// Univariate Polynomials. #ifndef _CL_UNIVPOLY_H #define _CL_UNIVPOLY_H #include "cl_object.h" #include "cl_ring.h" #include "cl_malloc.h" #include "cl_proplist.h" #include "cl_symbol.h" #include "cl_V.h" #include "cl_io.h" // To protect against mixing elements of different polynomial rings, every // polynomial carries its ring in itself. class cl_heap_univpoly_ring; class cl_univpoly_ring : public cl_ring { public: // Default constructor. cl_univpoly_ring (); // Constructor. Takes a cl_heap_univpoly_ring*, increments its refcount. cl_univpoly_ring (cl_heap_univpoly_ring* r); // Private constructor. Doesn't increment the refcount. cl_univpoly_ring (cl_private_thing); // Copy constructor. cl_univpoly_ring (const cl_univpoly_ring&); // Assignment operator. cl_univpoly_ring& operator= (const cl_univpoly_ring&); // Automatic dereferencing. cl_heap_univpoly_ring* operator-> () const { return (cl_heap_univpoly_ring*)heappointer; } }; // Copy constructor and assignment operator. CL_DEFINE_COPY_CONSTRUCTOR2(cl_univpoly_ring,cl_ring) CL_DEFINE_ASSIGNMENT_OPERATOR(cl_univpoly_ring,cl_univpoly_ring) // Normal constructor for `cl_univpoly_ring'. inline cl_univpoly_ring::cl_univpoly_ring (cl_heap_univpoly_ring* r) : cl_ring ((cl_private_thing) (cl_inc_pointer_refcount((cl_heap*)r), r)) {} // Private constructor for `cl_univpoly_ring'. inline cl_univpoly_ring::cl_univpoly_ring (cl_private_thing p) : cl_ring (p) {} // Operations on univariate polynomial rings. inline bool operator== (const cl_univpoly_ring& R1, const cl_univpoly_ring& R2) { return (R1.pointer == R2.pointer); } inline bool operator!= (const cl_univpoly_ring& R1, const cl_univpoly_ring& R2) { return (R1.pointer != R2.pointer); } inline bool operator== (const cl_univpoly_ring& R1, cl_heap_univpoly_ring* R2) { return (R1.pointer == R2); } inline bool operator!= (const cl_univpoly_ring& R1, cl_heap_univpoly_ring* R2) { return (R1.pointer != R2); } // Representation of a univariate polynomial. class _cl_UP /* cf. _cl_ring_element */ { public: cl_gcpointer rep; // vector of coefficients, a cl_V_any // Default constructor. _cl_UP (); public: /* ugh */ // Constructor. _cl_UP (const cl_heap_univpoly_ring* R, const cl_V_any& r) : rep (as_cl_private_thing(r)) { (void)R; } _cl_UP (const cl_univpoly_ring& R, const cl_V_any& r) : rep (as_cl_private_thing(r)) { (void)R; } public: // Conversion. CL_DEFINE_CONVERTER(_cl_ring_element) public: // Ability to place an object at a given address. void* operator new (size_t size) { return cl_malloc_hook(size); } void* operator new (size_t size, _cl_UP* ptr) { (void)size; return ptr; } void operator delete (void* ptr) { cl_free_hook(ptr); } }; class cl_UP /* cf. cl_ring_element */ : public _cl_UP { protected: cl_univpoly_ring _ring; // polynomial ring (references the base ring) public: const cl_univpoly_ring& ring () const { return _ring; } private: // Default constructor. cl_UP (); public: /* ugh */ // Constructor. cl_UP (const cl_univpoly_ring& R, const cl_V_any& r) : _cl_UP (R,r), _ring (R) {} cl_UP (const cl_univpoly_ring& R, const _cl_UP& r) : _cl_UP (r), _ring (R) {} public: // Conversion. CL_DEFINE_CONVERTER(cl_ring_element) // Destructive modification. void set_coeff (uintL index, const cl_ring_element& y); void finalize(); // Evaluation. const cl_ring_element operator() (const cl_ring_element& y) const; // Debugging output. void debug_print () const; public: // Ability to place an object at a given address. void* operator new (size_t size) { return cl_malloc_hook(size); } void* operator new (size_t size, cl_UP* ptr) { (void)size; return ptr; } void operator delete (void* ptr) { cl_free_hook(ptr); } }; // Ring operations. struct _cl_univpoly_setops /* cf. _cl_ring_setops */ { // print void (* fprint) (cl_heap_univpoly_ring* R, cl_ostream stream, const _cl_UP& x); // equality // (Be careful: This is not well-defined for polynomials with // floating-point coefficients.) cl_boolean (* equal) (cl_heap_univpoly_ring* R, const _cl_UP& x, const _cl_UP& y); }; struct _cl_univpoly_addops /* cf. _cl_ring_addops */ { // 0 const _cl_UP (* zero) (cl_heap_univpoly_ring* R); cl_boolean (* zerop) (cl_heap_univpoly_ring* R, const _cl_UP& x); // x+y const _cl_UP (* plus) (cl_heap_univpoly_ring* R, const _cl_UP& x, const _cl_UP& y); // x-y const _cl_UP (* minus) (cl_heap_univpoly_ring* R, const _cl_UP& x, const _cl_UP& y); // -x const _cl_UP (* uminus) (cl_heap_univpoly_ring* R, const _cl_UP& x); }; struct _cl_univpoly_mulops /* cf. _cl_ring_mulops */ { // 1 const _cl_UP (* one) (cl_heap_univpoly_ring* R); // canonical homomorphism const _cl_UP (* canonhom) (cl_heap_univpoly_ring* R, const cl_I& x); // x*y const _cl_UP (* mul) (cl_heap_univpoly_ring* R, const _cl_UP& x, const _cl_UP& y); // x^2 const _cl_UP (* square) (cl_heap_univpoly_ring* R, const _cl_UP& x); // x^y, y Integer >0 const _cl_UP (* expt_pos) (cl_heap_univpoly_ring* R, const _cl_UP& x, const cl_I& y); }; struct _cl_univpoly_modulops { // scalar multiplication x*y const _cl_UP (* scalmul) (cl_heap_univpoly_ring* R, const cl_ring_element& x, const _cl_UP& y); }; struct _cl_univpoly_polyops { // degree sintL (* degree) (cl_heap_univpoly_ring* R, const _cl_UP& x); // monomial const _cl_UP (* monomial) (cl_heap_univpoly_ring* R, const cl_ring_element& x, uintL e); // coefficient (0 if index>degree) const cl_ring_element (* coeff) (cl_heap_univpoly_ring* R, const _cl_UP& x, uintL index); // create new polynomial, bounded degree const _cl_UP (* create) (cl_heap_univpoly_ring* R, sintL deg); // set coefficient in new polynomial void (* set_coeff) (cl_heap_univpoly_ring* R, _cl_UP& x, uintL index, const cl_ring_element& y); // finalize polynomial void (* finalize) (cl_heap_univpoly_ring* R, _cl_UP& x); // evaluate, substitute an element of R const cl_ring_element (* eval) (cl_heap_univpoly_ring* R, const _cl_UP& x, const cl_ring_element& y); }; #if defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ < 8) // workaround two g++-2.7.0 bugs #define cl_univpoly_setops _cl_univpoly_setops #define cl_univpoly_addops _cl_univpoly_addops #define cl_univpoly_mulops _cl_univpoly_mulops #define cl_univpoly_modulops _cl_univpoly_modulops #define cl_univpoly_polyops _cl_univpoly_polyops #else typedef const _cl_univpoly_setops cl_univpoly_setops; typedef const _cl_univpoly_addops cl_univpoly_addops; typedef const _cl_univpoly_mulops cl_univpoly_mulops; typedef const _cl_univpoly_modulops cl_univpoly_modulops; typedef const _cl_univpoly_polyops cl_univpoly_polyops; #endif // Representation of a univariate polynomial ring. class cl_heap_univpoly_ring /* cf. cl_heap_ring */ : public cl_heap { SUBCLASS_cl_heap_ring() private: cl_property_list properties; protected: cl_univpoly_setops* setops; cl_univpoly_addops* addops; cl_univpoly_mulops* mulops; cl_univpoly_modulops* modulops; cl_univpoly_polyops* polyops; protected: cl_ring _basering; // the coefficients are elements of this ring public: const cl_ring& basering () const { return _basering; } public: // Low-level operations. void _fprint (cl_ostream stream, const _cl_UP& x) { setops->fprint(this,stream,x); } cl_boolean _equal (const _cl_UP& x, const _cl_UP& y) { return setops->equal(this,x,y); } const _cl_UP _zero () { return addops->zero(this); } cl_boolean _zerop (const _cl_UP& x) { return addops->zerop(this,x); } const _cl_UP _plus (const _cl_UP& x, const _cl_UP& y) { return addops->plus(this,x,y); } const _cl_UP _minus (const _cl_UP& x, const _cl_UP& y) { return addops->minus(this,x,y); } const _cl_UP _uminus (const _cl_UP& x) { return addops->uminus(this,x); } const _cl_UP _one () { return mulops->one(this); } const _cl_UP _canonhom (const cl_I& x) { return mulops->canonhom(this,x); } const _cl_UP _mul (const _cl_UP& x, const _cl_UP& y) { return mulops->mul(this,x,y); } const _cl_UP _square (const _cl_UP& x) { return mulops->square(this,x); } const _cl_UP _expt_pos (const _cl_UP& x, const cl_I& y) { return mulops->expt_pos(this,x,y); } const _cl_UP _scalmul (const cl_ring_element& x, const _cl_UP& y) { return modulops->scalmul(this,x,y); } sintL _degree (const _cl_UP& x) { return polyops->degree(this,x); } const _cl_UP _monomial (const cl_ring_element& x, uintL e) { return polyops->monomial(this,x,e); } const cl_ring_element _coeff (const _cl_UP& x, uintL index) { return polyops->coeff(this,x,index); } const _cl_UP _create (sintL deg) { return polyops->create(this,deg); } void _set_coeff (_cl_UP& x, uintL index, const cl_ring_element& y) { polyops->set_coeff(this,x,index,y); } void _finalize (_cl_UP& x) { polyops->finalize(this,x); } const cl_ring_element _eval (const _cl_UP& x, const cl_ring_element& y) { return polyops->eval(this,x,y); } // High-level operations. void fprint (cl_ostream stream, const cl_UP& x) { if (!(x.ring() == this)) cl_abort(); _fprint(stream,x); } cl_boolean equal (const cl_UP& x, const cl_UP& y) { if (!(x.ring() == this)) cl_abort(); if (!(y.ring() == this)) cl_abort(); return _equal(x,y); } const cl_UP zero () { return cl_UP(this,_zero()); } cl_boolean zerop (const cl_UP& x) { if (!(x.ring() == this)) cl_abort(); return _zerop(x); } const cl_UP plus (const cl_UP& x, const cl_UP& y) { if (!(x.ring() == this)) cl_abort(); if (!(y.ring() == this)) cl_abort(); return cl_UP(this,_plus(x,y)); } const cl_UP minus (const cl_UP& x, const cl_UP& y) { if (!(x.ring() == this)) cl_abort(); if (!(y.ring() == this)) cl_abort(); return cl_UP(this,_minus(x,y)); } const cl_UP uminus (const cl_UP& x) { if (!(x.ring() == this)) cl_abort(); return cl_UP(this,_uminus(x)); } const cl_UP one () { return cl_UP(this,_one()); } const cl_UP canonhom (const cl_I& x) { return cl_UP(this,_canonhom(x)); } const cl_UP mul (const cl_UP& x, const cl_UP& y) { if (!(x.ring() == this)) cl_abort(); if (!(y.ring() == this)) cl_abort(); return cl_UP(this,_mul(x,y)); } const cl_UP square (const cl_UP& x) { if (!(x.ring() == this)) cl_abort(); return cl_UP(this,_square(x)); } const cl_UP expt_pos (const cl_UP& x, const cl_I& y) { if (!(x.ring() == this)) cl_abort(); return cl_UP(this,_expt_pos(x,y)); } const cl_UP scalmul (const cl_ring_element& x, const cl_UP& y) { if (!(y.ring() == this)) cl_abort(); return cl_UP(this,_scalmul(x,y)); } sintL degree (const cl_UP& x) { if (!(x.ring() == this)) cl_abort(); return _degree(x); } const cl_UP monomial (const cl_ring_element& x, uintL e) { return cl_UP(this,_monomial(x,e)); } const cl_ring_element coeff (const cl_UP& x, uintL index) { if (!(x.ring() == this)) cl_abort(); return _coeff(x,index); } const cl_UP create (sintL deg) { return cl_UP(this,_create(deg)); } void set_coeff (cl_UP& x, uintL index, const cl_ring_element& y) { if (!(x.ring() == this)) cl_abort(); _set_coeff(x,index,y); } void finalize (cl_UP& x) { if (!(x.ring() == this)) cl_abort(); _finalize(x); } const cl_ring_element eval (const cl_UP& x, const cl_ring_element& y) { if (!(x.ring() == this)) cl_abort(); return _eval(x,y); } // 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. cl_heap_univpoly_ring (const cl_ring& r, cl_univpoly_setops*, cl_univpoly_addops*, cl_univpoly_mulops*, cl_univpoly_modulops*, cl_univpoly_polyops*); // This class is intented to be subclassable, hence needs a virtual destructor. virtual ~cl_heap_univpoly_ring () {} private: virtual void dummy (); }; #define SUBCLASS_cl_heap_univpoly_ring() \ SUBCLASS_cl_heap_ring() // Lookup or create the "standard" univariate polynomial ring over a ring r. extern const cl_univpoly_ring cl_find_univpoly_ring (const cl_ring& r); //CL_REQUIRE(cl_UP_unnamed) // Lookup or create a univariate polynomial ring with a named variable over r. extern const cl_univpoly_ring cl_find_univpoly_ring (const cl_ring& r, const cl_symbol& varname); //CL_REQUIRE(cl_UP_named) CL_REQUIRE(cl_UP) // Runtime typing support. extern cl_class cl_class_univpoly_ring; // Operations on polynomials. // Output. inline void fprint (cl_ostream stream, const cl_UP& x) { x.ring()->fprint(stream,x); } CL_DEFINE_PRINT_OPERATOR(cl_UP) // Add. inline const cl_UP operator+ (const cl_UP& x, const cl_UP& y) { return x.ring()->plus(x,y); } // Negate. inline const cl_UP operator- (const cl_UP& x) { return x.ring()->uminus(x); } // Subtract. inline const cl_UP operator- (const cl_UP& x, const cl_UP& y) { return x.ring()->minus(x,y); } // Equality. inline bool operator== (const cl_UP& x, const cl_UP& y) { return x.ring()->equal(x,y); } inline bool operator!= (const cl_UP& x, const cl_UP& y) { return !x.ring()->equal(x,y); } // Compare against 0. inline cl_boolean zerop (const cl_UP& x) { return x.ring()->zerop(x); } // Multiply. inline const cl_UP operator* (const cl_UP& x, const cl_UP& y) { return x.ring()->mul(x,y); } // Squaring. inline const cl_UP square (const cl_UP& x) { return x.ring()->square(x); } // Exponentiation x^y, where y > 0. inline const cl_UP expt_pos (const cl_UP& x, const cl_I& y) { return x.ring()->expt_pos(x,y); } // Scalar multiplication. #if 0 // less efficient inline const cl_UP operator* (const cl_I& x, const cl_UP& y) { return y.ring()->mul(y.ring()->canonhom(x),y); } inline const cl_UP operator* (const cl_UP& x, const cl_I& y) { return x.ring()->mul(x.ring()->canonhom(y),x); } #endif inline const cl_UP operator* (const cl_I& x, const cl_UP& y) { return y.ring()->scalmul(y.ring()->basering()->canonhom(x),y); } inline const cl_UP operator* (const cl_UP& x, const cl_I& y) { return x.ring()->scalmul(x.ring()->basering()->canonhom(y),x); } inline const cl_UP operator* (const cl_ring_element& x, const cl_UP& y) { return y.ring()->scalmul(x,y); } inline const cl_UP operator* (const cl_UP& x, const cl_ring_element& y) { return x.ring()->scalmul(y,x); } // Degree. inline sintL degree (const cl_UP& x) { return x.ring()->degree(x); } // Coefficient. inline const cl_ring_element coeff (const cl_UP& x, uintL index) { return x.ring()->coeff(x,index); } // Destructive modification. inline void set_coeff (cl_UP& x, uintL index, const cl_ring_element& y) { x.ring()->set_coeff(x,index,y); } inline void finalize (cl_UP& x) { x.ring()->finalize(x); } inline void cl_UP::set_coeff (uintL index, const cl_ring_element& y) { ring()->set_coeff(*this,index,y); } inline void cl_UP::finalize () { ring()->finalize(*this); } // Evaluation. (No extension of the base ring allowed here for now.) inline const cl_ring_element cl_UP::operator() (const cl_ring_element& y) const { return ring()->eval(*this,y); } // Derivative. extern const cl_UP deriv (const cl_UP& x); // Ring of uninitialized elements. // Any operation results in a run-time error. extern const cl_univpoly_ring cl_no_univpoly_ring; extern cl_class cl_class_no_univpoly_ring; CL_REQUIRE(cl_UP_no_ring) inline cl_univpoly_ring::cl_univpoly_ring () : cl_ring (as_cl_private_thing(cl_no_univpoly_ring)) {} inline _cl_UP::_cl_UP () : rep ((cl_private_thing) cl_combine(cl_FN_tag,0)) {} inline cl_UP::cl_UP () : _cl_UP (), _ring () {} // Debugging support. #ifdef CL_DEBUG extern int cl_UP_debug_module; static void* const cl_UP_debug_dummy[] = { &cl_UP_debug_dummy, &cl_UP_debug_module }; #endif #endif /* _CL_UNIVPOLY_H */ // Templates for univariate polynomials of complex/real/rational/integers. #ifdef notyet // Unfortunately, this is not usable now, because of gcc-2.7 bugs: // - A template inline function is not inline in the first function that // uses it. // - Argument matching bug: User-defined conversions are not tried (or // tried with too low priority) for template functions w.r.t. normal // functions. For example, a call expt_pos(cl_UP_specialized,int) // is compiled as expt_pos(const cl_UP&, const cl_I&) instead of // expt_pos(const cl_UP_specialized&, const cl_I&). // It will, however, be usable when gcc-2.8 is released. #if defined(_CL_UNIVPOLY_COMPLEX_H) || defined(_CL_UNIVPOLY_REAL_H) || defined(_CL_UNIVPOLY_RATIONAL_H) || defined(_CL_UNIVPOLY_INTEGER_H) #ifndef _CL_UNIVPOLY_AUX_H // Normal univariate polynomials with stricter static typing: // `class T' instead of `cl_ring_element'. template class cl_univpoly_specialized_ring; template class cl_UP_specialized; template class cl_heap_univpoly_specialized_ring; template class cl_univpoly_specialized_ring : public cl_univpoly_ring { public: // Default constructor. cl_univpoly_specialized_ring () : cl_univpoly_ring () {} // Copy constructor. cl_univpoly_specialized_ring (const cl_univpoly_specialized_ring&); // Assignment operator. cl_univpoly_specialized_ring& operator= (const cl_univpoly_specialized_ring&); // Automatic dereferencing. cl_heap_univpoly_specialized_ring* operator-> () const { return (cl_heap_univpoly_specialized_ring*)heappointer; } }; // Copy constructor and assignment operator. template _CL_DEFINE_COPY_CONSTRUCTOR2(cl_univpoly_specialized_ring,cl_univpoly_specialized_ring,cl_univpoly_ring) template CL_DEFINE_ASSIGNMENT_OPERATOR(cl_univpoly_specialized_ring,cl_univpoly_specialized_ring) template class cl_UP_specialized : public cl_UP { public: const cl_univpoly_specialized_ring& ring () const { return The(cl_univpoly_specialized_ring)(_ring); } // Conversion. CL_DEFINE_CONVERTER(cl_ring_element) // Destructive modification. void set_coeff (uintL index, const T& y); void finalize(); // Evaluation. const T operator() (const T& y) const; public: // Ability to place an object at a given address. void* operator new (size_t size) { return cl_malloc_hook(size); } void* operator new (size_t size, cl_UP_specialized* ptr) { (void)size; return ptr; } void operator delete (void* ptr) { cl_free_hook(ptr); } }; template class cl_heap_univpoly_specialized_ring : public cl_heap_univpoly_ring { SUBCLASS_cl_heap_univpoly_ring() // High-level operations. void fprint (cl_ostream stream, const cl_UP_specialized& x) { cl_heap_univpoly_ring::fprint(stream,x); } cl_boolean equal (const cl_UP_specialized& x, const cl_UP_specialized& y) { return cl_heap_univpoly_ring::equal(x,y); } const cl_UP_specialized zero () { return The2(cl_UP_specialized)(cl_heap_univpoly_ring::zero()); } cl_boolean zerop (const cl_UP_specialized& x) { return cl_heap_univpoly_ring::zerop(x); } const cl_UP_specialized plus (const cl_UP_specialized& x, const cl_UP_specialized& y) { return The2(cl_UP_specialized)(cl_heap_univpoly_ring::plus(x,y)); } const cl_UP_specialized minus (const cl_UP_specialized& x, const cl_UP_specialized& y) { return The2(cl_UP_specialized)(cl_heap_univpoly_ring::minus(x,y)); } const cl_UP_specialized uminus (const cl_UP_specialized& x) { return The2(cl_UP_specialized)(cl_heap_univpoly_ring::uminus(x)); } const cl_UP_specialized one () { return The2(cl_UP_specialized)(cl_heap_univpoly_ring::one()); } const cl_UP_specialized canonhom (const cl_I& x) { return The2(cl_UP_specialized)(cl_heap_univpoly_ring::canonhom(x)); } const cl_UP_specialized mul (const cl_UP_specialized& x, const cl_UP_specialized& y) { return The2(cl_UP_specialized)(cl_heap_univpoly_ring::mul(x,y)); } const cl_UP_specialized square (const cl_UP_specialized& x) { return The2(cl_UP_specialized)(cl_heap_univpoly_ring::square(x)); } const cl_UP_specialized expt_pos (const cl_UP_specialized& x, const cl_I& y) { return The2(cl_UP_specialized)(cl_heap_univpoly_ring::expt_pos(x,y)); } const cl_UP_specialized scalmul (const T& x, const cl_UP_specialized& y) { return The2(cl_UP_specialized)(cl_heap_univpoly_ring::scalmul(x,y)); } sintL degree (const cl_UP_specialized& x) { return cl_heap_univpoly_ring::degree(x); } const cl_UP_specialized monomial (const T& x, uintL e) { return The2(cl_UP_specialized)(cl_heap_univpoly_ring::monomial(cl_ring_element(cl_C_ring??,x),e)); } const T coeff (const cl_UP_specialized& x, uintL index) { return The(T)(cl_heap_univpoly_ring::coeff(x,index)); } const cl_UP_specialized create (sintL deg) { return The2(cl_UP_specialized)(cl_heap_univpoly_ring::create(deg)); } void set_coeff (cl_UP_specialized& x, uintL index, const T& y) { cl_heap_univpoly_ring::set_coeff(x,index,cl_ring_element(cl_C_ring??,y)); } void finalize (cl_UP_specialized& x) { cl_heap_univpoly_ring::finalize(x); } const T eval (const cl_UP_specialized& x, const T& y) { return The(T)(cl_heap_univpoly_ring::eval(x,cl_ring_element(cl_C_ring??,y))); } private: // No need for any constructors. cl_heap_univpoly_specialized_ring (); }; // Lookup of polynomial rings. template inline const cl_univpoly_specialized_ring cl_find_univpoly_ring (const cl_specialized_number_ring& r) { return The(cl_univpoly_specialized_ring) (cl_find_univpoly_ring((const cl_ring&)r)); } template inline const cl_univpoly_specialized_ring cl_find_univpoly_ring (const cl_specialized_number_ring& r, const cl_symbol& varname) { return The(cl_univpoly_specialized_ring) (cl_find_univpoly_ring((const cl_ring&)r,varname)); } // Operations on polynomials. // Add. template inline const cl_UP_specialized operator+ (const cl_UP_specialized& x, const cl_UP_specialized& y) { return x.ring()->plus(x,y); } // Negate. template inline const cl_UP_specialized operator- (const cl_UP_specialized& x) { return x.ring()->uminus(x); } // Subtract. template inline const cl_UP_specialized operator- (const cl_UP_specialized& x, const cl_UP_specialized& y) { return x.ring()->minus(x,y); } // Multiply. template inline const cl_UP_specialized operator* (const cl_UP_specialized& x, const cl_UP_specialized& y) { return x.ring()->mul(x,y); } // Squaring. template inline const cl_UP_specialized square (const cl_UP_specialized& x) { return x.ring()->square(x); } // Exponentiation x^y, where y > 0. template inline const cl_UP_specialized expt_pos (const cl_UP_specialized& x, const cl_I& y) { return x.ring()->expt_pos(x,y); } // Scalar multiplication. // Need more discrimination on T ?? template inline const cl_UP_specialized operator* (const cl_I& x, const cl_UP_specialized& y) { return y.ring()->mul(y.ring()->canonhom(x),y); } template inline const cl_UP_specialized operator* (const cl_UP_specialized& x, const cl_I& y) { return x.ring()->mul(x.ring()->canonhom(y),x); } template inline const cl_UP_specialized operator* (const T& x, const cl_UP_specialized& y) { return y.ring()->scalmul(x,y); } template inline const cl_UP_specialized operator* (const cl_UP_specialized& x, const T& y) { return x.ring()->scalmul(y,x); } // Coefficient. template inline const T coeff (const cl_UP_specialized& x, uintL index) { return x.ring()->coeff(x,index); } // Destructive modification. template inline void set_coeff (cl_UP_specialized& x, uintL index, const T& y) { x.ring()->set_coeff(x,index,y); } template inline void finalize (cl_UP_specialized& x) { x.ring()->finalize(x); } template inline void cl_UP_specialized::set_coeff (uintL index, const T& y) { ring()->set_coeff(*this,index,y); } template inline void cl_UP_specialized::finalize () { ring()->finalize(*this); } // Evaluation. (No extension of the base ring allowed here for now.) template inline const T cl_UP_specialized::operator() (const T& y) const { return ring()->eval(*this,y); } // Derivative. template inline const cl_UP_specialized deriv (const cl_UP_specialized& x) { return The(cl_UP_specialized)(deriv((const cl_UP&)x)); } #endif /* _CL_UNIVPOLY_AUX_H */ #endif #endif