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  WerrorS("no conversion to factory");
264  return term;
265 }
266 
267 static number ndConvFactoryNSingN( const CanonicalForm, const coeffs)
268 {
269  WerrorS("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  n2pInitChar, /* n_polyExt */
304  naInitChar, /* n_algExt */
305  ntInitChar, /* n_transExt */
306  #else
307  NULL, /* n_polyExt */
308  NULL, /* n_algExt */
309  NULL, /* n_transExt */
310  #endif
311  ngcInitChar, /* n_long_C */
312  #ifdef HAVE_RINGS
313  nrzInitChar, /* n_Z */
314  nrnInitChar, /* n_Zn */
315  nrnInitChar, /* n_Znm */
316  nr2mInitChar, /* n_Z2m */
317  #else
318  NULL, /* n_Z */
319  NULL, /* n_Zn */
320  NULL, /* n_Znm */
321  NULL, /* n_Z2m */
322  #endif
323  NULL /* n_CF */
324 };
327 /*2
328 * init operations for coeffs r
329 */
330 coeffs nInitChar(n_coeffType t, void * parameter)
331 {
332  n_Procs_s *n=cf_root;
333 
334  while((n!=NULL) && (n->nCoeffIsEqual!=NULL) && (!n->nCoeffIsEqual(n,t,parameter)))
335  n=n->next;
336 
337  if (n==NULL)
338  {
339  n=(n_Procs_s*)omAlloc0(sizeof(n_Procs_s));
340  n->next=cf_root;
341  n->ref=1;
342  n->type=t;
343 
344  // default entries (different from NULL) for some routines:
346  n->cfSize = ndSize;
349  n->cfImPart=ndReturn0;
350  n->cfDelete= ndDelete;
351  n->cfAnn = ndAnn;
352  n->cfCoeffString = ndCoeffString; // should alway be changed!
353  n->cfInpMult=ndInpMult;
354  n->cfInpAdd=ndInpAdd;
355  n->cfCopy = ndCopy;
356  n->cfIntMod=ndIntMod; /* dummy !! */
358  n->cfGcd = ndGcd;
359  n->cfNormalizeHelper = ndGcd; /* tricky, isn't it ?*/
360  n->cfLcm = ndGcd; /* tricky, isn't it ?*/
361  n->cfInitMPZ = ndInitMPZ;
362  n->cfMPZ = ndMPZ;
363  n->cfPower = ndPower;
365 
366  n->cfKillChar = ndKillChar; /* dummy */
367  n->cfSetChar = ndSetChar; /* dummy */
368  // temp. removed to catch all the coeffs which miss to implement this!
369 
371  n->cfFarey = ndFarey;
372  n->cfParDeg = ndParDeg;
373 
375 
378 
379  n->cfIsUnit = ndIsUnit;
380 #ifdef HAVE_RINGS
381  n->cfDivComp = ndDivComp;
382  n->cfDivBy = ndDivBy;
383  n->cfExtGcd = ndExtGcd;
384  //n->cfGetUnit = (nMapFunc)NULL;
385 #endif
386 
387 #ifdef LDEBUG
388  n->cfDBTest=ndDBTest;
389 #endif
390 
393 
394  BOOLEAN nOK=TRUE;
395  // init
396  if ((t<=nLastCoeffs) && (nInitCharTable[t]!=NULL))
397  nOK = (nInitCharTable[t])(n,parameter);
398  else
399  Werror("Sorry: the coeff type [%d] was not registered: it is missing in nInitCharTable", (int)t);
400  if (nOK)
401  {
402  omFreeSize(n,sizeof(*n));
403  return NULL;
404  }
405  cf_root=n;
406  // post init settings:
407  if (n->cfRePart==NULL) n->cfRePart=n->cfCopy;
408  if (n->cfExactDiv==NULL) n->cfExactDiv=n->cfDiv;
409  if (n->cfSubringGcd==NULL) n->cfSubringGcd=n->cfGcd;
410 
411 #ifdef HAVE_RINGS
412  if (n->cfGetUnit==NULL) n->cfGetUnit=n->cfCopy;
413 #endif
414 
415  if(n->cfWriteShort==NULL)
416  n->cfWriteShort = n->cfWriteLong;
417 
419  assume(n->cfSetChar!=NULL);
421  assume(n->cfMult!=NULL);
422  assume(n->cfSub!=NULL);
423  assume(n->cfAdd!=NULL);
424  assume(n->cfDiv!=NULL);
425  assume(n->cfIntMod!=NULL);
426  assume(n->cfExactDiv!=NULL);
427  assume(n->cfInit!=NULL);
428  assume(n->cfInitMPZ!=NULL);
429  assume(n->cfSize!=NULL);
430  assume(n->cfInt!=NULL);
431  assume(n->cfMPZ!=NULL);
432  //assume(n->n->cfDivComp!=NULL);
433  //assume(n->cfIsUnit!=NULL);
434  //assume(n->cfGetUnit!=NULL);
435  //assume(n->cfExtGcd!=NULL);
436  assume(n->cfInpNeg!=NULL);
437  assume(n->cfCopy!=NULL);
438 
439  assume(n->cfWriteLong!=NULL);
440  assume(n->cfWriteShort!=NULL);
441 
442  assume(n->iNumberOfParameters>= 0);
443 
444  assume( (n->iNumberOfParameters == 0 && n->pParameterNames == NULL) ||
445  (n->iNumberOfParameters > 0 && n->pParameterNames != NULL) );
446 
447  assume(n->cfParameter!=NULL);
448  assume(n->cfParDeg!=NULL);
449 
450  assume(n->cfRead!=NULL);
451  assume(n->cfNormalize!=NULL);
452  assume(n->cfGreater!=NULL);
453  //assume(n->cfDivBy!=NULL);
454  assume(n->cfEqual!=NULL);
455  assume(n->cfIsZero!=NULL);
456  assume(n->cfIsOne!=NULL);
457  assume(n->cfIsMOne!=NULL);
459  assume(n->cfGetDenom!=NULL);
461  assume(n->cfGcd!=NULL);
463  assume(n->cfDelete!=NULL);
464  assume(n->cfSetMap!=NULL);
465  assume(n->cfInpMult!=NULL);
466 // assume(n->cfInit_bigint!=NULL);
467  assume(n->cfCoeffWrite != NULL);
468 
469  assume(n->cfClearContent != NULL);
471 
472  assume(n->type==t);
473 
474 #ifndef SING_NDEBUG
475  if(n->cfKillChar==NULL) Warn("cfKillChar is NULL for coeff %d",t);
476  if(n->cfWriteLong==NULL) Warn("cfWrite is NULL for coeff %d",t);
477  if(n->cfWriteShort==NULL) Warn("cfWriteShort is NULL for coeff %d",t);
478  if(n->cfCoeffString==ndCoeffString) Warn("cfCoeffString is undefined for coeff %d",t);
479 #endif
480 
481  if( n->nNULL == NULL )
482  n->nNULL = n->cfInit(0, n); // may still remain NULL
483  }
484  else
485  {
486  n->ref++;
487  }
488  return n;
489 }
491 void nKillChar(coeffs r)
492 {
494  if (r!=NULL)
495  {
496  r->ref--;
497  if (r->ref<=0)
498  {
499  n_Procs_s tmp;
500  n_Procs_s* n=&tmp;
501  tmp.next=cf_root;
502  while((n->next!=NULL) && (n->next!=r)) n=n->next;
503  if (n->next==r)
504  {
505  n->next=n->next->next;
506  if (cf_root==r) cf_root=n->next;
507  n_Delete(&(r->nNULL),r);
508  assume (r->cfKillChar!=NULL); r->cfKillChar(r); // STATISTIC(nKillChar);
509  omFreeSize((void *)r, sizeof(n_Procs_s));
510  r=NULL;
511  }
512  else
513  {
514  WarnS("cf_root list destroyed");
515  }
516  }
517  }
518 }
521 {
522  if (n==n_unknown)
523  {
526  {
528  ((int)nLastCoeffs+1)*sizeof(cfInitCharProc));
530  ((int)nLastCoeffs)*sizeof(cfInitCharProc));
531  }
532  else
533  {
535  ((int)nLastCoeffs)*sizeof(cfInitCharProc),
536  (((int)nLastCoeffs)+1)*sizeof(cfInitCharProc));
537  }
538 
540  return nLastCoeffs;
541  }
542  else
543  {
544  if (nInitCharTable[n]!=NULL) Print("coeff %d already initialized\n",n);
545  nInitCharTable[n]=p;
546  return n;
547  }
548 }
550 coeffs nFindCoeffByName(const char *cf_name)
551 {
552  n_Procs_s* n=cf_root;
553  while(n!=NULL)
554  {
555  if ((n->cfCoeffName!=NULL)
556  && (strcmp(cf_name,n->cfCoeffName(n))==0)) return n;
557  n=n->next;
558  }
559  // TODO: parametrized cf, e.g. flint:Z/26[a]
560  return NULL;
561 }
563 void n_Print(number& a, const coeffs r)
564 {
565  assume(r != NULL);
566  n_Test(a,r);
567 
568  StringSetS("");
569  n_Write(a, r);
570  { char* s = StringEndS(); Print("%s", s); omFree(s); }
571 }
572 
574 number n_convFactoryNSingN( const CanonicalForm n, const coeffs r)
575 { STATISTIC(n_convFactoryNSingN); assume(r != NULL); assume(r->convFactoryNSingN != NULL); return r->convFactoryNSingN(n, r); }
576 
577 
579 CanonicalForm n_convSingNFactoryN( number n, BOOLEAN setChar, const coeffs r )
580 { 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:562
BOOLEAN(* cfDivBy)(number a, number b, const coeffs r)
Definition: coeffs.h:385
#define STATISTIC(f)
Definition: numstats.h:16
BOOLEAN nrInitChar(coeffs n, void *p)
Initialize r.
Definition: shortfl.cc:730
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:536
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of &#39;a&#39; and &#39;b&#39; in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ...
Definition: coeffs.h:690
const CanonicalForm int s
Definition: facAbsFact.cc:55
number(* cfCopy)(number a, const coeffs r)
return a copy of a
Definition: coeffs.h:199
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition: coeffs.h:846
const poly a
Definition: syzextra.cc:212
number(* cfExtGcd)(number a, number b, number *s, number *t, const coeffs r)
Definition: coeffs.h:248
#define Print
Definition: emacs.cc:83
numberfunc cfIntMod
Definition: coeffs.h:175
int(* cfDivComp)(number a, number b, const coeffs r)
Definition: coeffs.h:381
coeffs nFindCoeffByName(const char *cf_name)
find an existing coeff by its "CoeffName"
Definition: numbers.cc:549
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:834
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:320
static void ndKillChar(coeffs)
Definition: numbers.cc:249
?
Definition: coeffs.h:47
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
Definition: coeffs.h:873
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:419
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:190
void(* cfSetChar)(const coeffs r)
Definition: coeffs.h:161
Definition: int_poly.h:33
BOOLEAN naInitChar(coeffs cf, void *infoStruct)
Initialize the coeffs object.
Definition: algext.cc:1383
static BOOLEAN ndDivBy(number, number, const coeffs)
Definition: numbers.cc:255
#define FALSE
Definition: auxiliary.h:97
static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
multiplication of &#39;a&#39; and &#39;b&#39;; replacement of &#39;a&#39; by the product a*b
Definition: coeffs.h:645
return P p
Definition: myNF.cc:203
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:472
char const ** pParameterNames
array containing the names of Parameters (default NULL)
Definition: coeffs.h:326
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
Definition: numbers.cc:239
coeffs next
Definition: coeffs.h:125
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:272
static void ndNormalize(number &, const coeffs)
Definition: numbers.cc:146
BOOLEAN(*)(*)(*)(*) cfIsOne(number a, const coeffs r)
Definition: coeffs.h:229
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
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
number(* cfSubringGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:247
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:573
numberfunc cfAdd
Definition: coeffs.h:175
BOOLEAN(* cfGreater)(number a, number b, const coeffs r)
Definition: coeffs.h:225
void(* cfNormalize)(number &a, const coeffs r)
Definition: coeffs.h:223
static char * ndCoeffString(const coeffs r)
Definition: numbers.cc:54
number(* cfRePart)(number a, const coeffs r)
Definition: coeffs.h:200
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:448
factory&#39;s main class
Definition: canonicalform.h:75
#define TRUE
Definition: auxiliary.h:101
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:582
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:329
void(* cfCoeffWrite)(const coeffs r, BOOLEAN details)
output of coeff description via Print
Definition: coeffs.h:148
g
Definition: cfModGcd.cc:4031
void WerrorS(const char *s)
Definition: feFopen.cc:24
BOOLEAN nr2mInitChar(coeffs r, void *p)
Definition: rmodulo2m.cc:162
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:382
number(* cfGetUnit)(number a, const coeffs r)
Definition: coeffs.h:383
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:840
number(* cfFarey)(number p, number n, const coeffs)
rational reconstruction: "best" rational a/b with a/b = p mod n
Definition: coeffs.h:291
#define WarnS
Definition: emacs.cc:81
BOOLEAN npInitChar(coeffs r, void *p)
Definition: modulop.cc:500
BOOLEAN nlInitChar(coeffs r, void *p)
Definition: longrat.cc:3304
#define omAlloc(size)
Definition: omAllocDecl.h:210
number(* cfInitMPZ)(mpz_t i, const coeffs r)
init with a GMP integer
Definition: coeffs.h:181
char *(* cfCoeffString)(const coeffs r)
string output of coeff description
Definition: coeffs.h:151
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:762
BOOLEAN n2pInitChar(coeffs cf, void *infoStruct)
Definition: algext.cc:1639
BOOLEAN(* nCoeffIsEqual)(const coeffs r, n_coeffType n, void *parameter)
Definition: coeffs.h:145
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:178
number(* cfNormalizeHelper)(number a, number b, const coeffs r)
Definition: coeffs.h:271
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:460
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:237
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:924
long(* cfInt)(number &n, const coeffs r)
convertion to long, 0 if impossible
Definition: coeffs.h:187
void(* cfInpMult)(number &a, number b, const coeffs r)
Inplace: a *= b.
Definition: coeffs.h:281
n_coeffType nRegister(n_coeffType n, cfInitCharProc p)
Definition: numbers.cc:519
numberfunc cfSub
Definition: coeffs.h:175
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:490
static void ndClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Definition: numbers.cc:155
BOOLEAN nrnInitChar(coeffs r, void *p)
Definition: rmodulon.cc:167
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:201
#define assume(x)
Definition: mod2.h:403
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:195
The main handler for Singular numbers which are suitable for Singular polynomials.
BOOLEAN nrzInitChar(coeffs r, void *)
Definition: rintegers.cc:492
Templated enumerator interface for simple iteration over a generic collection of T&#39;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:831
int ref
Definition: coeffs.h:126
void(* cfPower)(number a, int i, number *result, const coeffs r)
Definition: coeffs.h:239
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete/n_New are empty operations.
Definition: coeffs.h:920
static FORCE_INLINE void n_Write(number &n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:595
virtual reference Current()=0
Gets the current element in the collection (read and write).
nCoeffsEnumeratorFunc cfClearContent
function pointer behind n_ClearContent
Definition: coeffs.h:309
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:742
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 &#39;a&#39;; raise an error if &#39;a&#39; is not invertible ...
Definition: coeffs.h:568
int m
Definition: cfEzgcd.cc:119
numberfunc cfExactDiv
Definition: coeffs.h:175
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:932
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:128
static CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:260
numberfunc cfDiv
Definition: coeffs.h:175
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:468
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:853
const char *(* cfRead)(const char *s, number *a, const coeffs r)
Definition: coeffs.h:221
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:425
numberfunc cfMult
Definition: coeffs.h:175
BOOLEAN nfInitChar(coeffs r, void *parameter)
Definition: ffields.cc:834
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:325
#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
void(* cfWriteLong)(number a, const coeffs r)
print a given number (long format)
Definition: coeffs.h:204
BOOLEAN ngfInitChar(coeffs n, void *parameter)
Initialize r.
Definition: gnumpfl.cc:440
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:246
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:928
number(* cfLcm)(number a, number b, const coeffs r)
Definition: coeffs.h:270
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:315
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:297
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:578
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:275
char *(* cfCoeffName)(const coeffs r)
default name of cf, should substitue cfCoeffWrite, cfCoeffString
Definition: coeffs.h:154
int(* cfSize)(number n, const coeffs r)
how complicated, (0) => 0, or positive
Definition: coeffs.h:184
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
number(* cfAnn)(number a, const coeffs r)
Definition: coeffs.h:261
number(* cfParameter)(const int i, const coeffs r)
create i^th parameter or NULL if not possible
Definition: coeffs.h:303
BOOLEAN(*)(*)(*)(*)(*) cfIsMOne(number a, const coeffs r)
Definition: coeffs.h:232
CanonicalForm(* convSingNFactoryN)(number n, BOOLEAN setChar, const coeffs r)
Definition: coeffs.h:316
void(* cfKillChar)(coeffs r)
Definition: coeffs.h:159
int BOOLEAN
Definition: auxiliary.h:88
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:189
void(* cfInpAdd)(number &a, number b, const coeffs r)
Inplace: a += b.
Definition: coeffs.h:284
number(* cfGetNumerator)(number &n, const coeffs r)
Definition: coeffs.h:241
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:208
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int iNumberOfParameters
Number of Parameters in the coeffs (default 0)
Definition: coeffs.h:323
return result
Definition: facAbsBiFact.cc:76
number(* cfGetDenom)(number &n, const coeffs r)
Definition: coeffs.h:240
BOOLEAN(*)(*)(*) cfIsZero(number a, const coeffs r)
Definition: coeffs.h:228
BOOLEAN(*)(*) cfEqual(number a, number b, const coeffs r)
tests
Definition: coeffs.h:227
BOOLEAN ntInitChar(coeffs cf, void *infoStruct)
Initialize the coeffs object.
Definition: transext.cc:2536
nCoeffsEnumeratorFunc cfClearDenominators
function pointer behind n_ClearDenominators
Definition: coeffs.h:312
#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:300