1 // Univariate Polynomials.
6 #include "cln/object.h"
8 #include "cln/malloc.h"
9 #include "cln/proplist.h"
10 #include "cln/symbol.h"
16 // To protect against mixing elements of different polynomial rings, every
17 // polynomial carries its ring in itself.
19 class cl_heap_univpoly_ring;
21 class cl_univpoly_ring : public cl_ring {
23 // Default constructor.
25 // Constructor. Takes a cl_heap_univpoly_ring*, increments its refcount.
26 cl_univpoly_ring (cl_heap_univpoly_ring* r);
27 // Private constructor. Doesn't increment the refcount.
28 cl_univpoly_ring (cl_private_thing);
30 cl_univpoly_ring (const cl_univpoly_ring&);
31 // Assignment operator.
32 cl_univpoly_ring& operator= (const cl_univpoly_ring&);
33 // Automatic dereferencing.
34 cl_heap_univpoly_ring* operator-> () const
35 { return (cl_heap_univpoly_ring*)heappointer; }
37 // Copy constructor and assignment operator.
38 CL_DEFINE_COPY_CONSTRUCTOR2(cl_univpoly_ring,cl_ring)
39 CL_DEFINE_ASSIGNMENT_OPERATOR(cl_univpoly_ring,cl_univpoly_ring)
41 // Normal constructor for `cl_univpoly_ring'.
42 inline cl_univpoly_ring::cl_univpoly_ring (cl_heap_univpoly_ring* r)
43 : cl_ring ((cl_private_thing) (cl_inc_pointer_refcount((cl_heap*)r), r)) {}
44 // Private constructor for `cl_univpoly_ring'.
45 inline cl_univpoly_ring::cl_univpoly_ring (cl_private_thing p)
48 // Operations on univariate polynomial rings.
50 inline bool operator== (const cl_univpoly_ring& R1, const cl_univpoly_ring& R2)
51 { return (R1.pointer == R2.pointer); }
52 inline bool operator!= (const cl_univpoly_ring& R1, const cl_univpoly_ring& R2)
53 { return (R1.pointer != R2.pointer); }
54 inline bool operator== (const cl_univpoly_ring& R1, cl_heap_univpoly_ring* R2)
55 { return (R1.pointer == R2); }
56 inline bool operator!= (const cl_univpoly_ring& R1, cl_heap_univpoly_ring* R2)
57 { return (R1.pointer != R2); }
59 // Representation of a univariate polynomial.
61 class _cl_UP /* cf. _cl_ring_element */ {
63 cl_gcpointer rep; // vector of coefficients, a cl_V_any
64 // Default constructor.
68 _cl_UP (const cl_heap_univpoly_ring* R, const cl_V_any& r) : rep (as_cl_private_thing(r)) { (void)R; }
69 _cl_UP (const cl_univpoly_ring& R, const cl_V_any& r) : rep (as_cl_private_thing(r)) { (void)R; }
72 CL_DEFINE_CONVERTER(_cl_ring_element)
73 public: // Ability to place an object at a given address.
74 void* operator new (size_t size) { return malloc_hook(size); }
75 void* operator new (size_t size, void* ptr) { (void)size; return ptr; }
76 void operator delete (void* ptr) { free_hook(ptr); }
79 class cl_UP /* cf. cl_ring_element */ : public _cl_UP {
81 cl_univpoly_ring _ring; // polynomial ring (references the base ring)
83 const cl_univpoly_ring& ring () const { return _ring; }
85 // Default constructor.
89 cl_UP (const cl_univpoly_ring& R, const cl_V_any& r)
90 : _cl_UP (R,r), _ring (R) {}
91 cl_UP (const cl_univpoly_ring& R, const _cl_UP& r)
92 : _cl_UP (r), _ring (R) {}
95 CL_DEFINE_CONVERTER(cl_ring_element)
96 // Destructive modification.
97 void set_coeff (uintL index, const cl_ring_element& y);
100 const cl_ring_element operator() (const cl_ring_element& y) const;
102 void debug_print () const;
103 public: // Ability to place an object at a given address.
104 void* operator new (size_t size) { return malloc_hook(size); }
105 void* operator new (size_t size, void* ptr) { (void)size; return ptr; }
106 void operator delete (void* ptr) { free_hook(ptr); }
112 struct _cl_univpoly_setops /* cf. _cl_ring_setops */ {
114 void (* fprint) (cl_heap_univpoly_ring* R, std::ostream& stream, const _cl_UP& x);
116 // (Be careful: This is not well-defined for polynomials with
117 // floating-point coefficients.)
118 cl_boolean (* equal) (cl_heap_univpoly_ring* R, const _cl_UP& x, const _cl_UP& y);
120 struct _cl_univpoly_addops /* cf. _cl_ring_addops */ {
122 const _cl_UP (* zero) (cl_heap_univpoly_ring* R);
123 cl_boolean (* zerop) (cl_heap_univpoly_ring* R, const _cl_UP& x);
125 const _cl_UP (* plus) (cl_heap_univpoly_ring* R, const _cl_UP& x, const _cl_UP& y);
127 const _cl_UP (* minus) (cl_heap_univpoly_ring* R, const _cl_UP& x, const _cl_UP& y);
129 const _cl_UP (* uminus) (cl_heap_univpoly_ring* R, const _cl_UP& x);
131 struct _cl_univpoly_mulops /* cf. _cl_ring_mulops */ {
133 const _cl_UP (* one) (cl_heap_univpoly_ring* R);
134 // canonical homomorphism
135 const _cl_UP (* canonhom) (cl_heap_univpoly_ring* R, const cl_I& x);
137 const _cl_UP (* mul) (cl_heap_univpoly_ring* R, const _cl_UP& x, const _cl_UP& y);
139 const _cl_UP (* square) (cl_heap_univpoly_ring* R, const _cl_UP& x);
141 const _cl_UP (* expt_pos) (cl_heap_univpoly_ring* R, const _cl_UP& x, const cl_I& y);
143 struct _cl_univpoly_modulops {
144 // scalar multiplication x*y
145 const _cl_UP (* scalmul) (cl_heap_univpoly_ring* R, const cl_ring_element& x, const _cl_UP& y);
147 struct _cl_univpoly_polyops {
149 sintL (* degree) (cl_heap_univpoly_ring* R, const _cl_UP& x);
151 const _cl_UP (* monomial) (cl_heap_univpoly_ring* R, const cl_ring_element& x, uintL e);
152 // coefficient (0 if index>degree)
153 const cl_ring_element (* coeff) (cl_heap_univpoly_ring* R, const _cl_UP& x, uintL index);
154 // create new polynomial, bounded degree
155 const _cl_UP (* create) (cl_heap_univpoly_ring* R, sintL deg);
156 // set coefficient in new polynomial
157 void (* set_coeff) (cl_heap_univpoly_ring* R, _cl_UP& x, uintL index, const cl_ring_element& y);
158 // finalize polynomial
159 void (* finalize) (cl_heap_univpoly_ring* R, _cl_UP& x);
160 // evaluate, substitute an element of R
161 const cl_ring_element (* eval) (cl_heap_univpoly_ring* R, const _cl_UP& x, const cl_ring_element& y);
163 typedef const _cl_univpoly_setops cl_univpoly_setops;
164 typedef const _cl_univpoly_addops cl_univpoly_addops;
165 typedef const _cl_univpoly_mulops cl_univpoly_mulops;
166 typedef const _cl_univpoly_modulops cl_univpoly_modulops;
167 typedef const _cl_univpoly_polyops cl_univpoly_polyops;
169 // Representation of a univariate polynomial ring.
171 class cl_heap_univpoly_ring /* cf. cl_heap_ring */ : public cl_heap {
172 SUBCLASS_cl_heap_ring()
174 cl_property_list properties;
176 cl_univpoly_setops* setops;
177 cl_univpoly_addops* addops;
178 cl_univpoly_mulops* mulops;
179 cl_univpoly_modulops* modulops;
180 cl_univpoly_polyops* polyops;
182 cl_ring _basering; // the coefficients are elements of this ring
184 const cl_ring& basering () const { return _basering; }
186 // Low-level operations.
187 void _fprint (std::ostream& stream, const _cl_UP& x)
188 { setops->fprint(this,stream,x); }
189 cl_boolean _equal (const _cl_UP& x, const _cl_UP& y)
190 { return setops->equal(this,x,y); }
191 const _cl_UP _zero ()
192 { return addops->zero(this); }
193 cl_boolean _zerop (const _cl_UP& x)
194 { return addops->zerop(this,x); }
195 const _cl_UP _plus (const _cl_UP& x, const _cl_UP& y)
196 { return addops->plus(this,x,y); }
197 const _cl_UP _minus (const _cl_UP& x, const _cl_UP& y)
198 { return addops->minus(this,x,y); }
199 const _cl_UP _uminus (const _cl_UP& x)
200 { return addops->uminus(this,x); }
202 { return mulops->one(this); }
203 const _cl_UP _canonhom (const cl_I& x)
204 { return mulops->canonhom(this,x); }
205 const _cl_UP _mul (const _cl_UP& x, const _cl_UP& y)
206 { return mulops->mul(this,x,y); }
207 const _cl_UP _square (const _cl_UP& x)
208 { return mulops->square(this,x); }
209 const _cl_UP _expt_pos (const _cl_UP& x, const cl_I& y)
210 { return mulops->expt_pos(this,x,y); }
211 const _cl_UP _scalmul (const cl_ring_element& x, const _cl_UP& y)
212 { return modulops->scalmul(this,x,y); }
213 sintL _degree (const _cl_UP& x)
214 { return polyops->degree(this,x); }
215 const _cl_UP _monomial (const cl_ring_element& x, uintL e)
216 { return polyops->monomial(this,x,e); }
217 const cl_ring_element _coeff (const _cl_UP& x, uintL index)
218 { return polyops->coeff(this,x,index); }
219 const _cl_UP _create (sintL deg)
220 { return polyops->create(this,deg); }
221 void _set_coeff (_cl_UP& x, uintL index, const cl_ring_element& y)
222 { polyops->set_coeff(this,x,index,y); }
223 void _finalize (_cl_UP& x)
224 { polyops->finalize(this,x); }
225 const cl_ring_element _eval (const _cl_UP& x, const cl_ring_element& y)
226 { return polyops->eval(this,x,y); }
227 // High-level operations.
228 void fprint (std::ostream& stream, const cl_UP& x)
230 if (!(x.ring() == this)) cl_abort();
233 cl_boolean equal (const cl_UP& x, const cl_UP& y)
235 if (!(x.ring() == this)) cl_abort();
236 if (!(y.ring() == this)) cl_abort();
241 return cl_UP(this,_zero());
243 cl_boolean zerop (const cl_UP& x)
245 if (!(x.ring() == this)) cl_abort();
248 const cl_UP plus (const cl_UP& x, const cl_UP& y)
250 if (!(x.ring() == this)) cl_abort();
251 if (!(y.ring() == this)) cl_abort();
252 return cl_UP(this,_plus(x,y));
254 const cl_UP minus (const cl_UP& x, const cl_UP& y)
256 if (!(x.ring() == this)) cl_abort();
257 if (!(y.ring() == this)) cl_abort();
258 return cl_UP(this,_minus(x,y));
260 const cl_UP uminus (const cl_UP& x)
262 if (!(x.ring() == this)) cl_abort();
263 return cl_UP(this,_uminus(x));
267 return cl_UP(this,_one());
269 const cl_UP canonhom (const cl_I& x)
271 return cl_UP(this,_canonhom(x));
273 const cl_UP mul (const cl_UP& x, const cl_UP& y)
275 if (!(x.ring() == this)) cl_abort();
276 if (!(y.ring() == this)) cl_abort();
277 return cl_UP(this,_mul(x,y));
279 const cl_UP square (const cl_UP& x)
281 if (!(x.ring() == this)) cl_abort();
282 return cl_UP(this,_square(x));
284 const cl_UP expt_pos (const cl_UP& x, const cl_I& y)
286 if (!(x.ring() == this)) cl_abort();
287 return cl_UP(this,_expt_pos(x,y));
289 const cl_UP scalmul (const cl_ring_element& x, const cl_UP& y)
291 if (!(y.ring() == this)) cl_abort();
292 return cl_UP(this,_scalmul(x,y));
294 sintL degree (const cl_UP& x)
296 if (!(x.ring() == this)) cl_abort();
299 const cl_UP monomial (const cl_ring_element& x, uintL e)
301 return cl_UP(this,_monomial(x,e));
303 const cl_ring_element coeff (const cl_UP& x, uintL index)
305 if (!(x.ring() == this)) cl_abort();
306 return _coeff(x,index);
308 const cl_UP create (sintL deg)
310 return cl_UP(this,_create(deg));
312 void set_coeff (cl_UP& x, uintL index, const cl_ring_element& y)
314 if (!(x.ring() == this)) cl_abort();
315 _set_coeff(x,index,y);
317 void finalize (cl_UP& x)
319 if (!(x.ring() == this)) cl_abort();
322 const cl_ring_element eval (const cl_UP& x, const cl_ring_element& y)
324 if (!(x.ring() == this)) cl_abort();
327 // Property operations.
328 cl_property* get_property (const cl_symbol& key)
329 { return properties.get_property(key); }
330 void add_property (cl_property* new_property)
331 { properties.add_property(new_property); }
333 cl_heap_univpoly_ring (const cl_ring& r, cl_univpoly_setops*, cl_univpoly_addops*, cl_univpoly_mulops*, cl_univpoly_modulops*, cl_univpoly_polyops*);
334 // This class is intented to be subclassable, hence needs a virtual destructor.
335 virtual ~cl_heap_univpoly_ring () {}
337 virtual void dummy ();
339 #define SUBCLASS_cl_heap_univpoly_ring() \
340 SUBCLASS_cl_heap_ring()
343 // Lookup or create the "standard" univariate polynomial ring over a ring r.
344 extern const cl_univpoly_ring find_univpoly_ring (const cl_ring& r);
345 //CL_REQUIRE(cl_UP_unnamed)
347 // Lookup or create a univariate polynomial ring with a named variable over r.
348 extern const cl_univpoly_ring find_univpoly_ring (const cl_ring& r, const cl_symbol& varname);
349 //CL_REQUIRE(cl_UP_named)
353 // Runtime typing support.
354 extern cl_class cl_class_univpoly_ring;
357 // Operations on polynomials.
360 inline void fprint (std::ostream& stream, const cl_UP& x)
361 { x.ring()->fprint(stream,x); }
362 CL_DEFINE_PRINT_OPERATOR(cl_UP)
365 inline const cl_UP operator+ (const cl_UP& x, const cl_UP& y)
366 { return x.ring()->plus(x,y); }
369 inline const cl_UP operator- (const cl_UP& x)
370 { return x.ring()->uminus(x); }
373 inline const cl_UP operator- (const cl_UP& x, const cl_UP& y)
374 { return x.ring()->minus(x,y); }
377 inline bool operator== (const cl_UP& x, const cl_UP& y)
378 { return x.ring()->equal(x,y); }
379 inline bool operator!= (const cl_UP& x, const cl_UP& y)
380 { return !x.ring()->equal(x,y); }
382 // Compare against 0.
383 inline cl_boolean zerop (const cl_UP& x)
384 { return x.ring()->zerop(x); }
387 inline const cl_UP operator* (const cl_UP& x, const cl_UP& y)
388 { return x.ring()->mul(x,y); }
391 inline const cl_UP square (const cl_UP& x)
392 { return x.ring()->square(x); }
394 // Exponentiation x^y, where y > 0.
395 inline const cl_UP expt_pos (const cl_UP& x, const cl_I& y)
396 { return x.ring()->expt_pos(x,y); }
398 // Scalar multiplication.
399 #if 0 // less efficient
400 inline const cl_UP operator* (const cl_I& x, const cl_UP& y)
401 { return y.ring()->mul(y.ring()->canonhom(x),y); }
402 inline const cl_UP operator* (const cl_UP& x, const cl_I& y)
403 { return x.ring()->mul(x.ring()->canonhom(y),x); }
405 inline const cl_UP operator* (const cl_I& x, const cl_UP& y)
406 { return y.ring()->scalmul(y.ring()->basering()->canonhom(x),y); }
407 inline const cl_UP operator* (const cl_UP& x, const cl_I& y)
408 { return x.ring()->scalmul(x.ring()->basering()->canonhom(y),x); }
409 inline const cl_UP operator* (const cl_ring_element& x, const cl_UP& y)
410 { return y.ring()->scalmul(x,y); }
411 inline const cl_UP operator* (const cl_UP& x, const cl_ring_element& y)
412 { return x.ring()->scalmul(y,x); }
415 inline sintL degree (const cl_UP& x)
416 { return x.ring()->degree(x); }
419 inline const cl_ring_element coeff (const cl_UP& x, uintL index)
420 { return x.ring()->coeff(x,index); }
422 // Destructive modification.
423 inline void set_coeff (cl_UP& x, uintL index, const cl_ring_element& y)
424 { x.ring()->set_coeff(x,index,y); }
425 inline void finalize (cl_UP& x)
426 { x.ring()->finalize(x); }
427 inline void cl_UP::set_coeff (uintL index, const cl_ring_element& y)
428 { ring()->set_coeff(*this,index,y); }
429 inline void cl_UP::finalize ()
430 { ring()->finalize(*this); }
432 // Evaluation. (No extension of the base ring allowed here for now.)
433 inline const cl_ring_element cl_UP::operator() (const cl_ring_element& y) const
435 return ring()->eval(*this,y);
439 extern const cl_UP deriv (const cl_UP& x);
442 // Ring of uninitialized elements.
443 // Any operation results in a run-time error.
445 extern const cl_univpoly_ring cl_no_univpoly_ring;
446 extern cl_class cl_class_no_univpoly_ring;
447 CL_REQUIRE(cl_UP_no_ring)
449 inline cl_univpoly_ring::cl_univpoly_ring ()
450 : cl_ring (as_cl_private_thing(cl_no_univpoly_ring)) {}
451 inline _cl_UP::_cl_UP ()
452 : rep ((cl_private_thing) cl_combine(cl_FN_tag,0)) {}
453 inline cl_UP::cl_UP ()
454 : _cl_UP (), _ring () {}
457 // Debugging support.
459 extern int cl_UP_debug_module;
460 static void* const cl_UP_debug_dummy[] = { &cl_UP_debug_dummy,
467 #endif /* _CL_UNIVPOLY_H */
471 // Templates for univariate polynomials of complex/real/rational/integers.
474 // Unfortunately, this is not usable now, because of gcc-2.7 bugs:
475 // - A template inline function is not inline in the first function that
477 // - Argument matching bug: User-defined conversions are not tried (or
478 // tried with too low priority) for template functions w.r.t. normal
479 // functions. For example, a call expt_pos(cl_UP_specialized<cl_N>,int)
480 // is compiled as expt_pos(const cl_UP&, const cl_I&) instead of
481 // expt_pos(const cl_UP_specialized<cl_N>&, const cl_I&).
482 // It will, however, be usable when gcc-2.8 is released.
484 #if defined(_CL_UNIVPOLY_COMPLEX_H) || defined(_CL_UNIVPOLY_REAL_H) || defined(_CL_UNIVPOLY_RATIONAL_H) || defined(_CL_UNIVPOLY_INTEGER_H)
485 #ifndef _CL_UNIVPOLY_AUX_H
487 // Normal univariate polynomials with stricter static typing:
488 // `class T' instead of `cl_ring_element'.
490 template <class T> class cl_univpoly_specialized_ring;
491 template <class T> class cl_UP_specialized;
492 template <class T> class cl_heap_univpoly_specialized_ring;
495 class cl_univpoly_specialized_ring : public cl_univpoly_ring {
497 // Default constructor.
498 cl_univpoly_specialized_ring () : cl_univpoly_ring () {}
500 cl_univpoly_specialized_ring (const cl_univpoly_specialized_ring&);
501 // Assignment operator.
502 cl_univpoly_specialized_ring& operator= (const cl_univpoly_specialized_ring&);
503 // Automatic dereferencing.
504 cl_heap_univpoly_specialized_ring<T>* operator-> () const
505 { return (cl_heap_univpoly_specialized_ring<T>*)heappointer; }
507 // Copy constructor and assignment operator.
509 _CL_DEFINE_COPY_CONSTRUCTOR2(cl_univpoly_specialized_ring<T>,cl_univpoly_specialized_ring,cl_univpoly_ring)
511 CL_DEFINE_ASSIGNMENT_OPERATOR(cl_univpoly_specialized_ring<T>,cl_univpoly_specialized_ring<T>)
514 class cl_UP_specialized : public cl_UP {
516 const cl_univpoly_specialized_ring<T>& ring () const { return The(cl_univpoly_specialized_ring<T>)(_ring); }
518 CL_DEFINE_CONVERTER(cl_ring_element)
519 // Destructive modification.
520 void set_coeff (uintL index, const T& y);
523 const T operator() (const T& y) const;
524 public: // Ability to place an object at a given address.
525 void* operator new (size_t size) { return malloc_hook(size); }
526 void* operator new (size_t size, void* ptr) { (void)size; return ptr; }
527 void operator delete (void* ptr) { free_hook(ptr); }
531 class cl_heap_univpoly_specialized_ring : public cl_heap_univpoly_ring {
532 SUBCLASS_cl_heap_univpoly_ring()
533 // High-level operations.
534 void fprint (std::ostream& stream, const cl_UP_specialized<T>& x)
536 cl_heap_univpoly_ring::fprint(stream,x);
538 cl_boolean equal (const cl_UP_specialized<T>& x, const cl_UP_specialized<T>& y)
540 return cl_heap_univpoly_ring::equal(x,y);
542 const cl_UP_specialized<T> zero ()
544 return The2(cl_UP_specialized<T>)(cl_heap_univpoly_ring::zero());
546 cl_boolean zerop (const cl_UP_specialized<T>& x)
548 return cl_heap_univpoly_ring::zerop(x);
550 const cl_UP_specialized<T> plus (const cl_UP_specialized<T>& x, const cl_UP_specialized<T>& y)
552 return The2(cl_UP_specialized<T>)(cl_heap_univpoly_ring::plus(x,y));
554 const cl_UP_specialized<T> minus (const cl_UP_specialized<T>& x, const cl_UP_specialized<T>& y)
556 return The2(cl_UP_specialized<T>)(cl_heap_univpoly_ring::minus(x,y));
558 const cl_UP_specialized<T> uminus (const cl_UP_specialized<T>& x)
560 return The2(cl_UP_specialized<T>)(cl_heap_univpoly_ring::uminus(x));
562 const cl_UP_specialized<T> one ()
564 return The2(cl_UP_specialized<T>)(cl_heap_univpoly_ring::one());
566 const cl_UP_specialized<T> canonhom (const cl_I& x)
568 return The2(cl_UP_specialized<T>)(cl_heap_univpoly_ring::canonhom(x));
570 const cl_UP_specialized<T> mul (const cl_UP_specialized<T>& x, const cl_UP_specialized<T>& y)
572 return The2(cl_UP_specialized<T>)(cl_heap_univpoly_ring::mul(x,y));
574 const cl_UP_specialized<T> square (const cl_UP_specialized<T>& x)
576 return The2(cl_UP_specialized<T>)(cl_heap_univpoly_ring::square(x));
578 const cl_UP_specialized<T> expt_pos (const cl_UP_specialized<T>& x, const cl_I& y)
580 return The2(cl_UP_specialized<T>)(cl_heap_univpoly_ring::expt_pos(x,y));
582 const cl_UP_specialized<T> scalmul (const T& x, const cl_UP_specialized<T>& y)
584 return The2(cl_UP_specialized<T>)(cl_heap_univpoly_ring::scalmul(x,y));
586 sintL degree (const cl_UP_specialized<T>& x)
588 return cl_heap_univpoly_ring::degree(x);
590 const cl_UP_specialized<T> monomial (const T& x, uintL e)
592 return The2(cl_UP_specialized<T>)(cl_heap_univpoly_ring::monomial(cl_ring_element(cl_C_ring??,x),e));
594 const T coeff (const cl_UP_specialized<T>& x, uintL index)
596 return The(T)(cl_heap_univpoly_ring::coeff(x,index));
598 const cl_UP_specialized<T> create (sintL deg)
600 return The2(cl_UP_specialized<T>)(cl_heap_univpoly_ring::create(deg));
602 void set_coeff (cl_UP_specialized<T>& x, uintL index, const T& y)
604 cl_heap_univpoly_ring::set_coeff(x,index,cl_ring_element(cl_C_ring??,y));
606 void finalize (cl_UP_specialized<T>& x)
608 cl_heap_univpoly_ring::finalize(x);
610 const T eval (const cl_UP_specialized<T>& x, const T& y)
612 return The(T)(cl_heap_univpoly_ring::eval(x,cl_ring_element(cl_C_ring??,y)));
615 // No need for any constructors.
616 cl_heap_univpoly_specialized_ring ();
619 // Lookup of polynomial rings.
621 inline const cl_univpoly_specialized_ring<T> find_univpoly_ring (const cl_specialized_number_ring<T>& r)
622 { return The(cl_univpoly_specialized_ring<T>) (find_univpoly_ring((const cl_ring&)r)); }
624 inline const cl_univpoly_specialized_ring<T> find_univpoly_ring (const cl_specialized_number_ring<T>& r, const cl_symbol& varname)
625 { return The(cl_univpoly_specialized_ring<T>) (find_univpoly_ring((const cl_ring&)r,varname)); }
627 // Operations on polynomials.
631 inline const cl_UP_specialized<T> operator+ (const cl_UP_specialized<T>& x, const cl_UP_specialized<T>& y)
632 { return x.ring()->plus(x,y); }
636 inline const cl_UP_specialized<T> operator- (const cl_UP_specialized<T>& x)
637 { return x.ring()->uminus(x); }
641 inline const cl_UP_specialized<T> operator- (const cl_UP_specialized<T>& x, const cl_UP_specialized<T>& y)
642 { return x.ring()->minus(x,y); }
646 inline const cl_UP_specialized<T> operator* (const cl_UP_specialized<T>& x, const cl_UP_specialized<T>& y)
647 { return x.ring()->mul(x,y); }
651 inline const cl_UP_specialized<T> square (const cl_UP_specialized<T>& x)
652 { return x.ring()->square(x); }
654 // Exponentiation x^y, where y > 0.
656 inline const cl_UP_specialized<T> expt_pos (const cl_UP_specialized<T>& x, const cl_I& y)
657 { return x.ring()->expt_pos(x,y); }
659 // Scalar multiplication.
660 // Need more discrimination on T ??
662 inline const cl_UP_specialized<T> operator* (const cl_I& x, const cl_UP_specialized<T>& y)
663 { return y.ring()->mul(y.ring()->canonhom(x),y); }
665 inline const cl_UP_specialized<T> operator* (const cl_UP_specialized<T>& x, const cl_I& y)
666 { return x.ring()->mul(x.ring()->canonhom(y),x); }
668 inline const cl_UP_specialized<T> operator* (const T& x, const cl_UP_specialized<T>& y)
669 { return y.ring()->scalmul(x,y); }
671 inline const cl_UP_specialized<T> operator* (const cl_UP_specialized<T>& x, const T& y)
672 { return x.ring()->scalmul(y,x); }
676 inline const T coeff (const cl_UP_specialized<T>& x, uintL index)
677 { return x.ring()->coeff(x,index); }
679 // Destructive modification.
681 inline void set_coeff (cl_UP_specialized<T>& x, uintL index, const T& y)
682 { x.ring()->set_coeff(x,index,y); }
684 inline void finalize (cl_UP_specialized<T>& x)
685 { x.ring()->finalize(x); }
687 inline void cl_UP_specialized<T>::set_coeff (uintL index, const T& y)
688 { ring()->set_coeff(*this,index,y); }
690 inline void cl_UP_specialized<T>::finalize ()
691 { ring()->finalize(*this); }
693 // Evaluation. (No extension of the base ring allowed here for now.)
695 inline const T cl_UP_specialized<T>::operator() (const T& y) const
697 return ring()->eval(*this,y);
702 inline const cl_UP_specialized<T> deriv (const cl_UP_specialized<T>& x)
703 { return The(cl_UP_specialized<T>)(deriv((const cl_UP&)x)); }
706 #endif /* _CL_UNIVPOLY_AUX_H */