X-Git-Url: https://ginac.de/CLN/cln.git//cln.git?a=blobdiff_plain;ds=inline;f=include%2Fcln%2Fmodinteger.h;h=7830286638e91c65fd867898c27d4b2a0c352570;hb=2ee2f088755c856d4eed429ed7fcdf4ca519ae00;hp=cc613be9f8e03f0c6365fe3c050d9ec978c7a443;hpb=0c3376e34488b339b826a6ee7d9f2bc6c4e6edac;p=cln.git

diff --git a/include/cln/modinteger.h b/include/cln/modinteger.h
index cc613be..7830286 100644
--- a/include/cln/modinteger.h
+++ b/include/cln/modinteger.h
@@ -11,7 +11,7 @@
 #include "cln/io.h"
 #include "cln/proplist.h"
 #include "cln/condition.h"
-#include "cln/abort.h"
+#include "cln/exception.h"
 #undef random // Linux defines random() as a macro!
 
 namespace cln {
@@ -46,7 +46,16 @@ extern const cl_modint_ring cl_modint0_ring;
 // Default constructor. This avoids dealing with NULL pointers.
 inline cl_modint_ring::cl_modint_ring ()
 	: cl_ring (as_cl_private_thing(cl_modint0_ring)) {}
-CL_REQUIRE(cl_MI)
+
+class cl_MI_init_helper
+{
+	static int count;
+public:
+	cl_MI_init_helper();
+	~cl_MI_init_helper();
+};
+static cl_MI_init_helper cl_MI_init_helper_instance;
+
 // Copy constructor and assignment operator.
 CL_DEFINE_COPY_CONSTRUCTOR2(cl_modint_ring,cl_ring)
 CL_DEFINE_ASSIGNMENT_OPERATOR(cl_modint_ring,cl_modint_ring)
@@ -141,9 +150,9 @@ public:
 	cl_MI_x (cl_composite_condition* c) : value (), condition (c) {}
 	cl_MI_x (const cl_MI& x) : value (x), condition (NULL) {}
 	// Cast operators.
-	//operator cl_MI& () { if (condition) cl_abort(); return value; }
-	//operator const cl_MI& () const { if (condition) cl_abort(); return value; }
-	operator cl_MI () const { if (condition) cl_abort(); return value; }
+	//operator cl_MI& () { if (condition) throw runtime_exception(); return value; }
+	//operator const cl_MI& () const { if (condition) throw runtime_exception(); return value; }
+	operator cl_MI () const { if (condition) throw runtime_exception(); return value; }
 };
 
 
