My Project
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 "misc/mylimits.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 #include "coeffs/ntupel.h"
28 #include "coeffs/flintcf_Qrat.h"
29 
30 #ifdef HAVE_RINGS
31 #include "coeffs/rmodulo2m.h"
32 #include "coeffs/rmodulon.h"
33 #include "coeffs/rintegers.h"
34 #endif
35 
36 #ifdef HAVE_POLYEXTENSIONS
39 #endif
40 
41 
42 //static int characteristic = 0;
43 //extern int IsPrime(int p);
44 
46 
47 void nNew(number* d) { *d=NULL; }
48 
49 
50 static void ndDelete(number* d, const coeffs) { *d=NULL; }
51 static number ndAnn(number, const coeffs) { return NULL;}
52 static char* ndCoeffString(const coeffs r)
53 {
54  return omStrDup(r->cfCoeffName(r));
55 }
56 static void ndCoeffWrite(const coeffs r,BOOLEAN)
57 {
58  PrintS(r->cfCoeffName(r));
59 }
60 static char* ndCoeffName(const coeffs r)
61 {
62  STATIC_VAR char s[20];
63  snprintf(s,11,"Coeffs(%d)",r->type);
64  return s;
65 }
66 static void ndInpMult(number &a, number b, const coeffs r)
67 {
68  number n=r->cfMult(a,b,r);
69  r->cfDelete(&a,r);
70  a=n;
71 }
72 void ndInpAdd(number &a, number b, const coeffs r)
73 {
74  number n=r->cfAdd(a,b,r);
75  r->cfDelete(&a,r);
76  a=n;
77 }
78 
79 static void ndPower(number a, int i, number * res, const coeffs r)
80 {
81  if (i==0)
82  {
83  *res = r->cfInit(1, r);
84  }
85  else if (i==1)
86  {
87  *res = r->cfCopy(a, r);
88  }
89  else if (i==2)
90  {
91  *res = r->cfMult(a, a, r);
92  }
93  else if (i<0)
94  {
95  number b = r->cfInvers(a, r);
96  ndPower(b, -i, res, r);
97  r->cfDelete(&b, r);
98  }
99  else
100  {
101  ndPower(a, i/2, res, r);
102  r->cfInpMult(*res, *res, r);
103  if (i&1)
104  {
105  r->cfInpMult(*res, a, r);
106  }
107  }
108 }
109 static number ndInvers(number a, const coeffs r)
110 {
111  number one=r->cfInit(1,r);
112  number res=r->cfDiv(one,a,r);
113  r->cfDelete(&one,r);
114  return res;
115 }
116 static number ndInvers_Ring(number a, const coeffs r)
117 {
118  if (!r->cfIsUnit(a,r)) Print("ndInvers_Ring used with non-unit\n");
119  number one=r->cfInit(1,r);
120  number res=r->cfDiv(one,a,r);
121  r->cfDelete(&one,r);
122  return res;
123 }
124 
125 static BOOLEAN ndIsUnit_Ring(number a, const coeffs r)
126 { return r->cfIsOne(a,r)|| r->cfIsMOne(a,r); }
127 static BOOLEAN ndIsUnit_Field(number a, const coeffs r)
128 { return !r->cfIsZero(a,r); }
129 static number ndGetUnit_Ring(number, const coeffs r)
130 { return r->cfInit(1,r); }
131 static number ndRandom(siRandProc p, number p1, number p2, const coeffs cf)
132 { return cf->cfInit(p(),cf); }
133 static number ndEucNorm(number a, const coeffs cf)
134 { return cf->cfInit(cf->cfSize(a,cf),cf); }
135 #ifdef LDEBUG
136 // static void nDBDummy1(number* d,char *, int) { *d=NULL; }
137 static BOOLEAN ndDBTest(number, const char *, const int, const coeffs){ return TRUE; }
138 #endif
139 
140 static number ndFarey(number,number,const coeffs r)
141 {
142  Werror("farey not implemented for %s (c=%d)",r->cfCoeffName(r),getCoeffType(r));
143  return NULL;
144 }
145 static number ndXExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
146 {
147  Werror("XExtGcd not implemented for %s (c=%d)",r->cfCoeffName(r),getCoeffType(r));
148  return NULL;
149 }
150 static number ndChineseRemainder(number *,number *,int,BOOLEAN,CFArray&,const coeffs r)
151 {
152  Werror("ChineseRemainder not implemented for %s (c=%d)",r->cfCoeffName(r),getCoeffType(r));
153  return r->cfInit(0,r);
154 }
155 number ndReadFd( const ssiInfo *f, const coeffs r)
156 {
157  Warn("ReadFd not implemented for %s (c=%d)",r->cfCoeffName(r),getCoeffType(r));
158  return NULL;
159 }
160 
161 static void ndWriteFd(number a, const ssiInfo *f, const coeffs r)
162 {
163  Warn("WriteFd not implemented for %s (c=%d)",r->cfCoeffName(r),getCoeffType(r));
164 }
165 
166 static int ndParDeg(number n, const coeffs r)
167 {
168  return (-r->cfIsZero(n,r));
169 }
170 
171 static number ndParameter(const int, const coeffs r)
172 {
173  return r->cfInit(1,r);
174 }
175 
176 BOOLEAN n_IsZeroDivisor( number a, const coeffs r)
177 {
178  BOOLEAN ret = n_IsZero(a, r);
179  int c = n_GetChar(r);
180  if (ret || (c==0) || (r->is_field))
181  return ret; /*n_IsZero(a, r)*/
182  number ch = n_Init( c, r );
183  number g = n_Gcd( ch, a, r );
184  ret = !n_IsOne (g, r);
185  n_Delete(&ch, r);
186  n_Delete(&g, r);
187  return ret;
188 }
189 
190 void ndNormalize(number&, const coeffs) { }
191 static number ndReturn0(number, const coeffs r) { return r->cfInit(0,r); }
192 number ndGcd(number, number, const coeffs r) { return r->cfInit(1,r); }
193 static number ndIntMod(number, number, const coeffs r) { return r->cfInit(0,r); }
194 static number ndGetDenom(number &, const coeffs r) { return r->cfInit(1,r); }
195 static number ndGetNumerator(number &a,const coeffs r) { return r->cfCopy(a,r); }
196 static int ndSize(number a, const coeffs r) { return (int)r->cfIsZero(a,r)==FALSE; }
197 
198 static void ndClearContent(ICoeffsEnumerator& numberCollectionEnumerator, number& c, const coeffs r)
199 {
200  assume(r != NULL);
201 
202  // no fractions
203  assume(!( nCoeff_is_Q(r) ));
204  // all coeffs are given by integers!!!
205 
206  numberCollectionEnumerator.Reset();
207 
208  if( !numberCollectionEnumerator.MoveNext() ) // empty zero polynomial?
209  {
210  c = n_Init(1, r);
211  return;
212  }
213 
214  number &curr = numberCollectionEnumerator.Current();
215 
216 #ifdef HAVE_RINGS
217  /// TODO: move to a separate implementation
218  if (nCoeff_is_Ring(r))
219  {
220  if (nCoeff_has_Units(r))
221  {
222  c = n_GetUnit(curr, r);
223 
224  if (!n_IsOne(c, r))
225  {
226  number inv = n_Invers(c, r);
227 
228  n_InpMult(curr, inv, r);
229 
230  while( numberCollectionEnumerator.MoveNext() )
231  {
232  number &n = numberCollectionEnumerator.Current();
233  n_Normalize(n, r); // ?
234  n_InpMult(n, inv, r); // TODO: either this or directly divide!!!?
235  }
236 
237  n_Delete(&inv, r);
238  }
239  } else c = n_Init(1, r);
240 
241  return;
242  }
243 #endif
244 
245  assume(!nCoeff_is_Ring(r));
247 
248  n_Normalize(curr, r); // Q: good/bad/ugly??
249 
250  if (!n_IsOne(curr, r))
251  {
252  number t = curr; // takes over the curr! note: not a reference!!!
253 
254  curr = n_Init(1, r); // ???
255 
256  number inv = n_Invers(t, r);
257 
258  while( numberCollectionEnumerator.MoveNext() )
259  {
260  number &n = numberCollectionEnumerator.Current();
261  n_InpMult(n, inv, r); // TODO: either this or directly divide!!!?
262 // n_Normalize(n, r); // ?
263  }
264 
265  n_Delete(&inv, r);
266 
267  c = t;
268  } else
269  c = n_Copy(curr, r); // c == 1 and nothing else to do...
270 }
271 
272 static void ndClearDenominators(ICoeffsEnumerator& /*numberCollectionEnumerator*/, number& d, const coeffs r)
273 {
274  assume( r != NULL );
277 
278  d = n_Init(1, r);
279 }
280 
281 static number ndCopy(number a, const coeffs) { return a; }
282 number ndCopyMap(number a, const coeffs aRing, const coeffs r)
283 {
284  // aRing and r need not be the same, but must be the same representation
285  assume(aRing->rep==r->rep);
287  return a;
288  else
289  return r->cfCopy(a, r);
290 }
291 
292 static void ndKillChar(coeffs) {}
293 static void ndSetChar(const coeffs) {}
294 
295 number nd_Copy(number a, const coeffs r) { return r->cfCopy(a, r); }
296 
297 #ifdef HAVE_RINGS
298 static BOOLEAN ndDivBy(number, number, const coeffs) { return TRUE; } // assume a,b !=0
299 static int ndDivComp(number, number, const coeffs) { return 2; }
300 static number ndExtGcd (number, number, number *, number *, const coeffs r) { return r->cfInit(1,r); }
301 #endif
302 
303 CanonicalForm ndConvSingNFactoryN( number, BOOLEAN /*setChar*/, const coeffs)
304 {
305  CanonicalForm term(0);
306  WerrorS("no conversion to factory");
307  return term;
308 }
309 
310 static number ndConvFactoryNSingN( const CanonicalForm, const coeffs)
311 {
312  WerrorS("no conversion from factory");
313  return NULL;
314 }
315 
316 /**< [in, out] a bigint number >= 0 */
317 /**< [out] the GMP equivalent */
318 /// Converts a non-negative bigint number into a GMP number.
319 static void ndMPZ(mpz_t result, number &n, const coeffs r)
320 {
321  mpz_init_set_si( result, r->cfInt(n, r) );
322 }
323 
324 static number ndInitMPZ(mpz_t m, const coeffs r)
325 {
326  return r->cfInit( mpz_get_si(m), r);
327 }
328 
329 static const char *ndRead(const char * s, number *, const coeffs r)
330 {
331  Werror("cfRead is undefined for %s",nCoeffString(r));
332  return s;
333 }
334 static nMapFunc ndSetMap(const coeffs src, const coeffs dst)
335 {
336  if (src==dst) return ndCopyMap;
337  Werror("cfSetMap is undefined for %s",nCoeffString(dst));
338  return NULL;
339 }
340 
341 static BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void *)
342 {
343  /* test, if r is an instance of nInitCoeffs(n,parameter) */
344  /* if parameter is not needed */
345  return (n==r->type);
346 }
347 
348 static number ndQuotRem (number a, number b, number * r, const coeffs R)
349 {
350  // implementation for a field: r: 0, result: n_Div
351  assume(R->is_field);
352  *r=n_Init(0,R);
353  return n_Div(a,b,R);
354 }
357 { NULL, /*n_unknown */
358  npInitChar, /* n_Zp */
359  nlInitChar, /* n_Q */
360  nrInitChar, /* n_R */
361  nfInitChar, /* n_GF */
362  ngfInitChar, /* n_long_R */
363  #ifdef HAVE_POLYEXTENSIONS
364  n2pInitChar, /* n_polyExt */
365  naInitChar, /* n_algExt */
366  ntInitChar, /* n_transExt */
367  #else
368  NULL, /* n_polyExt */
369  NULL, /* n_algExt */
370  NULL, /* n_transExt */
371  #endif
372  ngcInitChar, /* n_long_C */
373  nnInitChar, /* n_nTupel */
374  #ifdef HAVE_RINGS
375  nrzInitChar, /* n_Z */
376  nrnInitChar, /* n_Zn */
377  nrnInitChar, /* n_Znm */
378  nr2mInitChar, /* n_Z2m */
379  #else
380  NULL, /* n_Z */
381  NULL, /* n_Zn */
382  NULL, /* n_Znm */
383  NULL, /* n_Z2m */
384  #endif
385  flintQrat_InitChar, /* n_FlintQrat */
386  NULL /* n_CF */
387 };
388 
390 /*2
391 * init operations for coeffs r
392 */
393 coeffs nInitChar(n_coeffType t, void * parameter)
394 {
395  n_Procs_s *n=cf_root;
396 
397  while((n!=NULL) && (n->nCoeffIsEqual!=NULL) && (!n->nCoeffIsEqual(n,t,parameter)))
398  n=n->next;
399 
400  if (n==NULL)
401  {
402  n=(n_Procs_s*)omAlloc0(sizeof(n_Procs_s));
403  n->next=cf_root;
404  n->ref=1;
405  n->type=t;
406 
407  // default entries (different from NULL) for some routines:
409  n->cfSize = ndSize;
412  n->cfImPart=ndReturn0;
413  n->cfDelete= ndDelete;
414  n->cfAnn = ndAnn;
417  n->cfCoeffName = ndCoeffName; // should alway be changed!
418  n->cfInpAdd=ndInpAdd;
419  n->cfInpMult=ndInpMult;
420  n->cfCopy = ndCopy;
421  n->cfIntMod=ndIntMod; /* dummy !! */
423  n->cfGcd = ndGcd;
424  n->cfNormalizeHelper = ndGcd; /* tricky, isn't it ?*/
425  n->cfLcm = ndGcd; /* tricky, isn't it ?*/
426  n->cfInitMPZ = ndInitMPZ;
427  n->cfMPZ = ndMPZ;
428  n->cfPower = ndPower;
429  n->cfQuotRem = ndQuotRem;
430  n->cfInvers = ndInvers;
431  n->cfRandom = ndRandom;
432 
433  n->cfKillChar = ndKillChar; /* dummy */
434  n->cfSetChar = ndSetChar; /* dummy */
435  // temp. removed to catch all the coeffs which miss to implement this!
436 
437  n->cfChineseRemainder = ndChineseRemainder; /* not implemented */
438  n->cfFarey = ndFarey; /* not implemented */
439  n->cfParDeg = ndParDeg; /* not implemented */
440  n->cfReadFd = ndReadFd; /* not implemented */
441  n->cfWriteFd = ndWriteFd; /* not implemented */
442 
444 
447 
448  n->cfEucNorm = ndEucNorm;
449 #ifdef HAVE_RINGS
450  n->cfDivComp = ndDivComp;
451  n->cfDivBy = ndDivBy;
452  n->cfExtGcd = ndExtGcd;
453  n->cfXExtGcd = ndXExtGcd;
454  //n->cfGetUnit = ndGetUnit_Ring;// set afterwards
455 #endif
456 
457  // report error, if not redefined
458  n->cfRead=ndRead;
459  n->cfSetMap=ndSetMap;
460 
461 #ifdef LDEBUG
462  n->cfDBTest=ndDBTest;
463 #endif
464 
467 
468  BOOLEAN nOK=TRUE;
469  // init
470  if ((t<=nLastCoeffs) && (nInitCharTable[t]!=NULL))
471  nOK = (nInitCharTable[t])(n,parameter);
472  else
473  Werror("Sorry: the coeff type [%d] was not registered: it is missing in nInitCharTable", (int)t);
474  if (nOK)
475  {
476  omFreeSize(n,sizeof(*n));
477  return NULL;
478  }
479  cf_root=n;
480  // post init settings:
481  if (n->cfRePart==NULL) n->cfRePart=n->cfCopy;
482  if (n->cfExactDiv==NULL) n->cfExactDiv=n->cfDiv;
483  if (n->cfSubringGcd==NULL) n->cfSubringGcd=n->cfGcd;
484  if (n->cfWriteShort==NULL) n->cfWriteShort = n->cfWriteLong;
485  if (n->cfIsUnit==NULL)
486  {
487  if (n->is_field) n->cfIsUnit=ndIsUnit_Field;
488  else n->cfIsUnit=ndIsUnit_Ring;
489  }
490  #ifdef HAVE_RINGS
491  if (n->cfGetUnit==NULL)
492  {
493  if (n->is_field) n->cfGetUnit=n->cfCopy;
494  else n->cfGetUnit=ndGetUnit_Ring;
495  }
496  if ((n->cfInvers==ndInvers)&&(n->is_field))
497  {
499  }
500  #endif
501 
502 
503  if(n->cfMult==NULL) PrintS("cfMult missing\n");
504  if(n->cfSub==NULL) PrintS("cfSub missing\n");
505  if(n->cfAdd==NULL) PrintS("cfAdd missing\n");
506  if(n->cfDiv==NULL) PrintS("cfDiv missing\n");
507  if(n->cfExactDiv==NULL) PrintS("cfExactDiv missing\n");
508  if(n->cfInit==NULL) PrintS("cfInit missing\n");
509  if(n->cfInt==NULL) PrintS("cfInt missing\n");
510  if(n->cfIsUnit==NULL) PrintS("cfIsUnit missing\n");
511  if(n->cfGetUnit==NULL) PrintS("cfGetUnit missing\n");
512  if(n->cfInpNeg==NULL) PrintS("cfInpNeg missing\n");
513  if(n->cfXExtGcd==NULL) PrintS("cfXExtGcd missing\n");
514  if(n->cfAnn==NULL) PrintS("cfAnn missing\n");
515  if(n->cfWriteLong==NULL) PrintS("cfWriteLong missing\n");
516 
517  assume(n->iNumberOfParameters>= 0);
518 
519  assume( (n->iNumberOfParameters == 0 && n->pParameterNames == NULL) ||
520  (n->iNumberOfParameters > 0 && n->pParameterNames != NULL) );
521 
522 
523  if(n->cfGreater==NULL) PrintS("cfGreater missing\n");
524  if(n->cfEqual==NULL) PrintS("cfEqual missing\n");
525  if(n->cfIsZero==NULL) PrintS("cfIsZero missing\n");
526  if(n->cfIsOne==NULL) PrintS("cfIsOne missing\n");
527  if(n->cfIsMOne==NULL) PrintS("cfIsMOne missing\n");
528  if(n->cfGreaterZero==NULL) PrintS("cfGreaterZero missing\n");
529  /* error reporter:
530  if(n->cfRead==ndRead) PrintS("cfRead missing\n");
531  if(n->cfSetMap==ndSetMap) PrintS("cfSetMap missing\n");
532  */
533 
534  assume(n->type==t);
535 
536 #ifndef SING_NDEBUG
537  if(n->cfWriteLong==NULL) Warn("cfWrite is NULL for coeff %d",t);
538  if(n->cfWriteShort==NULL) Warn("cfWriteShort is NULL for coeff %d",t);
539 #endif
540  }
541  else
542  {
543  n->ref++;
544  }
545  return n;
546 }
547 
548 void nKillChar(coeffs r)
549 {
550  if (r!=NULL)
551  {
552  r->ref--;
553  if (r->ref<=0)
554  {
555  n_Procs_s tmp;
556  n_Procs_s* n=&tmp;
557  tmp.next=cf_root;
558  while((n->next!=NULL) && (n->next!=r)) n=n->next;
559  if (n->next==r)
560  {
561  n->next=n->next->next;
562  if (cf_root==r) cf_root=n->next;
563  assume (r->cfKillChar!=NULL); r->cfKillChar(r);
564  omFreeSize((void *)r, sizeof(n_Procs_s));
565  r=NULL;
566  }
567  else
568  {
569  WarnS("cf_root list destroyed");
570  }
571  }
572  }
573 }
574 
576 {
577  if (n==n_unknown)
578  {
581  {
583  ((int)nLastCoeffs+1)*sizeof(cfInitCharProc));
585  ((int)nLastCoeffs)*sizeof(cfInitCharProc));
586  }
587  else
588  {
590  ((int)nLastCoeffs)*sizeof(cfInitCharProc),
591  (((int)nLastCoeffs)+1)*sizeof(cfInitCharProc));
592  }
593 
595  return nLastCoeffs;
596  }
597  else
598  {
599  if (nInitCharTable[n]!=NULL) Print("coeff %d already initialized\n",n);
600  nInitCharTable[n]=p;
601  return n;
602  }
603 }
604 
605 struct nFindCoeffByName_s;
606 typedef struct nFindCoeffByName_s* nFindCoeffByName_p;
607 
608 struct nFindCoeffByName_s
609 {
612  nFindCoeffByName_p next;
613 };
614 
615 VAR nFindCoeffByName_p nFindCoeffByName_Root=NULL;
617 {
618  nFindCoeffByName_p h=(nFindCoeffByName_p)omAlloc0(sizeof(*h));
619  h->p=p;
620  h->n=n;
621  h->next=nFindCoeffByName_Root;
623 }
624 
625 coeffs nFindCoeffByName(char *cf_name)
626 {
627  n_Procs_s* n=cf_root;
628  // try existings coeffs:
629  while(n!=NULL)
630  {
631  if ((n->cfCoeffName!=NULL)
632  && (strcmp(cf_name,n->cfCoeffName(n))==0)) return n;
633  n=n->next;
634  }
635  // TODO: parametrized cf, e.g. flint:Z/26[a]
636  // try existing types:
637  nFindCoeffByName_p p=nFindCoeffByName_Root;
638  while(p!=NULL)
639  {
640  coeffs cf=p->p(cf_name,p->n);
641  if (cf!=NULL) return cf;
642  p=p->next;
643  }
644  return NULL;
645 }
646 
647 void n_Print(number& a, const coeffs r)
648 {
649  assume(r != NULL);
650  n_Test(a,r);
651 
652  StringSetS("");
653  n_Write(a, r);
654  { char* s = StringEndS(); Print("%s", s); omFree(s); }
655 }
656 
657 char* nEati(char *s, int *i, int m)
658 {
659 
660  if (((*s) >= '0') && ((*s) <= '9'))
661  {
662  unsigned long ii=0L;
663  do
664  {
665  ii *= 10;
666  ii += *s++ - '0';
667  if ((m!=0) && (ii > (MAX_INT_VAL / 10))) ii = ii % m;
668  }
669  while (((*s) >= '0') && ((*s) <= '9'));
670  if ((m!=0) && (ii>=(unsigned)m)) ii=ii%m;
671  *i=(int)ii;
672  }
673  else (*i) = 1;
674  return s;
675 }
676 
677 /// extracts a long integer from s, returns the rest
678 char * nEatLong(char *s, mpz_ptr i)
679 {
680  const char * start=s;
681 
682  while (*s >= '0' && *s <= '9') s++;
683  if (*s=='\0')
684  {
685  mpz_set_str(i,start,10);
686  }
687  else
688  {
689  char c=*s;
690  *s='\0';
691  mpz_set_str(i,start,10);
692  *s=c;
693  }
694  return s;
695 }
696 
BOOLEAN naInitChar(coeffs cf, void *infoStruct)
Initialize the coeffs object.
Definition: algext.cc:1388
BOOLEAN n2pInitChar(coeffs cf, void *infoStruct)
Definition: algext.cc:1642
All the auxiliary stuff.
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
int m
Definition: cfEzgcd.cc:128
int i
Definition: cfEzgcd.cc:132
int p
Definition: cfModGcd.cc:4078
g
Definition: cfModGcd.cc:4090
CanonicalForm cf
Definition: cfModGcd.cc:4083
CanonicalForm b
Definition: cfModGcd.cc:4103
FILE * f
Definition: checklibs.c:9
factory's main class
Definition: canonicalform.h:86
virtual reference Current()=0
Gets the current element in the collection (read and write).
virtual void Reset()=0
Sets the enumerator to its initial position: -1, which is before the first element in the collection.
virtual bool MoveNext()=0
Advances the enumerator to the next element of the collection. returns true if the enumerator was suc...
Templated enumerator interface for simple iteration over a generic collection of T's.
Definition: Enumerator.h:125
Definition: int_poly.h:33
Coefficient rings, fields and other domains suitable for Singular polynomials.
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition: coeffs.h:451
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
Definition: coeffs.h:959
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:797
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:839
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:712
n_coeffType
Definition: coeffs.h:27
@ n_CF
?
Definition: coeffs.h:48
@ n_unknown
Definition: coeffs.h:28
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:664
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:564
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition: coeffs.h:832
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
Definition: coeffs.h:859
static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext(const coeffs r)
is it an alg. ext. of Q?
Definition: coeffs.h:914
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
Definition: coeffs.h:615
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:806
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:464
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:532
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete/n_New are empty operations.
Definition: coeffs.h:906
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:730
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:591
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:800
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:538
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:910
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:641
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:578
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:468
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:918
#define Print
Definition: emacs.cc:80
#define Warn
Definition: emacs.cc:77
#define WarnS
Definition: emacs.cc:78
return result
Definition: facAbsBiFact.cc:75
const CanonicalForm int s
Definition: facAbsFact.cc:51
CanonicalForm res
Definition: facAbsFact.cc:60
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
void WerrorS(const char *s)
Definition: feFopen.cc:24
BOOLEAN nfInitChar(coeffs r, void *parameter)
Definition: ffields.cc:858
BOOLEAN flintQrat_InitChar(coeffs cf, void *infoStruct)
#define STATIC_VAR
Definition: globaldefs.h:7
#define VAR
Definition: globaldefs.h:5
BOOLEAN ngcInitChar(coeffs n, void *parameter)
Initialize r (n_long_C)
Definition: gnumpc.cc:568
BOOLEAN ngfInitChar(coeffs n, void *parameter)
Initialize r.
Definition: gnumpfl.cc:513
STATIC_VAR Poly * h
Definition: janet.cc:971
BOOLEAN nlInitChar(coeffs r, void *p)
Definition: longrat.cc:3475
#define assume(x)
Definition: mod2.h:389
BOOLEAN npInitChar(coeffs r, void *p)
Definition: modulop.cc:340
const int MAX_INT_VAL
Definition: mylimits.h:12
The main handler for Singular numbers which are suitable for Singular polynomials.
BOOLEAN nnInitChar(coeffs n, void *p)
Initialize r.
Definition: ntupel.cc:616
static void ndPower(number a, int i, number *res, const coeffs r)
Definition: numbers.cc:79
static BOOLEAN ndIsUnit_Field(number a, const coeffs r)
Definition: numbers.cc:127
void nRegisterCfByName(cfInitCfByNameProc p, n_coeffType n)
Definition: numbers.cc:615
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:303
static int ndDivComp(number, number, const coeffs)
Definition: numbers.cc:299
static number ndEucNorm(number a, const coeffs cf)
Definition: numbers.cc:133
VAR nFindCoeffByName_p nFindCoeffByName_Root
Definition: numbers.cc:614
static number ndGetUnit_Ring(number, const coeffs r)
Definition: numbers.cc:129
static BOOLEAN ndDBTest(number, const char *, const int, const coeffs)
Definition: numbers.cc:137
number ndGcd(number, number, const coeffs r)
Definition: numbers.cc:192
static void ndKillChar(coeffs)
Definition: numbers.cc:292
static number ndConvFactoryNSingN(const CanonicalForm, const coeffs)
[in, out] a bigint number >= 0
Definition: numbers.cc:310
static void ndClearDenominators(ICoeffsEnumerator &, number &d, const coeffs r)
Definition: numbers.cc:272
static void ndClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Definition: numbers.cc:198
number ndReadFd(const ssiInfo *f, const coeffs r)
Definition: numbers.cc:155
static int ndParDeg(number n, const coeffs r)
Definition: numbers.cc:166
static BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void *)
Definition: numbers.cc:340
static char * ndCoeffString(const coeffs r)
Definition: numbers.cc:52
VAR n_Procs_s * cf_root
Definition: numbers.cc:45
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
Definition: numbers.cc:282
static BOOLEAN ndIsUnit_Ring(number a, const coeffs r)
Definition: numbers.cc:125
static char * ndCoeffName(const coeffs r)
Definition: numbers.cc:60
void ndNormalize(number &, const coeffs)
Definition: numbers.cc:190
void n_Print(number &a, const coeffs r)
print a number (BEWARE of string buffers!) mostly for debugging
Definition: numbers.cc:646
nFindCoeffByName_p next
Definition: numbers.cc:611
static int ndSize(number a, const coeffs r)
Definition: numbers.cc:196
static number ndIntMod(number, number, const coeffs r)
Definition: numbers.cc:193
void ndInpAdd(number &a, number b, const coeffs r)
Definition: numbers.cc:72
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:392
static void ndWriteFd(number a, const ssiInfo *f, const coeffs r)
Definition: numbers.cc:161
static number ndFarey(number, number, const coeffs r)
Definition: numbers.cc:140
void nNew(number *d)
Definition: numbers.cc:47
static void ndMPZ(mpz_t result, number &n, const coeffs r)
Converts a non-negative bigint number into a GMP number.
Definition: numbers.cc:318
STATIC_VAR n_coeffType nLastCoeffs
Definition: numbers.cc:354
static number ndAnn(number, const coeffs)
Definition: numbers.cc:51
static number ndGetDenom(number &, const coeffs r)
Definition: numbers.cc:194
static void ndDelete(number *d, const coeffs)
Definition: numbers.cc:50
STATIC_VAR cfInitCharProc * nInitCharTable
Definition: numbers.cc:388
n_coeffType n
Definition: numbers.cc:609
static number ndInvers_Ring(number a, const coeffs r)
Definition: numbers.cc:116
static number ndParameter(const int, const coeffs r)
Definition: numbers.cc:171
static number ndXExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition: numbers.cc:145
static number ndCopy(number a, const coeffs)
Definition: numbers.cc:281
static void ndInpMult(number &a, number b, const coeffs r)
Definition: numbers.cc:66
static const char * ndRead(const char *s, number *, const coeffs r)
Definition: numbers.cc:328
VAR cfInitCharProc nInitCharTableDefault[]
Definition: numbers.cc:355
static number ndChineseRemainder(number *, number *, int, BOOLEAN, CFArray &, const coeffs r)
Definition: numbers.cc:150
coeffs nFindCoeffByName(char *cf_name)
find an existing coeff by its "CoeffName"
Definition: numbers.cc:624
static number ndGetNumerator(number &a, const coeffs r)
Definition: numbers.cc:195
static BOOLEAN ndDivBy(number, number, const coeffs)
Definition: numbers.cc:298
static number ndInitMPZ(mpz_t m, const coeffs r)
Definition: numbers.cc:323
cfInitCfByNameProc p
Definition: numbers.cc:610
char * nEatLong(char *s, mpz_ptr i)
extracts a long integer from s, returns the rest
Definition: numbers.cc:677
number nd_Copy(number a, const coeffs r)
Definition: numbers.cc:295
static nMapFunc ndSetMap(const coeffs src, const coeffs dst)
Definition: numbers.cc:333
static number ndInvers(number a, const coeffs r)
Definition: numbers.cc:109
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:176
static void ndCoeffWrite(const coeffs r, BOOLEAN)
Definition: numbers.cc:56
n_coeffType nRegister(n_coeffType n, cfInitCharProc p)
Definition: numbers.cc:574
static number ndRandom(siRandProc p, number p1, number p2, const coeffs cf)
Definition: numbers.cc:131
static number ndReturn0(number, const coeffs r)
Definition: numbers.cc:191
static number ndExtGcd(number, number, number *, number *, const coeffs r)
Definition: numbers.cc:300
static number ndQuotRem(number a, number b, number *r, const coeffs R)
Definition: numbers.cc:347
char * nEati(char *s, int *i, int m)
divide by the first (leading) number and return it, i.e. make monic
Definition: numbers.cc:656
static void ndSetChar(const coeffs)
Definition: numbers.cc:293
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:547
coeffs(* cfInitCfByNameProc)(char *s, n_coeffType n)
initialize an object of type coeffs by its name, return NULL otherwise
Definition: numbers.h:98
BOOLEAN(* cfInitCharProc)(coeffs, void *)
initialize an object of type coeff, return FALSE in case of success
Definition: numbers.h:94
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:220
#define omFree(addr)
Definition: omAllocDecl.h:261
#define omAlloc0(size)
Definition: omAllocDecl.h:211
#define NULL
Definition: omList.c:12
void StringSetS(const char *st)
Definition: reporter.cc:128
void PrintS(const char *s)
Definition: reporter.cc:284
char * StringEndS()
Definition: reporter.cc:151
void Werror(const char *fmt,...)
Definition: reporter.cc:189
BOOLEAN nrzInitChar(coeffs r, void *parameter)
BOOLEAN nr2mInitChar(coeffs r, void *p)
Definition: rmodulo2m.cc:797
BOOLEAN nrnInitChar(coeffs r, void *p)
Definition: rmodulon.cc:996
Definition: s_buff.h:21
BOOLEAN nrInitChar(coeffs n, void *p)
Initialize r.
Definition: shortfl.cc:658
#define R
Definition: sirandom.c:27
int(* siRandProc)()
Definition: sirandom.h:9
BOOLEAN(* cfIsUnit)(number a, const coeffs r)
Definition: coeffs.h:378
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
number(* cfNormalizeHelper)(number a, number b, const coeffs r)
Definition: coeffs.h:271
int(* cfDivComp)(number a, number b, const coeffs r)
Definition: coeffs.h:377
BOOLEAN(*)(*)(*)(*)(*)(*) cfGreaterZero(number a, const coeffs r)
Definition: coeffs.h:237
number(* cfExtGcd)(number a, number b, number *s, number *t, const coeffs r)
Definition: coeffs.h:248
number(* cfGetUnit)(number a, const coeffs r)
Definition: coeffs.h:379
number(* cfLcm)(number a, number b, const coeffs r)
Definition: coeffs.h:270
number(* cfGetNumerator)(number &n, const coeffs r)
Definition: coeffs.h:241
number(* cfInvers)(number a, const coeffs r)
return 1/a
Definition: coeffs.h:197
number(* cfInit)(long i, const coeffs r)
init with an integer
Definition: coeffs.h:178
int iNumberOfParameters
Number of Parameters in the coeffs (default 0)
Definition: coeffs.h:319
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
number(* cfInitMPZ)(mpz_t i, const coeffs r)
init with a GMP integer
Definition: coeffs.h:181
BOOLEAN is_field
TRUE, if cf is a field.
Definition: coeffs.h:140
char *(* cfCoeffName)(const coeffs r)
default name of cf, should substitue cfCoeffWrite, cfCoeffString
Definition: coeffs.h:154
nMapFunc(* cfSetMap)(const coeffs src, const coeffs dst)
Definition: coeffs.h:275
number(* cfParameter)(const int i, const coeffs r)
create i^th parameter or NULL if not possible
Definition: coeffs.h:303
void(* cfSetChar)(const coeffs r)
Definition: coeffs.h:161
number(* convFactoryNSingN)(const CanonicalForm n, const coeffs r)
conversion to CanonicalForm(factory) to number
Definition: coeffs.h:315
number(* cfGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:246
number(* cfImPart)(number a, const coeffs r)
Definition: coeffs.h:201
number(* cfFarey)(number p, number n, const coeffs)
rational reconstruction: "best" rational a/b with a/b = p mod n
Definition: coeffs.h:291
coeffs next
Definition: coeffs.h:125
number(* cfCopy)(number a, const coeffs r)
return a copy of a
Definition: coeffs.h:199
int ref
Definition: coeffs.h:126
BOOLEAN(*)(*)(*) cfIsZero(number a, const coeffs r)
Definition: coeffs.h:228
void(* cfKillChar)(coeffs r)
Definition: coeffs.h:159
BOOLEAN(*)(*) cfEqual(number a, number b, const coeffs r)
tests
Definition: coeffs.h:227
numberfunc cfIntMod
Definition: coeffs.h:175
numberfunc cfExactDiv
Definition: coeffs.h:175
void(* cfMPZ)(mpz_t result, number &n, const coeffs r)
Converts a (integer) number n into a GMP number, 0 if impossible.
Definition: coeffs.h:190
BOOLEAN(* nCoeffIsEqual)(const coeffs r, n_coeffType n, void *parameter)
Definition: coeffs.h:145
number(* cfXExtGcd)(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition: coeffs.h:256
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
number(* cfRePart)(number a, const coeffs r)
Definition: coeffs.h:200
void(* cfNormalize)(number &a, const coeffs r)
Definition: coeffs.h:223
numberfunc cfMult
Definition: coeffs.h:175
char *(* cfCoeffString)(const coeffs r)
string output of coeff description
Definition: coeffs.h:151
number(* cfGetDenom)(number &n, const coeffs r)
Definition: coeffs.h:240
void(* cfWriteLong)(number a, const coeffs r)
print a given number (long format)
Definition: coeffs.h:204
number(* cfSubringGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:247
BOOLEAN(*)(*)(*)(*) cfIsOne(number a, const coeffs r)
Definition: coeffs.h:229
number(* cfEucNorm)(number a, const coeffs r)
Definition: coeffs.h:258
number(* cfAnn)(number a, const coeffs r)
Definition: coeffs.h:261
number(* cfReadFd)(const ssiInfo *f, const coeffs r)
Definition: coeffs.h:278
void(* cfPower)(number a, int i, number *result, const coeffs r)
Definition: coeffs.h:239
CanonicalForm(* convSingNFactoryN)(number n, BOOLEAN setChar, const coeffs r)
Definition: coeffs.h:316
long(* cfInt)(number &n, const coeffs r)
convertion to long, 0 if impossible
Definition: coeffs.h:187
BOOLEAN(* cfGreater)(number a, number b, const coeffs r)
Definition: coeffs.h:225
number(* cfQuotRem)(number a, number b, number *rem, const coeffs r)
Definition: coeffs.h:269
void(* cfCoeffWrite)(const coeffs r, BOOLEAN details)
output of coeff description via Print
Definition: coeffs.h:148
void(* cfDelete)(number *a, const coeffs r)
Definition: coeffs.h:272
numberfunc cfSub
Definition: coeffs.h:175
BOOLEAN(* cfDBTest)(number a, const char *f, const int l, const coeffs r)
Test: is "a" a correct number?
Definition: coeffs.h:415
void(* cfWriteFd)(number a, const ssiInfo *f, const coeffs r)
Definition: coeffs.h:277
n_coeffType type
Definition: coeffs.h:128
numberfunc cfAdd
Definition: coeffs.h:175
number(* cfRandom)(siRandProc p, number p1, number p2, const coeffs cf)
a function returning random elements
Definition: coeffs.h:306
BOOLEAN(*)(*)(*)(*)(*) cfIsMOne(number a, const coeffs r)
Definition: coeffs.h:232
numberfunc cfDiv
Definition: coeffs.h:175
char const ** pParameterNames
array containing the names of Parameters (default NULL)
Definition: coeffs.h:322
int(* cfParDeg)(number x, const coeffs r)
degree for coeffcients: -1 for 0, 0 for "constants", ...
Definition: coeffs.h:300
void(* cfInpMult)(number &a, number b, const coeffs r)
Inplace: a *= b.
Definition: coeffs.h:281
int(* cfSize)(number n, const coeffs r)
how complicated, (0) => 0, or positive
Definition: coeffs.h:184
const char *(* cfRead)(const char *s, number *a, const coeffs r)
Definition: coeffs.h:221
void(* cfInpAdd)(number &a, number b, const coeffs r)
Inplace: a += b.
Definition: coeffs.h:284
BOOLEAN(* cfDivBy)(number a, number b, const coeffs r)
Definition: coeffs.h:381
nCoeffsEnumeratorFunc cfClearContent
function pointer behind n_ClearContent
Definition: coeffs.h:309
nCoeffsEnumeratorFunc cfClearDenominators
function pointer behind n_ClearDenominators
Definition: coeffs.h:312
BOOLEAN ntInitChar(coeffs cf, void *infoStruct)
Initialize the coeffs object.
Definition: transext.cc:2636