numbers.cc
Go to the documentation of this file.
1 /*****************************************
2 * Computer Algebra System SINGULAR *
3 *****************************************/
4 
5 /*
6 * ABSTRACT: interface to coefficient aritmetics
7 */
8 
9 #include <string.h>
10 #include <stdlib.h>
11 
12 #include <misc/auxiliary.h>
13 #include <omalloc/omalloc.h>
14 #include <factory/factory.h>
15 
16 #include <reporter/reporter.h>
17 
18 #include <coeffs/coeffs.h>
19 #include <coeffs/numbers.h>
20 
21 #include <coeffs/longrat.h>
22 #include <coeffs/modulop.h>
23 #include <coeffs/gnumpfl.h>
24 #include <coeffs/gnumpc.h>
25 #include <coeffs/ffields.h>
26 #include <coeffs/shortfl.h>
27 
28 #ifdef HAVE_RINGS
29 # include <coeffs/rmodulo2m.h>
30 # include <coeffs/rmodulon.h>
31 # include <coeffs/rintegers.h>
32 #endif
33 
34 #ifdef HAVE_POLYEXTENSIONS
37 #endif
38 
39 
40 #ifdef HAVE_NUMSTATS
41 struct SNumberStatistic number_stats;
42 #endif /* HAVE_NUMSTATS */
43 
44 //static int characteristic = 0;
45 //extern int IsPrime(int p);
46 
48 
49 void nNew(number* d) { *d=NULL; }
50 
51 
52 static void ndDelete(number* d, const coeffs) { *d=NULL; }
53 static number ndAnn(number, const coeffs) { return NULL;}
54 static char* ndCoeffString(const coeffs r)
55 {
56  char *s=(char *)omAlloc(11);snprintf(s,11,"Coeffs(%d)",r->type);
57  return s;
58 }
59 static void ndInpMult(number &a, number b, const coeffs r)
60 {
61  number n=r->cfMult(a,b,r);
62  r->cfDelete(&a,r);
63  a=n;
64 }
65 static void ndInpAdd(number &a, number b, const coeffs r)
66 {
67  number n=r->cfAdd(a,b,r);
68  r->cfDelete(&a,r);
69  a=n;
70 }
71 
72 static void ndPower(number a, int i, number * res, const coeffs r)
73 {
74  if (i==0)
75  {
76  *res = r->cfInit(1, r);
77  }
78  else if (i==1)
79  {
80  *res = r->cfCopy(a, r);
81  }
82  else if (i==2)
83  {
84  *res = r->cfMult(a, a, r);
85  }
86  else if (i<0)
87  {
88  number b = r->cfInvers(a, r);
89  ndPower(b, -i, res, r);
90  r->cfDelete(&b, r);
91  }
92  else
93  {
94  ndPower(a, i/2, res, r);
95  r->cfInpMult(*res, *res, r);
96  if (i&1)
97  {
98  r->cfInpMult(*res, a, r);
99  }
100  }
101 }
102 
103 static BOOLEAN ndIsUnit(number a, const coeffs r) { return !r->cfIsZero(a,r); }
104 #ifdef LDEBUG
105 // static void nDBDummy1(number* d,char *, int) { *d=NULL; }
106 static BOOLEAN ndDBTest(number, const char *, const int, const coeffs){ return TRUE; }
107 #endif
108 
109 static number ndFarey(number,number,const coeffs r)
110 {
111  Werror("farey not implemented for %s (c=%d)",r->cfCoeffString(r),getCoeffType(r));
112  return NULL;
113 }
114 static number ndChineseRemainder(number *,number *,int,BOOLEAN,CFArray&,const coeffs r)
115 {
116  Werror("ChineseRemainder not implemented for %s (c=%d)",r->cfCoeffString(r),getCoeffType(r));
117  return r->cfInit(0,r);
118 }
119 
120 static int ndParDeg(number n, const coeffs r)
121 {
122  return (-r->cfIsZero(n,r));
123 }
124 
125 static number ndParameter(const int, const coeffs r)
126 {
127  Werror("ndParameter: n_Parameter is not implemented/relevant for (coeff_type = %d)",getCoeffType(r));
128  return NULL;
129 }
130 
132 {
133  int c = n_GetChar(r);
134  BOOLEAN ret = n_IsZero(a, r);
135  if( (c != 0) && !ret )
136  {
137  number ch = n_Init( c, r );
138  number g = n_Gcd( ch, a, r );
139  ret = !n_IsOne (g, r);
140  n_Delete(&ch, r);
141  n_Delete(&g, r);
142  }
143  return ret;
144 }
145 
146 static void ndNormalize(number&, const coeffs) { }
147 static number ndReturn0(number, const coeffs r) { return r->cfInit(0,r); }
148 static number ndGcd(number, number, const coeffs r) { return r->cfInit(1,r); }
149 static number ndIntMod(number, number, const coeffs r) { return r->cfInit(0,r); }
150 static number ndGetDenom(number &, const coeffs r) { return r->cfInit(1,r); }
151 static number ndGetNumerator(number &a,const coeffs r) { return r->cfCopy(a,r); }
152 static int ndSize(number a, const coeffs r) { return (int)r->cfIsZero(a,r)==FALSE; }
153 static char * ndCoeffName(const coeffs r) { return r->cfCoeffString(r); }
154 
155 static void ndClearContent(ICoeffsEnumerator& numberCollectionEnumerator, number& c, const coeffs r)
156 {
157  assume(r != NULL);
158 
159  // no fractions
160  assume(!( nCoeff_is_Q(r) ));
161  // all coeffs are given by integers!!!
162 
163  numberCollectionEnumerator.Reset();
164 
165  if( !numberCollectionEnumerator.MoveNext() ) // empty zero polynomial?
166  {
167  c = n_Init(1, r);
168  return;
169  }
170 
171  number &curr = numberCollectionEnumerator.Current();
172 
173 #ifdef HAVE_RINGS
174  /// TODO: move to a separate implementation
175  if (nCoeff_is_Ring(r))
176  {
177  if (nCoeff_has_Units(r))
178  {
179  c = n_GetUnit(curr, r);
180 
181  if (!n_IsOne(c, r))
182  {
183  number inv = n_Invers(c, r);
184 
185  n_InpMult(curr, inv, r);
186 
187  while( numberCollectionEnumerator.MoveNext() )
188  {
189  number &n = numberCollectionEnumerator.Current();
190  n_Normalize(n, r); // ?
191  n_InpMult(n, inv, r); // TODO: either this or directly divide!!!?
192  }
193 
194  n_Delete(&inv, r);
195  }
196  } else c = n_Init(1, r);
197 
198  return;
199  }
200 #endif
201 
202  assume(!nCoeff_is_Ring(r));
204 
205  n_Normalize(curr, r); // Q: good/bad/ugly??
206 
207  if (!n_IsOne(curr, r))
208  {
209  number t = curr; // takes over the curr! note: not a reference!!!
210 
211  curr = n_Init(1, r); // ???
212 
213  number inv = n_Invers(t, r);
214 
215  while( numberCollectionEnumerator.MoveNext() )
216  {
217  number &n = numberCollectionEnumerator.Current();
218  n_InpMult(n, inv, r); // TODO: either this or directly divide!!!?
219 // n_Normalize(n, r); // ?
220  }
221 
222  n_Delete(&inv, r);
223 
224  c = t;
225  } else
226  c = n_Copy(curr, r); // c == 1 and nothing else to do...
227 }
228 
229 static void ndClearDenominators(ICoeffsEnumerator& /*numberCollectionEnumerator*/, number& d, const coeffs r)
230 {
231  assume( r != NULL );
234 
235  d = n_Init(1, r);
236 }
237 
238 static number ndCopy(number a, const coeffs) { return a; }
239 number ndCopyMap(number a, const coeffs aRing, const coeffs r)
240 {
241  // aRing and r need not be the same, but must be the same representation
242  assume(aRing->rep==r->rep);
244  return a;
245  else
246  return r->cfCopy(a, r);
247 }
248 
249 static void ndKillChar(coeffs) {}
250 static void ndSetChar(const coeffs) {}
251 
252 number nd_Copy(number a, const coeffs r) { return r->cfCopy(a, r); }
253 
254 #ifdef HAVE_RINGS
255 static BOOLEAN ndDivBy(number, number, const coeffs) { return TRUE; } // assume a,b !=0
256 static int ndDivComp(number, number, const coeffs) { return 2; }
257 static number ndExtGcd (number, number, number *, number *, const coeffs r) { return r->cfInit(1,r); }
258 #endif
259 
260 static CanonicalForm ndConvSingNFactoryN( number, BOOLEAN /*setChar*/, const coeffs)
261 {
262  CanonicalForm term(0);
263  Werror("no conversion to factory");
264  return term;
265 }
266 
267 static number ndConvFactoryNSingN( const CanonicalForm, const coeffs)
268 {
269  Werror("no conversion from factory");
270  return NULL;
271 }
272 
273 /**< [in, out] a bigint number >= 0 */
274 /**< [out] the GMP equivalent */
275 /// Converts a non-negative bigint number into a GMP number.
276 static void ndMPZ(mpz_t result, number &n, const coeffs r)
277 {
278  mpz_init_set_si( result, r->cfInt(n, r) );
279 }
281 static number ndInitMPZ(mpz_t m, const coeffs r)
282 {
283  return r->cfInit( mpz_get_si(m), r);
284 }
285 
287 static BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void *)
288 {
289  /* test, if r is an instance of nInitCoeffs(n,parameter) */
290  /* if parameter is not needed */
291  return (n==r->type);
292 }
296 { NULL, /*n_unknown */
297  npInitChar, /* n_Zp */
298  nlInitChar, /* n_Q */
299  nrInitChar, /* n_R */
300  nfInitChar, /* n_GF */
301  ngfInitChar, /* n_long_R */
302  #ifdef HAVE_POLYEXTENSIONS
303  naInitChar, /* n_algExt */
304  ntInitChar, /* n_transExt */
305  #else
306  NULL, /* n_algExt */
307  NULL, /* n_transExt */
308  #endif
309  ngcInitChar, /* n_long_C */
310  #ifdef HAVE_RINGS
311  nrzInitChar, /* n_Z */
312  nrnInitChar, /* n_Zn */
313  nrnInitChar, /* n_Znm */
314  nr2mInitChar, /* n_Z2m */
315  #else
316  NULL, /* n_Z */
317  NULL, /* n_Zn */
318  NULL, /* n_Znm */
319  NULL, /* n_Z2m */
320  #endif
321  NULL /* n_CF */
322 };
325 /*2
326 * init operations for coeffs r
327 */
328 coeffs nInitChar(n_coeffType t, void * parameter)
329 {
331 
332  while((n!=NULL) && (n->nCoeffIsEqual!=NULL) && (!n->nCoeffIsEqual(n,t,parameter)))
333  n=n->next;
334 
335  if (n==NULL)
336  {
337  n=(n_Procs_s*)omAlloc0(sizeof(n_Procs_s));
338  n->next=cf_root;
339  n->ref=1;
340  n->type=t;
341 
342  // default entries (different from NULL) for some routines:
344  n->cfSize = ndSize;
347  n->cfImPart=ndReturn0;
348  n->cfDelete= ndDelete;
349  n->cfAnn = ndAnn;
350  n->cfCoeffString = ndCoeffString; // should alway be changed!
351  n->cfInpMult=ndInpMult;
352  n->cfInpAdd=ndInpAdd;
353  n->cfCopy = ndCopy;
354  n->cfIntMod=ndIntMod; /* dummy !! */
356  n->cfGcd = ndGcd;
357  n->cfNormalizeHelper = ndGcd; /* tricky, isn't it ?*/
358  n->cfLcm = ndGcd; /* tricky, isn't it ?*/
359  n->cfInitMPZ = ndInitMPZ;
360  n->cfMPZ = ndMPZ;
361  n->cfPower = ndPower;
363 
364  n->cfKillChar = ndKillChar; /* dummy */
365  n->cfSetChar = ndSetChar; /* dummy */
366  // temp. removed to catch all the coeffs which miss to implement this!
367 
369  n->cfFarey = ndFarey;
370  n->cfParDeg = ndParDeg;
371 
373 
376 
377  n->cfIsUnit = ndIsUnit;
378 #ifdef HAVE_RINGS
379  n->cfDivComp = ndDivComp;
380  n->cfDivBy = ndDivBy;
381  n->cfExtGcd = ndExtGcd;
382  //n->cfGetUnit = (nMapFunc)NULL;
383 #endif
384 
385 #ifdef LDEBUG
386  n->cfDBTest=ndDBTest;
387 #endif
388 
391 
392  BOOLEAN nOK=TRUE;
393  // init
394  if ((t<=nLastCoeffs) && (nInitCharTable[t]!=NULL))
395  nOK = (nInitCharTable[t])(n,parameter);
396  else
397  Werror("Sorry: the coeff type [%d] was not registered: it is missing in nInitCharTable", (int)t);
398  if (nOK)
399  {
400  omFreeSize(n,sizeof(*n));
401  return NULL;
402  }
403  cf_root=n;
404  // post init settings:
405  if (n->cfRePart==NULL) n->cfRePart=n->cfCopy;
406  if (n->cfExactDiv==NULL) n->cfExactDiv=n->cfDiv;
407  if (n->cfSubringGcd==NULL) n->cfSubringGcd=n->cfGcd;
408 
409 #ifdef HAVE_RINGS
410  if (n->cfGetUnit==NULL) n->cfGetUnit=n->cfCopy;
411 #endif
412 
413  if(n->cfWriteShort==NULL)
414  n->cfWriteShort = n->cfWriteLong;
415 
417  assume(n->cfSetChar!=NULL);
419  assume(n->cfMult!=NULL);
420  assume(n->cfSub!=NULL);
421  assume(n->cfAdd!=NULL);
422  assume(n->cfDiv!=NULL);
423  assume(n->cfIntMod!=NULL);
424  assume(n->cfExactDiv!=NULL);
425  assume(n->cfInit!=NULL);
426  assume(n->cfInitMPZ!=NULL);
427  assume(n->cfSize!=NULL);
428  assume(n->cfInt!=NULL);
429  assume(n->cfMPZ!=NULL);
430  //assume(n->n->cfDivComp!=NULL);
431  //assume(n->cfIsUnit!=NULL);
432  //assume(n->cfGetUnit!=NULL);
433  //assume(n->cfExtGcd!=NULL);
434  assume(n->cfInpNeg!=NULL);
435  assume(n->cfCopy!=NULL);
436 
437  assume(n->cfWriteLong!=NULL);
438  assume(n->cfWriteShort!=NULL);
439 
440  assume(n->iNumberOfParameters>= 0);
441 
442  assume( (n->iNumberOfParameters == 0 && n->pParameterNames == NULL) ||
443  (n->iNumberOfParameters > 0 && n->pParameterNames != NULL) );
444 
445  assume(n->cfParameter!=NULL);
446  assume(n->cfParDeg!=NULL);
447 
448  assume(n->cfRead!=NULL);
449  assume(n->cfNormalize!=NULL);
450  assume(n->cfGreater!=NULL);
451  //assume(n->cfDivBy!=NULL);
452  assume(n->cfEqual!=NULL);
453  assume(n->cfIsZero!=NULL);
454  assume(n->cfIsOne!=NULL);
455  assume(n->cfIsMOne!=NULL);
457  assume(n->cfGetDenom!=NULL);
459  assume(n->cfGcd!=NULL);
461  assume(n->cfDelete!=NULL);
462  assume(n->cfSetMap!=NULL);
463  assume(n->cfInpMult!=NULL);
464 // assume(n->cfInit_bigint!=NULL);
465  assume(n->cfCoeffWrite != NULL);
466 
467  assume(n->cfClearContent != NULL);
469 
470  assume(n->type==t);
471 
472 #ifndef SING_NDEBUG
473  if(n->cfKillChar==NULL) Warn("cfKillChar is NULL for coeff %d",t);
474  if(n->cfWriteLong==NULL) Warn("cfWrite is NULL for coeff %d",t);
475  if(n->cfWriteShort==NULL) Warn("cfWriteShort is NULL for coeff %d",t);
476  if(n->cfCoeffString==ndCoeffString) Warn("cfCoeffString is undefined for coeff %d",t);
477 #endif
478 
479  if( n->nNULL == NULL )
480  n->nNULL = n->cfInit(0, n); // may still remain NULL
481  }
482  else
483  {
484  n->ref++;
485  }
486  return n;
487 }
489 void nKillChar(coeffs r)
490 {
492  if (r!=NULL)
493  {
494  r->ref--;
495  if (r->ref<=0)
496  {
497  n_Procs_s tmp;
498  n_Procs_s* n=&tmp;
499  tmp.next=cf_root;
500  while((n->next!=NULL) && (n->next!=r)) n=n->next;
501  if (n->next==r)
502  {
503  n->next=n->next->next;
504  if (cf_root==r) cf_root=n->next;
505  n_Delete(&(r->nNULL),r);
506  assume (r->cfKillChar!=NULL); r->cfKillChar(r); // STATISTIC(nKillChar);
507  omFreeSize((void *)r, sizeof(n_Procs_s));
508  r=NULL;
509  }
510  else
511  {
512  WarnS("cf_root list destroyed");
513  }
514  }
515  }
516 }
517 
520 {
521  if (n==n_unknown)
522  {
525  {
527  ((int)nLastCoeffs+1)*sizeof(cfInitCharProc));
529  ((int)nLastCoeffs)*sizeof(cfInitCharProc));
530  }
531  else
532  {
534  ((int)nLastCoeffs)*sizeof(cfInitCharProc),
535  (((int)nLastCoeffs)+1)*sizeof(cfInitCharProc));
536  }
537 
539  return nLastCoeffs;
540  }
541  else
542  {
543  if (nInitCharTable[n]!=NULL) Print("coeff %d already initialized\n",n);
544  nInitCharTable[n]=p;
545  return n;
546  }
547 }
548 
550 void n_Print(number& a, const coeffs r)
551 {
552  assume(r != NULL);
553  n_Test(a,r);
554 
555  StringSetS("");
556  n_Write(a, r);
557  { char* s = StringEndS(); Print("%s", s); omFree(s); }
558 }
559 
561 number n_convFactoryNSingN( const CanonicalForm n, const coeffs r)
562 { STATISTIC(n_convFactoryNSingN); assume(r != NULL); assume(r->convFactoryNSingN != NULL); return r->convFactoryNSingN(n, r); }
563 
564 
566 CanonicalForm n_convSingNFactoryN( number n, BOOLEAN setChar, const coeffs r )
567 { STATISTIC(n_convSingNFactoryN); assume(r != NULL); assume(r->convSingNFactoryN != NULL); return r->convSingNFactoryN(n, setChar, r); }
number nd_Copy(number a, const coeffs r)
Definition: numbers.cc:252
static BOOLEAN ndIsUnit(number a, const coeffs r)
Definition: numbers.cc:103
void n_Print(number &a, const coeffs r)
print a number (BEWARE of string buffers!) mostly for debugging
Definition: numbers.cc:549
BOOLEAN(* cfDivBy)(number a, number b, const coeffs r)
Definition: coeffs.h:382
#define STATISTIC(f)
Definition: numstats.h:16
BOOLEAN nrInitChar(coeffs n, void *p)
Initialize r.
Definition: shortfl.cc:733
static FORCE_INLINE number n_GetUnit(number n, const coeffs r)
in Z: 1 in Z/kZ (where k is not a prime): largest divisor of n (taken in Z) that is co-prime with k i...
Definition: coeffs.h:533
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ...
Definition: coeffs.h:685
const CanonicalForm int s
Definition: facAbsFact.cc:55
number(* cfCopy)(number a, const coeffs r)
return a copy of a
Definition: coeffs.h:198
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition: coeffs.h:830
const poly a
Definition: syzextra.cc:212
number(* cfExtGcd)(number a, number b, number *s, number *t, const coeffs r)
Definition: coeffs.h:245
#define Print
Definition: emacs.cc:83
numberfunc cfIntMod
Definition: coeffs.h:174
int(* cfDivComp)(number a, number b, const coeffs r)
Definition: coeffs.h:378
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:818
static void ndPower(number a, int i, number *res, const coeffs r)
Definition: numbers.cc:72
static number ndParameter(const int, const coeffs r)
Definition: numbers.cc:125
number nNULL
the 0 as constant, NULL by default
Definition: coeffs.h:317
static void ndKillChar(coeffs)
Definition: numbers.cc:249
?
Definition: coeffs.h:46
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
Definition: coeffs.h:857
static BOOLEAN ndDBTest(number, const char *, const int, const coeffs)
Definition: numbers.cc:106
BOOLEAN(* cfDBTest)(number a, const char *f, const int l, const coeffs r)
Test: is "a" a correct number?
Definition: coeffs.h:416
void(* cfMPZ)(mpz_t result, number &n, const coeffs r)
Converts a non-negative number n into a GMP number, 0 if impossible.
Definition: coeffs.h:189
void(* cfSetChar)(const coeffs r)
Definition: coeffs.h:160
Definition: int_poly.h:36
BOOLEAN naInitChar(coeffs cf, void *infoStruct)
Initialize the coeffs object.
Definition: algext.cc:1389
static BOOLEAN ndDivBy(number, number, const coeffs)
Definition: numbers.cc:255
#define FALSE
Definition: auxiliary.h:140
static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
multiplication of 'a' and 'b'; replacement of 'a' by the product a*b
Definition: coeffs.h:640
return P p
Definition: myNF.cc:203
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:469
char const ** pParameterNames
array containing the names of Parameters (default NULL)
Definition: coeffs.h:323
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
Definition: numbers.cc:239
coeffs next
Definition: coeffs.h:124
static number ndCopy(number a, const coeffs)
Definition: numbers.cc:238
static n_coeffType nLastCoeffs
Definition: numbers.cc:293
static number ndChineseRemainder(number *, number *, int, BOOLEAN, CFArray &, const coeffs r)
Definition: numbers.cc:114
void(* cfDelete)(number *a, const coeffs r)
Definition: coeffs.h:269
static void ndNormalize(number &, const coeffs)
Definition: numbers.cc:146
BOOLEAN(*)(*)(*)(*) cfIsOne(number a, const coeffs r)
Definition: coeffs.h:228
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:539
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
number(* cfSubringGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:244
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
BOOLEAN n_IsZeroDivisor(number a, const coeffs r)
Test whether a is a zero divisor in r i.e. not coprime with char. of r very inefficient implementatio...
Definition: numbers.cc:131
static number ndConvFactoryNSingN(const CanonicalForm, const coeffs)
[in, out] a bigint number >= 0
Definition: numbers.cc:267
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:560
numberfunc cfAdd
Definition: coeffs.h:174
BOOLEAN(* cfGreater)(number a, number b, const coeffs r)
Definition: coeffs.h:224
void(* cfNormalize)(number &a, const coeffs r)
Definition: coeffs.h:222
static char * ndCoeffString(const coeffs r)
Definition: numbers.cc:54
number(* cfRePart)(number a, const coeffs r)
Definition: coeffs.h:199
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:445
factory's main class
Definition: canonicalform.h:75
#define TRUE
Definition: auxiliary.h:144
static void ndDelete(number *d, const coeffs)
Definition: numbers.cc:52
static int ndDivComp(number, number, const coeffs)
Definition: numbers.cc:256
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:327
void(* cfCoeffWrite)(const coeffs r, BOOLEAN details)
output of coeff description via Print
Definition: coeffs.h:147
g
Definition: cfModGcd.cc:4031
BOOLEAN nr2mInitChar(coeffs r, void *p)
Definition: rmodulo2m.cc:160
char * StringEndS()
Definition: reporter.cc:151
static char * ndCoeffName(const coeffs r)
Definition: numbers.cc:153
BOOLEAN(* cfIsUnit)(number a, const coeffs r)
Definition: coeffs.h:379
number(* cfGetUnit)(number a, const coeffs r)
Definition: coeffs.h:380
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:824
number(* cfFarey)(number p, number n, const coeffs)
rational reconstruction: "best" rational a/b with a/b = p mod n
Definition: coeffs.h:288
#define WarnS
Definition: emacs.cc:81
BOOLEAN npInitChar(coeffs r, void *p)
Definition: modulop.cc:498
BOOLEAN nlInitChar(coeffs r, void *p)
Definition: longrat.cc:3138
#define omAlloc(size)
Definition: omAllocDecl.h:210
number(* cfInitMPZ)(mpz_t i, const coeffs r)
init with a GMP integer
Definition: coeffs.h:180
char *(* cfCoeffString)(const coeffs r)
string output of coeff description
Definition: coeffs.h:150
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:753
BOOLEAN(* nCoeffIsEqual)(const coeffs r, n_coeffType n, void *parameter)
Definition: coeffs.h:144
static number ndReturn0(number, const coeffs r)
Definition: numbers.cc:147
poly res
Definition: myNF.cc:322
static void ndInpMult(number &a, number b, const coeffs r)
Definition: numbers.cc:59
virtual void Reset()=0
Sets the enumerator to its initial position: -1, which is before the first element in the collection...
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:220
number(* cfInit)(long i, const coeffs r)
init with an integer
Definition: coeffs.h:177
number(* cfNormalizeHelper)(number a, number b, const coeffs r)
Definition: coeffs.h:268
BOOLEAN(* cfInitCharProc)(coeffs, void *)
initialize an object of type coeff, return FALSE in case of success
Definition: numbers.h:89
static number ndInitMPZ(mpz_t m, const coeffs r)
Definition: numbers.cc:280
BOOLEAN ngcInitChar(coeffs n, void *parameter)
Initialize r (n_long_C)
Definition: gnumpc.cc:464
const ring r
Definition: syzextra.cc:208
static int ndParDeg(number n, const coeffs r)
Definition: numbers.cc:120
Coefficient rings, fields and other domains suitable for Singular polynomials.
BOOLEAN(*)(*)(*)(*)(*)(*) cfGreaterZero(number a, const coeffs r)
Definition: coeffs.h:234
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:911
long(* cfInt)(number &n, const coeffs r)
convertion to long, 0 if impossible
Definition: coeffs.h:186
void(* cfInpMult)(number &a, number b, const coeffs r)
Inplace: a *= b.
Definition: coeffs.h:278
n_coeffType nRegister(n_coeffType n, cfInitCharProc p)
Definition: numbers.cc:518
numberfunc cfSub
Definition: coeffs.h:174
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:488
static void ndClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Definition: numbers.cc:155
BOOLEAN nrnInitChar(coeffs r, void *p)
Definition: rmodulon.cc:163
static number ndGetDenom(number &, const coeffs r)
Definition: numbers.cc:150
#define omFree(addr)
Definition: omAllocDecl.h:261
number(* cfImPart)(number a, const coeffs r)
Definition: coeffs.h:200
#define assume(x)
Definition: mod2.h:405
number(* cfInpNeg)(number a, const coeffs r)
changes argument inline: a:= -a return -a! (no copy is returned) the result should be assigned to the...
Definition: coeffs.h:194
The main handler for Singular numbers which are suitable for Singular polynomials.
BOOLEAN nrzInitChar(coeffs r, void *)
Definition: rintegers.cc:488
Templated enumerator interface for simple iteration over a generic collection of T's.
Definition: Enumerator.h:124
static int ndSize(number a, const coeffs r)
Definition: numbers.cc:152
void StringSetS(const char *st)
Definition: reporter.cc:128
static FORCE_INLINE BOOLEAN nCoeff_has_Units(const coeffs r)
returns TRUE, if r is not a field and r has non-trivial units
Definition: coeffs.h:815
int ref
Definition: coeffs.h:125
void(* cfPower)(number a, int i, number *result, const coeffs r)
Definition: coeffs.h:236
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete/n_New are empty operations.
Definition: coeffs.h:907
static FORCE_INLINE void n_Write(number &n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:592
virtual reference Current()=0
Gets the current element in the collection (read and write).
nCoeffsEnumeratorFunc cfClearContent
function pointer behind n_ClearContent
Definition: coeffs.h:306
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:923
All the auxiliary stuff.
n_Procs_s * cf_root
Definition: numbers.cc:47
void nNew(number *d)
Definition: numbers.cc:49
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible ...
Definition: coeffs.h:565
int m
Definition: cfEzgcd.cc:119
numberfunc cfExactDiv
Definition: coeffs.h:174
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:919
int i
Definition: cfEzgcd.cc:123
static BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void *)
Definition: numbers.cc:286
n_coeffType type
Definition: coeffs.h:127
static CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:260
numberfunc cfDiv
Definition: coeffs.h:174
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:465
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:837
const char *(* cfRead)(const char *s, number *a, const coeffs r)
Definition: coeffs.h:220
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
numberfunc cfMult
Definition: coeffs.h:174
BOOLEAN nfInitChar(coeffs r, void *parameter)
Definition: ffields.cc:836
cfInitCharProc nInitCharTableDefault[]
Definition: numbers.cc:294
static number ndGcd(number, number, const coeffs r)
Definition: numbers.cc:148
n_coeffType
Definition: coeffs.h:27
static number ndExtGcd(number, number, number *, number *, const coeffs r)
Definition: numbers.cc:257
static cfInitCharProc * nInitCharTable
Definition: numbers.cc:323
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition: coeffs.h:452
void(* cfWriteLong)(number a, const coeffs r)
print a given number (long format)
Definition: coeffs.h:203
BOOLEAN ngfInitChar(coeffs n, void *parameter)
Initialize r.
Definition: gnumpfl.cc:443
virtual bool MoveNext()=0
Advances the enumerator to the next element of the collection. returns true if the enumerator was suc...
number(* cfGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:243
static void ndSetChar(const coeffs)
Definition: numbers.cc:250
static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext(const coeffs r)
is it an alg. ext. of Q?
Definition: coeffs.h:915
number(* cfLcm)(number a, number b, const coeffs r)
Definition: coeffs.h:267
static void ndInpAdd(number &a, number b, const coeffs r)
Definition: numbers.cc:65
number(* convFactoryNSingN)(const CanonicalForm n, const coeffs r)
conversion to CanonicalForm(factory) to number
Definition: coeffs.h:312
number(* cfChineseRemainder)(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs)
chinese remainder returns X with X mod q[i]=x[i], i=0..rl-1
Definition: coeffs.h:294
static number ndGetNumerator(number &a, const coeffs r)
Definition: numbers.cc:151
static number ndAnn(number, const coeffs)
Definition: numbers.cc:53
static number ndIntMod(number, number, const coeffs r)
Definition: numbers.cc:149
CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: numbers.cc:565
static number ndFarey(number, number, const coeffs r)
Definition: numbers.cc:109
static void ndClearDenominators(ICoeffsEnumerator &, number &d, const coeffs r)
Definition: numbers.cc:229
nMapFunc(* cfSetMap)(const coeffs src, const coeffs dst)
Definition: coeffs.h:272
char *(* cfCoeffName)(const coeffs r)
default name of cf, should substitue cfCoeffWrite, cfCoeffString
Definition: coeffs.h:153
int(* cfSize)(number n, const coeffs r)
how complicated, (0) => 0, or positive
Definition: coeffs.h:183
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:456
number(* cfAnn)(number a, const coeffs r)
Definition: coeffs.h:258
number(* cfParameter)(const int i, const coeffs r)
create i^th parameter or NULL if not possible
Definition: coeffs.h:300
BOOLEAN(*)(*)(*)(*)(*) cfIsMOne(number a, const coeffs r)
Definition: coeffs.h:229
CanonicalForm(* convSingNFactoryN)(number n, BOOLEAN setChar, const coeffs r)
Definition: coeffs.h:313
void(* cfKillChar)(coeffs r)
Definition: coeffs.h:158
int BOOLEAN
Definition: auxiliary.h:131
const poly b
Definition: syzextra.cc:213
static void ndMPZ(mpz_t result, number &n, const coeffs r)
Converts a non-negative bigint number into a GMP number.
Definition: numbers.cc:275
void Werror(const char *fmt,...)
Definition: reporter.cc:199
void(* cfInpAdd)(number &a, number b, const coeffs r)
Inplace: a += b.
Definition: coeffs.h:281
number(* cfGetNumerator)(number &n, const coeffs r)
Definition: coeffs.h:238
void(* cfWriteShort)(number a, const coeffs r)
print a given number in a shorter way, if possible e.g. in K(a): a2 instead of a^2 ...
Definition: coeffs.h:207
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int iNumberOfParameters
Number of Parameters in the coeffs (default 0)
Definition: coeffs.h:320
return result
Definition: facAbsBiFact.cc:76
number(* cfGetDenom)(number &n, const coeffs r)
Definition: coeffs.h:237
BOOLEAN(*)(*)(*) cfIsZero(number a, const coeffs r)
Definition: coeffs.h:227
BOOLEAN(*)(*) cfEqual(number a, number b, const coeffs r)
tests
Definition: coeffs.h:226
BOOLEAN ntInitChar(coeffs cf, void *infoStruct)
Initialize the coeffs object.
Definition: transext.cc:2503
nCoeffsEnumeratorFunc cfClearDenominators
function pointer behind n_ClearDenominators
Definition: coeffs.h:309
#define Warn
Definition: emacs.cc:80
int(* cfParDeg)(number x, const coeffs r)
degree for coeffcients: -1 for 0, 0 for "constants", ...
Definition: coeffs.h:297