@@ -153,14 +162,14 @@ struct _cl_modint_setops /* cf. _cl_ring_setops */ {
 	// print
 	void (* fprint) (cl_heap_modint_ring* R, std::ostream& stream, const _cl_MI& x);
 	// equality
-	cl_boolean (* equal) (cl_heap_modint_ring* R, const _cl_MI& x, const _cl_MI& y);
+	bool (* equal) (cl_heap_modint_ring* R, const _cl_MI& x, const _cl_MI& y);
 	// random number
 	const _cl_MI (* random) (cl_heap_modint_ring* R, random_state& randomstate);
 };
 struct _cl_modint_addops /* cf. _cl_ring_addops */ {
 	// 0
 	const _cl_MI (* zero) (cl_heap_modint_ring* R);
-	cl_boolean (* zerop) (cl_heap_modint_ring* R, const _cl_MI& x);
+	bool (* zerop) (cl_heap_modint_ring* R, const _cl_MI& x);
 	// x+y
 	const _cl_MI (* plus) (cl_heap_modint_ring* R, const _cl_MI& x, const _cl_MI& y);
 	// x-y
@@ -216,13 +225,13 @@ public:
 	// Low-level operations.
 	void _fprint (std::ostream& stream, const _cl_MI& x)
 		{ setops->fprint(this,stream,x); }
-	cl_boolean _equal (const _cl_MI& x, const _cl_MI& y)
+	bool _equal (const _cl_MI& x, const _cl_MI& y)
 		{ return setops->equal(this,x,y); }
 	const _cl_MI _random (random_state& randomstate)
 		{ return setops->random(this,randomstate); }
 	const _cl_MI _zero ()
 		{ return addops->zero(this); }
-	cl_boolean _zerop (const _cl_MI& x)
+	bool _zerop (const _cl_MI& x)
 		{ return addops->zerop(this,x); }
 	const _cl_MI _plus (const _cl_MI& x, const _cl_MI& y)
 		{ return addops->plus(this,x,y); }
@@ -253,13 +262,13 @@ public:
 	// High-level operations.
 	void fprint (std::ostream& stream, const cl_MI& x)
 	{
-		if (!(x.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
 		_fprint(stream,x);
 	}
-	cl_boolean equal (const cl_MI& x, const cl_MI& y)
+	bool equal (const cl_MI& x, const cl_MI& y)
 	{
-		if (!(x.ring() == this)) cl_abort();
-		if (!(y.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
+		if (!(y.ring() == this)) throw runtime_exception();
 		return _equal(x,y);
 	}
 	const cl_MI random (random_state& randomstate = default_random_state)
@@ -270,26 +279,26 @@ public:
 	{
 		return cl_MI(this,_zero());
 	}
-	cl_boolean zerop (const cl_MI& x)
+	bool zerop (const cl_MI& x)
 	{
-		if (!(x.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
 		return _zerop(x);
 	}
 	const cl_MI plus (const cl_MI& x, const cl_MI& y)
 	{
-		if (!(x.ring() == this)) cl_abort();
-		if (!(y.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
+		if (!(y.ring() == this)) throw runtime_exception();
 		return cl_MI(this,_plus(x,y));
 	}
 	const cl_MI minus (const cl_MI& x, const cl_MI& y)
 	{
-		if (!(x.ring() == this)) cl_abort();
-		if (!(y.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
+		if (!(y.ring() == this)) throw runtime_exception();
 		return cl_MI(this,_minus(x,y));
 	}
 	const cl_MI uminus (const cl_MI& x)
 	{
-		if (!(x.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
 		return cl_MI(this,_uminus(x));
 	}
 	const cl_MI one ()
@@ -302,34 +311,34 @@ public:
 	}
 	const cl_MI mul (const cl_MI& x, const cl_MI& y)
 	{
-		if (!(x.ring() == this)) cl_abort();
-		if (!(y.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
+		if (!(y.ring() == this)) throw runtime_exception();
 		return cl_MI(this,_mul(x,y));
 	}
 	const cl_MI square (const cl_MI& x)
 	{
-		if (!(x.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
 		return cl_MI(this,_square(x));
 	}
 	const cl_MI expt_pos (const cl_MI& x, const cl_I& y)
 	{
-		if (!(x.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
 		return cl_MI(this,_expt_pos(x,y));
 	}
 	const cl_MI_x recip (const cl_MI& x)
 	{
-		if (!(x.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
 		return _recip(x);
 	}
 	const cl_MI_x div (const cl_MI& x, const cl_MI& y)
 	{
-		if (!(x.ring() == this)) cl_abort();
-		if (!(y.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
+		if (!(y.ring() == this)) throw runtime_exception();
 		return _div(x,y);
 	}
 	const cl_MI_x expt (const cl_MI& x, const cl_I& y)
 	{
-		if (!(x.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
 		return _expt(x,y);
 	}
 	const cl_I reduce_modulo (const cl_I& x)
@@ -338,34 +347,27 @@ public:
 	}
 	const cl_I retract (const cl_MI& x)
 	{
-		if (!(x.ring() == this)) cl_abort();
+		if (!(x.ring() == this)) throw runtime_exception();
 		return _retract(x);
 	}
 	// Miscellaneous.
-	sintL bits; // number of bits needed to represent a representative, or -1
+	sintC bits; // number of bits needed to represent a representative, or -1
 	int log2_bits; // log_2(bits), or -1
 	// Property operations.
 	cl_property* get_property (const cl_symbol& key)
 		{ return properties.get_property(key); }
 	void add_property (cl_property* new_property)
 		{ properties.add_property(new_property); }
-// Constructor.
+// Constructor / destructor.
 	cl_heap_modint_ring (cl_I m, cl_modint_setops*, cl_modint_addops*, cl_modint_mulops*);
-// This class is intented to be subclassable, hence needs a virtual destructor.
-	virtual ~cl_heap_modint_ring () {}
-private:
-	virtual void dummy ();
+	~cl_heap_modint_ring () {}
 };
 #define SUBCLASS_cl_heap_modint_ring() \
   SUBCLASS_cl_heap_ring()
 
 // Lookup or create a modular integer ring  Z/mZ
 extern const cl_modint_ring find_modint_ring (const cl_I& m);
-CL_REQUIRE(cl_MI)
-
-// Runtime typing support.
-extern cl_class cl_class_modint_ring;
-
+static cl_MI_init_helper cl_MI_init_helper_instance2;
 
 // Operations on modular integers.
 
@@ -395,8 +397,8 @@ inline const cl_MI operator- (const cl_I& x, const cl_MI& y)
 	{ return y.ring()->minus(y.ring()->canonhom(x),y); }
 
 // Shifts.
-extern const cl_MI operator<< (const cl_MI& x, sintL y); // assume 0 <= y < 2^31
-extern const cl_MI operator>> (const cl_MI& x, sintL y); // assume m odd, 0 <= y < 2^31
+extern const cl_MI operator<< (const cl_MI& x, sintC y); // assume 0 <= y < 2^(intCsize-1)
+extern const cl_MI operator>> (const cl_MI& x, sintC y); // assume m odd, 0 <= y < 2^(intCsize-1)
 
 // Equality.
 inline bool operator== (const cl_MI& x, const cl_MI& y)
@@ -413,7 +415,7 @@ inline bool operator!= (const cl_I& x, const cl_MI& y)
 	{ return !y.ring()->equal(y.ring()->canonhom(x),y); }
 
 // Compare against 0.
-inline cl_boolean zerop (const cl_MI& x)
+inline bool zerop (const cl_MI& x)
 	{ return x.ring()->zerop(x); }
 
 // Multiply.
@@ -456,9 +458,7 @@ inline const cl_MI operator* (const cl_MI& x, const cl_I& y)
 // Debugging support.
 #ifdef CL_DEBUG
 extern int cl_MI_debug_module;
-static void* const cl_MI_debug_dummy[] = { &cl_MI_debug_dummy,
-	&cl_MI_debug_module
-};
+CL_FORCE_LINK(cl_MI_debug_dummy, cl_MI_debug_module)
 #endif
 
 }  // namespace cln