Number.h
Go to the documentation of this file.
1 #ifndef NUMBERCPP_HEADER
2 #define NUMBERCPP_HEADER
3 #include <boost/intrusive_ptr.hpp>
4 #include <kernel/mod2.h>
5 #include <coeffs/numbers.h>
6 #include <kernel/polys.h>
7 //#include <kernel/febase.h>
8 #include <polys/monomials/ring.h>
9 using namespace boost;
10 inline void intrusive_ptr_add_ref(ring r)
11 {
12  r->ref++;
13  //Print("ref count after add: %d", r->ref);
14 }
15 inline void intrusive_ptr_release(ring r)
16 {
17  if (r->ref<=0) rDelete(r);
18  else
19  {
20  r->ref--;
21  }
22  //Print("ref count after release: %d", r->ref);
23 }
24 
26 {
29 };
30 template<poly_variant,class,class> class PolyBase;
31 class Poly;
32 //class TrivialErrorHandler;
33 class Vector;
34 class Number
35 {
36  public:
37  friend Number operator+(const Number& n1, const Number& n2);
38  friend Number operator-(const Number& n1, const Number& n2);
39  friend Number operator/(const Number& n1, const Number& n2);
40  friend Number operator*(const Number& n1, const Number& n2);
41  friend bool operator==(const Number& n1, const Number& n2);
42  friend Number operator+(const Number& n1, int n2);
43  friend Number operator-(const Number& n1, int n2);
44  friend Number operator/(const Number& n1, int n2);
45  friend Number operator*(const Number& n1, int n2);
46  friend bool operator==(const Number& n1, int n2);
47  friend Number operator+(int n1, const Number& n2);
48  friend Number operator-(int n1, const Number& n2);
49  friend Number operator/(int n1, const Number& n2);
50  friend Number operator*(int n1, const Number& n2);
51  friend bool operator==(int n1, const Number& n2);
52  friend class Poly;
53  friend class Vector;
54  //friend class PolyBase<POLY_VARIANT_RING,Poly,TrivialErrorHandler>;
55 // friend class PolyBase <poly_variant variant,
56 // class create_type_input,
57 // class error_handle_traits>;
58  template <poly_variant,class,class> friend class PolyBase;
59  friend class PolyImpl;
60  number as_number() const
61  {
62  return n_Copy(n,r.get()->cf);
63  }
64  Number& operator=(const Number& n2)
65  {
66  //durch Reihenfolge Selbstzuweisungen berücksichtigt
67  number nc=n_Copy(n2.n,n2.r.get()->cf);
68  n_Delete(&n,r.get()->cf);
69  r=n2.r;
70  n=nc;
71  return *this;
72  }
74  {
75  Number t(*this);
76  //t.n=n_Copy(n,r);
77  t.n=n_InpNeg(t.n,r.get()->cf);
78  return t;
79  }
80  Number& operator+=(const Number & n2)
81  {
82  if (r!=n2.r)
83  {
84  WerrorS("not the same ring");
85  return *this;
86  }
87  number nv=n_Add(n,n2.n,r.get()->cf);
88  n_Delete(&n,r.get()->cf);
89  n=nv;
90  return *this;
91  }
92  Number& operator*=(const Number & n2)
93  {
94  if (r!=n2.r)
95  {
96  WerrorS("not the same ring");
97  return *this;
98  }
99  number nv=n_Mult(n,n2.n,r.get()->cf);
100  n_Delete(&n,r.get()->cf);
101  n=nv;
102  return *this;
103  }
104  Number& operator-=(const Number & n2)
105  {
106  if (r!=n2.r)
107  {
108  WerrorS("not the same ring");
109  return *this;
110  }
111  number nv=n_Sub(n,n2.n,r.get()->cf);
112  n_Delete(&n,r.get()->cf);
113  n=nv;
114  return *this;
115  }
116  Number& operator/=(const Number & n2)
117  {
118  if (r!=n2.r)
119  {
120  WerrorS("not the same ring");
121  return *this;
122  }
123  number nv=n_Div(n,n2.n,r.get()->cf);
124  n_Delete(&n,r.get()->cf);
125  n=nv;
126  return *this;
127  }
128  Number& operator=(int n2)
129  {
130  n_Delete(&n,r.get()->cf);
131  n=n_Init(n2,r.get()->cf);
132  return *this;
133  }
135  {
136  number n2n=n_Init(n2,r.get()->cf);
137  number nv=n_Add(n,n2n,r.get()->cf);
138  n_Delete(&n,r.get()->cf);
139  n_Delete(&n2n,r.get()->cf);
140  n=nv;
141  return *this;
142  }
144  {
145  number n2n=n_Init(n2,r.get()->cf);
146  number nv=n_Mult(n,n2n,r.get()->cf);
147  n_Delete(&n,r.get()->cf);
148  n_Delete(&n2n,r.get()->cf);
149  n=nv;
150  return *this;
151  }
153  {
154  number n2n=n_Init(n2,r.get()->cf);
155  number nv=n_Sub(n,n2n,r.get()->cf);
156  n_Delete(&n,r.get()->cf);
157  n_Delete(&n2n,r.get()->cf);
158  n=nv;
159  return *this;
160  }
162  {
163  number n2n=n_Init(n2,r.get()->cf);
164  number nv=n_Div(n,n2n,r.get()->cf);
165  n_Delete(&n,r.get()->cf);
166  n_Delete(&n2n,r.get()->cf);
167  n=nv;
168  return *this;
169  }
171  {
172  r=currRing;
173  if (r.get()!=NULL)
174  n=n_Init(0,r.get()->cf);
175  else
176  n=(number) NULL;
177  }
178  Number(const Number & n)
179  {
180  r=n.r;
181  this->n=n_Copy(n.n,r.get()->cf);
182  }
183  Number(number n, ring r)
184  {
185  this->n=n_Copy(n,r->cf);
186  this->r=r;
187  }
188  Number(int n, ring r)
189  {
190  this->r=r;
191  this->n=n_Init(n,r->cf);
192  }
193  Number(int n, intrusive_ptr<ip_sring> r)
194  {
195  this->r=r;
196  this->n=n_Init(n,r.get()->cf);
197  }
198  explicit Number(int n)
199  {
200  r=currRing;
201  this->n=n_Init(n,r.get()->cf);
202  }
203  void write() const
204  {
205  number towrite=n;
206  n_Write(towrite,r.get()->cf);
207  }
209  {
210  if (r!=NULL)
211  n_Delete(&n,r.get()->cf);
212  }
213  ring getRing() const
214  {
215  return r.get();
216  }
217  protected:
218  number n;
219  intrusive_ptr<ip_sring> r;
220 };
221 
222 inline Number operator+(const Number &n1, const Number& n2)
223 {
224  Number erg(n1);
225  erg+=n2;
226  return erg;
227 }
228 inline Number operator*(const Number &n1, const Number& n2)
229 {
230  Number erg(n1);
231  erg*=n2;
232  return erg;
233 }
234 inline Number operator-(const Number &n1, const Number& n2)
235 {
236  Number erg(n1);
237  erg-=n2;
238  return erg;
239 }
240 inline Number operator/(const Number &n1, const Number& n2)
241 {
242  Number erg(n1);
243  erg/=n2;
244  return erg;
245 }
246 inline bool operator==(const Number &n1, const Number& n2)
247 {
248  if(n1.r!=n2.r)
249  return false;
250  return n_Equal(n1.n,n2.n,n1.r.get()->cf);
251 }
252 inline Number operator+(const Number &n1, int n2)
253 {
254  Number erg(n1);
255  erg+=Number(n2,n1.r);
256  return erg;
257 }
258 inline Number operator*(const Number &n1, int n2)
259 {
260  Number erg(n1);
261  erg*=Number(n2,n1.r);
262  return erg;
263 }
264 inline Number operator-(const Number &n1, int n2)
265 {
266  Number erg(n1);
267  erg-=Number(n2,n1.r);
268  return erg;
269 }
270 inline Number operator/(const Number &n1, int n2)
271 {
272  Number erg(n1);
273  erg/=Number(n2,n1.r);
274  return erg;
275 }
276 inline bool operator==(const Number &n1, int n2)
277 {
278  return n_Equal(n1.n,Number(n2,n1.r).n,n1.r.get()->cf);
279 }
280 inline Number operator+(int n1, const Number& n2)
281 {
282  Number erg(n2);
283  return erg+=Number(n1,n2.r);
284 }
285 inline Number operator-(int n1, const Number& n2)
286 {
287  Number erg(n1,n2.r);
288  return erg-=n2;
289 }
290 inline Number operator/(int n1, const Number& n2)
291 {
292  Number erg(n1,n2.r);
293  return erg/=n2;
294 }
295 inline Number operator*(int n1, const Number& n2)
296 {
297  Number erg(n2);
298  return erg*=Number(n1,n2.r);
299 }
300 inline bool operator==(int n1, const Number& n2)
301 {
302  return n2==Number(n1,n2.r);
303 }
304 #endif
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of &#39;a&#39; and &#39;b&#39;, i.e., a-b
Definition: coeffs.h:673
Number(int n)
Definition: Number.h:198
Number & operator*=(const Number &n2)
Definition: Number.h:92
Number & operator+=(const Number &n2)
Definition: Number.h:80
Number & operator-=(int n2)
Definition: Number.h:152
Definition: janet.h:14
Number & operator-=(const Number &n2)
Definition: Number.h:104
number as_number() const
Definition: Number.h:60
Number operator*(const Number &n1, const Number &n2)
Definition: Number.h:228
Compatiblity layer for legacy polynomial operations (over currRing)
Definition: Poly.h:509
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:542
Number(int n, ring r)
Definition: Number.h:188
~Number()
Definition: Number.h:208
Number & operator=(int n2)
Definition: Number.h:128
intrusive_ptr< ip_sring > r
Definition: Number.h:219
void WerrorS(const char *s)
Definition: feFopen.cc:24
Number & operator+=(int n2)
Definition: Number.h:134
Number operator-(const Number &n1, const Number &n2)
Definition: Number.h:234
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:640
void intrusive_ptr_release(ring r)
Definition: Number.h:15
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
const ring r
Definition: syzextra.cc:208
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of &#39;a&#39; and &#39;b&#39;, i.e., a+b
Definition: coeffs.h:660
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:595
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition: coeffs.h:561
void intrusive_ptr_add_ref(ring r)
Definition: Number.h:10
bool operator==(const Number &n1, const Number &n2)
Definition: Number.h:246
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:455
Number & operator/=(int n2)
Definition: Number.h:161
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:448
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:619
Definition: Number.h:34
Number & operator/=(const Number &n2)
Definition: Number.h:116
Number & operator*=(int n2)
Definition: Number.h:143
void write() const
Definition: Number.h:203
Number(const Number &n)
Definition: Number.h:178
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff &#39;a&#39; and &#39;b&#39; represent the same number; they may have different representations.
Definition: coeffs.h:464
number n
Definition: Number.h:218
Number operator/(const Number &n1, const Number &n2)
Definition: Number.h:240
Number operator+(const Number &n1, const Number &n2)
Definition: Number.h:222
ring getRing() const
Definition: Number.h:213
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
Number operator-()
Definition: Number.h:73
Number & operator=(const Number &n2)
Definition: Number.h:64
Definition: Poly.h:44
Number(int n, intrusive_ptr< ip_sring > r)
Definition: Number.h:193
Number(number n, ring r)
Definition: Number.h:183
Number()
Definition: Number.h:170
poly_variant
Definition: Number.h:25