1// Univariate Polynomials over modular integers.
2
3#ifndef _CL_UNIVPOLY_MODINT_H
4#define _CL_UNIVPOLY_MODINT_H
5
6#include "cln/ring.h"
7#include "cln/univpoly.h"
8#include "cln/modinteger.h"
9#include "cln/integer_class.h"
10
11namespace cln {
12
13// Normal univariate polynomials with stricter static typing:
14// `cl_MI' instead of `cl_ring_element'.
15
16class cl_heap_univpoly_modint_ring;
17
18class cl_univpoly_modint_ring : public cl_univpoly_ring {
19public:
20 // Default constructor.
21 cl_univpoly_modint_ring () : cl_univpoly_ring () {}
22 // Copy constructor.
23 cl_univpoly_modint_ring (const cl_univpoly_modint_ring&);
24 // Assignment operator.
25 cl_univpoly_modint_ring& operator= (const cl_univpoly_modint_ring&);
26 // Automatic dereferencing.
27 cl_heap_univpoly_modint_ring* operator-> () const
28 { return (cl_heap_univpoly_modint_ring*)heappointer; }
29};
30// Copy constructor and assignment operator.
31CL_DEFINE_COPY_CONSTRUCTOR2(cl_univpoly_modint_ring,cl_univpoly_ring)
32CL_DEFINE_ASSIGNMENT_OPERATOR(cl_univpoly_modint_ring,cl_univpoly_modint_ring)
33
34class cl_UP_MI : public cl_UP {
35public:
36 const cl_univpoly_modint_ring& ring () const { return The(cl_univpoly_modint_ring)(_ring); }
37 // Conversion.
38 CL_DEFINE_CONVERTER(cl_ring_element)
39 // Destructive modification.
40 void set_coeff (uintL index, const cl_MI& y);
41 void finalize();
42 // Evaluation.
43 const cl_MI operator() (const cl_MI& y) const;
44public: // Ability to place an object at a given address.
45 void* operator new (size_t size) { return malloc_hook(size); }
46 void* operator new (size_t size, void* ptr) { (void)size; return ptr; }
47 void operator delete (void* ptr) { free_hook(ptr); }
48};
49
50class cl_heap_univpoly_modint_ring : public cl_heap_univpoly_ring {
51 SUBCLASS_cl_heap_univpoly_ring()
52 const cl_modint_ring& basering () const { return The(cl_modint_ring)(_basering); }
53 // High-level operations.
54 void fprint (std::ostream& stream, const cl_UP_MI& x)
55 {
56 cl_heap_univpoly_ring::fprint(stream,x);
57 }
58 bool equal (const cl_UP_MI& x, const cl_UP_MI& y)
59 {
60 return cl_heap_univpoly_ring::equal(x,y);
61 }
62 const cl_UP_MI zero ()
63 {
64 return The2(cl_UP_MI)(cl_heap_univpoly_ring::zero());
65 }
66 bool zerop (const cl_UP_MI& x)
67 {
68 return cl_heap_univpoly_ring::zerop(x);
69 }
70 const cl_UP_MI plus (const cl_UP_MI& x, const cl_UP_MI& y)
71 {
72 return The2(cl_UP_MI)(cl_heap_univpoly_ring::plus(x,y));
73 }
74 const cl_UP_MI minus (const cl_UP_MI& x, const cl_UP_MI& y)
75 {
76 return The2(cl_UP_MI)(cl_heap_univpoly_ring::minus(x,y));
77 }
78 const cl_UP_MI uminus (const cl_UP_MI& x)
79 {
80 return The2(cl_UP_MI)(cl_heap_univpoly_ring::uminus(x));
81 }
82 const cl_UP_MI one ()
83 {
84 return The2(cl_UP_MI)(cl_heap_univpoly_ring::one());
85 }
86 const cl_UP_MI canonhom (const cl_I& x)
87 {
88 return The2(cl_UP_MI)(cl_heap_univpoly_ring::canonhom(x));
89 }
90 const cl_UP_MI mul (const cl_UP_MI& x, const cl_UP_MI& y)
91 {
92 return The2(cl_UP_MI)(cl_heap_univpoly_ring::mul(x,y));
93 }
94 const cl_UP_MI square (const cl_UP_MI& x)
95 {
96 return The2(cl_UP_MI)(cl_heap_univpoly_ring::square(x));
97 }
98 const cl_UP_MI expt_pos (const cl_UP_MI& x, const cl_I& y)
99 {
100 return The2(cl_UP_MI)(cl_heap_univpoly_ring::expt_pos(x,y));
101 }
102 const cl_UP_MI scalmul (const cl_MI& x, const cl_UP_MI& y)
103 {
104 return The2(cl_UP_MI)(cl_heap_univpoly_ring::scalmul(x,y));
105 }
106 sintL degree (const cl_UP_MI& x)
107 {
108 return cl_heap_univpoly_ring::degree(x);
109 }
110 sintL ldegree (const cl_UP_MI& x)
111 {
112 return cl_heap_univpoly_ring::ldegree(x);
113 }
114 const cl_UP_MI monomial (const cl_MI& x, uintL e)
115 {
116 return The2(cl_UP_MI)(cl_heap_univpoly_ring::monomial(x,e));
117 }
118 const cl_MI coeff (const cl_UP_MI& x, uintL index)
119 {
120 return The2(cl_MI)(cl_heap_univpoly_ring::coeff(x,index));
121 }
122 const cl_UP_MI create (sintL deg)
123 {
124 return The2(cl_UP_MI)(cl_heap_univpoly_ring::create(deg));
125 }
126 void set_coeff (cl_UP_MI& x, uintL index, const cl_MI& y)
127 {
128 cl_heap_univpoly_ring::set_coeff(x,index,y);
129 }
130 void finalize (cl_UP_MI& x)
131 {
132 cl_heap_univpoly_ring::finalize(x);
133 }
134 const cl_MI eval (const cl_UP_MI& x, const cl_MI& y)
135 {
136 return The2(cl_MI)(cl_heap_univpoly_ring::eval(x,y));
137 }
138private:
139 // No need for any constructors.
140 cl_heap_univpoly_modint_ring ();
141};
142
143// Lookup of polynomial rings.
144inline const cl_univpoly_modint_ring find_univpoly_ring (const cl_modint_ring& r)
145{ return The(cl_univpoly_modint_ring) (find_univpoly_ring((const cl_ring&)r)); }
146inline const cl_univpoly_modint_ring find_univpoly_ring (const cl_modint_ring& r, const cl_symbol& varname)
147{ return The(cl_univpoly_modint_ring) (find_univpoly_ring((const cl_ring&)r,varname)); }
148
149// Operations on polynomials.
150
151// Add.
152inline const cl_UP_MI operator+ (const cl_UP_MI& x, const cl_UP_MI& y)
153 { return x.ring()->plus(x,y); }
154
155// Negate.
156inline const cl_UP_MI operator- (const cl_UP_MI& x)
157 { return x.ring()->uminus(x); }
158
159// Subtract.
160inline const cl_UP_MI operator- (const cl_UP_MI& x, const cl_UP_MI& y)
161 { return x.ring()->minus(x,y); }
162
163// Multiply.
164inline const cl_UP_MI operator* (const cl_UP_MI& x, const cl_UP_MI& y)
165 { return x.ring()->mul(x,y); }
166
167// Squaring.
168inline const cl_UP_MI square (const cl_UP_MI& x)
169 { return x.ring()->square(x); }
170
171// Exponentiation x^y, where y > 0.
172inline const cl_UP_MI expt_pos (const cl_UP_MI& x, const cl_I& y)
173 { return x.ring()->expt_pos(x,y); }
174
175// Scalar multiplication.
176#if 0 // less efficient
177inline const cl_UP_MI operator* (const cl_I& x, const cl_UP_MI& y)
178 { return y.ring()->mul(y.ring()->canonhom(x),y); }
179inline const cl_UP_MI operator* (const cl_UP_MI& x, const cl_I& y)
180 { return x.ring()->mul(x.ring()->canonhom(y),x); }
181#endif
182inline const cl_UP_MI operator* (const cl_I& x, const cl_UP_MI& y)
183 { return y.ring()->scalmul(y.ring()->basering()->canonhom(x),y); }
184inline const cl_UP_MI operator* (const cl_UP_MI& x, const cl_I& y)
185 { return x.ring()->scalmul(x.ring()->basering()->canonhom(y),x); }
186inline const cl_UP_MI operator* (const cl_MI& x, const cl_UP_MI& y)
187 { return y.ring()->scalmul(x,y); }
188inline const cl_UP_MI operator* (const cl_UP_MI& x, const cl_MI& y)
189 { return x.ring()->scalmul(y,x); }
190
191// Coefficient.
192inline const cl_MI coeff (const cl_UP_MI& x, uintL index)
193 { return x.ring()->coeff(x,index); }
194
195// Destructive modification.
196inline void set_coeff (cl_UP_MI& x, uintL index, const cl_MI& y)
197 { x.ring()->set_coeff(x,index,y); }
198inline void finalize (cl_UP_MI& x)
199 { x.ring()->finalize(x); }
200inline void cl_UP_MI::set_coeff (uintL index, const cl_MI& y)
201 { ring()->set_coeff(*this,index,y); }
202inline void cl_UP_MI::finalize ()
203 { ring()->finalize(*this); }
204
205// Evaluation. (No extension of the base ring allowed here for now.)
206inline const cl_MI cl_UP_MI::operator() (const cl_MI& y) const
207{
208 return ring()->eval(*this,y);
209}
210
211// Derivative.
212inline const cl_UP_MI deriv (const cl_UP_MI& x)
213 { return The2(cl_UP_MI)(deriv((const cl_UP&)x)); }
214
215} // namespace cln
216
217#endif /* _CL_UNIVPOLY_MODINT_H */
218