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 static void ndDelete(number* d, const coeffs) { *d=NULL; }
48 static number ndAnn(number, const coeffs cf) { WarnS("cfAnn undefined"); return n_Init(0,cf); }
49 static char* ndCoeffString(const coeffs r)
50 {
51  return omStrDup(r->cfCoeffName(r));
52 }
53 static void ndCoeffWrite(const coeffs r,BOOLEAN)
54 {
55  PrintS(r->cfCoeffName(r));
56 }
57 static char* ndCoeffName(const coeffs r)
58 {
59  STATIC_VAR char s[20];
60  snprintf(s,11,"Coeffs(%d)",r->type);
61  return s;
62 }
63 static void ndInpMult(number &a, number b, const coeffs r)
64 {
65  number n=r->cfMult(a,b,r);
66  r->cfDelete(&a,r);
67  a=n;
68 }
69 static void ndInpAdd(number &a, number b, const coeffs r)
70 {
71  number n=r->cfAdd(a,b,r);
72  r->cfDelete(&a,r);
73  a=n;
74 }
75 
76 static void ndPower(number a, int i, number * res, const coeffs r)
77 {
78  if (i==0)
79  {
80  *res = r->cfInit(1, r);
81  }
82  else if (i==1)
83  {
84  *res = r->cfCopy(a, r);
85  }
86  else if (i==2)
87  {
88  *res = r->cfMult(a, a, r);
89  }
90  else if (i<0)
91  {
92  number b = r->cfInvers(a, r);
93  ndPower(b, -i, res, r);
94  r->cfDelete(&b, r);
95  }
96  else
97  {
98  ndPower(a, i/2, res, r);
99  r->cfInpMult(*res, *res, r);
100  if (i&1)
101  {
102  r->cfInpMult(*res, a, r);
103  }
104  }
105 }
106 static number ndInvers(number a, const coeffs r)
107 {
108  number one=r->cfInit(1,r);
109  number res=r->cfDiv(one,a,r);
110  r->cfDelete(&one,r);
111  return res;
112 }
113 static number ndInvers_Ring(number a, const coeffs r)
114 {
115  if (!r->cfIsUnit(a,r)) Print("ndInvers_Ring used with non-unit\n");
116  number one=r->cfInit(1,r);
117  number res=r->cfDiv(one,a,r);
118  r->cfDelete(&one,r);
119  return res;
120 }
121 
122 static BOOLEAN ndIsUnit_Ring(number a, const coeffs r)
123 { return r->cfIsOne(a,r)|| r->cfIsMOne(a,r); }
124 static BOOLEAN ndIsUnit_Field(number a, const coeffs r)
125 { return !r->cfIsZero(a,r); }
126 static number ndGetUnit_Ring(number, const coeffs r)
127 { return r->cfInit(1,r); }
128 static number ndRandom(siRandProc p, number, number, const coeffs cf)
129 { return cf->cfInit(p(),cf); }
130 static number ndEucNorm(number a, const coeffs cf)
131 { return cf->cfInit(cf->cfSize(a,cf),cf); }
132 #ifdef LDEBUG
133 // static void nDBDummy1(number* d,char *, int) { *d=NULL; }
134 static BOOLEAN ndDBTest(number, const char *, const int, const coeffs){ return TRUE; }
135 #endif
136 
137 static number ndFarey(number,number,const coeffs r)
138 {
139  Werror("farey not implemented for %s (c=%d)",r->cfCoeffName(r),getCoeffType(r));
140  return NULL;
141 }
142 static number ndXExtGcd(number, number, number *, number *, number *, number *, const coeffs r)
143 {
144  Werror("XExtGcd not implemented for %s (c=%d)",r->cfCoeffName(r),getCoeffType(r));
145  return NULL;
146 }
147 static number ndChineseRemainder(number *,number *,int,BOOLEAN,CFArray&,const coeffs r)
148 {
149  Werror("ChineseRemainder not implemented for %s (c=%d)",r->cfCoeffName(r),getCoeffType(r));
150  return r->cfInit(0,r);
151 }
152 number ndReadFd( const ssiInfo *, const coeffs r)
153 {
154  Warn("ReadFd not implemented for %s (c=%d)",r->cfCoeffName(r),getCoeffType(r));
155  return NULL;
156 }
157 
158 static void ndWriteFd(number, const ssiInfo *, const coeffs r)
159 {
160  Warn("WriteFd not implemented for %s (c=%d)",r->cfCoeffName(r),getCoeffType(r));
161 }
162 
163 static int ndParDeg(number n, const coeffs r)
164 {
165  return (-r->cfIsZero(n,r));
166 }
167 
168 static number ndParameter(const int, const coeffs r)
169 {
170  return r->cfInit(1,r);
171 }
172 
173 BOOLEAN n_IsZeroDivisor( number a, const coeffs r)
174 {
175  BOOLEAN ret = n_IsZero(a, r);
176  int c = n_GetChar(r);
177  if (ret || (c==0) || (r->is_field))
178  return ret; /*n_IsZero(a, r)*/
179  number ch = n_Init( c, r );
180  number g = n_Gcd( ch, a, r );
181  ret = !n_IsOne (g, r);
182  n_Delete(&ch, r);
183  n_Delete(&g, r);
184  return ret;
185 }
186 
187 void ndNormalize(number&, const coeffs) { }
188 static number ndReturn0(number, const coeffs r) { return r->cfInit(0,r); }
189 number ndGcd(number, number, const coeffs r) { return r->cfInit(1,r); }
190 static number ndIntMod(number a, number b, const coeffs R)
191 {
192  if (R->is_field)
193  return R->cfInit(0,R);
194  else // implementation for a non-field:
195  {
196  number d=n_Div(a,b,R);
197  number p=n_Mult(b,d,R);
198  number r=n_Sub(a,p,R);
199  n_Delete(&p,R);
200  n_Delete(&d,R);
201  return r;
202  }
203 }
204 static number ndGetDenom(number &, const coeffs r) { return r->cfInit(1,r); }
205 static number ndGetNumerator(number &a,const coeffs r) { return r->cfCopy(a,r); }
206 static int ndSize(number a, const coeffs r) { return (int)r->cfIsZero(a,r)==FALSE; }
207 
208 static void ndClearContent(ICoeffsEnumerator& numberCollectionEnumerator, number& c, const coeffs r)
209 {
210  assume(r != NULL);
211 
212  // no fractions
213  assume(!( nCoeff_is_Q(r) ));
214  // all coeffs are given by integers!!!
215 
216  numberCollectionEnumerator.Reset();
217 
218  if( !numberCollectionEnumerator.MoveNext() ) // empty zero polynomial?
219  {
220  c = n_Init(1, r);
221  return;
222  }
223 
224  number &curr = numberCollectionEnumerator.Current();
225 
226 #ifdef HAVE_RINGS
227  /// TODO: move to a separate implementation
228  if (nCoeff_is_Ring(r))
229  {
230  if (nCoeff_has_Units(r))
231  {
232  c = n_GetUnit(curr, r);
233 
234  if (!n_IsOne(c, r))
235  {
236  number inv = n_Invers(c, r);
237 
238  n_InpMult(curr, inv, r);
239 
240  while( numberCollectionEnumerator.MoveNext() )
241  {
242  number &n = numberCollectionEnumerator.Current();
243  n_Normalize(n, r); // ?
244  n_InpMult(n, inv, r); // TODO: either this or directly divide!!!?
245  }
246 
247  n_Delete(&inv, r);
248  }
249  } else c = n_Init(1, r);
250 
251  return;
252  }
253 #endif
254 
255  assume(!nCoeff_is_Ring(r));
257 
258  n_Normalize(curr, r); // Q: good/bad/ugly??
259 
260  if (!n_IsOne(curr, r))
261  {
262  number t = curr; // takes over the curr! note: not a reference!!!
263 
264  curr = n_Init(1, r); // ???
265 
266  number inv = n_Invers(t, r);
267 
268  while( numberCollectionEnumerator.MoveNext() )
269  {
270  number &n = numberCollectionEnumerator.Current();
271  n_InpMult(n, inv, r); // TODO: either this or directly divide!!!?
272 // n_Normalize(n, r); // ?
273  }
274 
275  n_Delete(&inv, r);
276 
277  c = t;
278  } else
279  c = n_Copy(curr, r); // c == 1 and nothing else to do...
280 }
281 
282 static void ndClearDenominators(ICoeffsEnumerator& /*numberCollectionEnumerator*/, number& d, const coeffs r)
283 {
284  assume( r != NULL );
287 
288  d = n_Init(1, r);
289 }
290 
291 number ndCopyMap(number a, const coeffs aRing, const coeffs r)
292 {
293  // aRing and r need not be the same, but must be the same representation
294  assume(aRing->rep==r->rep);
296  return a;
297  else
298  return r->cfCopy(a, r);
299 }
300 
301 static void ndKillChar(coeffs) {}
302 static void ndSetChar(const coeffs) {}
303 
304 static number ndCopy(number a, const coeffs) { return a; }
305 number nd_Copy(number a, const coeffs r) { return r->cfCopy(a, r); }
306 
307 #ifdef HAVE_RINGS
308 static BOOLEAN ndDivBy(number, number, const coeffs) { return TRUE; } // assume a,b !=0
309 static int ndDivComp(number, number, const coeffs) { return 2; }
310 static number ndExtGcd (number, number, number *, number *, const coeffs r) { return r->cfInit(1,r); }
311 #endif
312 
313 CanonicalForm ndConvSingNFactoryN( number, BOOLEAN /*setChar*/, const coeffs)
314 {
315  CanonicalForm term(0);
316  WerrorS("no conversion to factory");
317  return term;
318 }
319 
320 static number ndConvFactoryNSingN( const CanonicalForm, const coeffs)
321 {
322  WerrorS("no conversion from factory");
323  return NULL;
324 }
325 
326 /**< [in, out] a bigint number >= 0 */
327 /**< [out] the GMP equivalent */
328 /// Converts a non-negative bigint number into a GMP number.
329 static void ndMPZ(mpz_t result, number &n, const coeffs r)
330 {
331  mpz_init_set_si( result, r->cfInt(n, r) );
332 }
333 
334 static number ndInitMPZ(mpz_t m, const coeffs r)
335 {
336  return r->cfInit( mpz_get_si(m), r);
337 }
338 
339 static const char *ndRead(const char * s, number *, const coeffs r)
340 {
341  Werror("cfRead is undefined for %s",nCoeffString(r));
342  return s;
343 }
344 static nMapFunc ndSetMap(const coeffs src, const coeffs dst)
345 {
346  if (src==dst) return ndCopyMap;
347  Werror("cfSetMap is undefined for %s",nCoeffString(dst));
348  return NULL;
349 }
350 
351 static BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void *)
352 {
353  /* test, if r is an instance of nInitCoeffs(n,parameter) */
354  /* if parameter is not needed */
355  return (n==r->type);
356 }
357 
358 number ndQuotRem (number a, number b, number * r, const coeffs R)
359 {
360  // implementation for a field: r: 0, result: n_Div
361  if(R->is_field)
362  {
363  *r=n_Init(0,R);
364  return n_Div(a,b,R);
365  }
366  else
367  // implementation for a non-field:
368  {
369  number d=n_Div(a,b,R);
370  number p=n_Mult(b,d,R);
371  *r=n_Sub(a,p,R);
372  n_Delete(&p,R);
373  return d;
374  }
375 }
378 { NULL, /*n_unknown */
379  npInitChar, /* n_Zp */
380  nlInitChar, /* n_Q */
381  nrInitChar, /* n_R */
382  nfInitChar, /* n_GF */
383  ngfInitChar, /* n_long_R */
384  #ifdef HAVE_POLYEXTENSIONS
385  n2pInitChar, /* n_polyExt */
386  naInitChar, /* n_algExt */
387  ntInitChar, /* n_transExt */
388  #else
389  NULL, /* n_polyExt */
390  NULL, /* n_algExt */
391  NULL, /* n_transExt */
392  #endif
393  ngcInitChar, /* n_long_C */
394  nnInitChar, /* n_nTupel */
395  #ifdef HAVE_RINGS
396  nrzInitChar, /* n_Z */
397  nrnInitChar, /* n_Zn */
398  nrnInitChar, /* n_Znm */
399  nr2mInitChar, /* n_Z2m */
400  #else
401  NULL, /* n_Z */
402  NULL, /* n_Zn */
403  NULL, /* n_Znm */
404  NULL, /* n_Z2m */
405  #endif
406  flintQrat_InitChar, /* n_FlintQrat */
407  NULL /* n_CF */
408 };
409 
411 /*2
412 * init operations for coeffs r
413 */
414 coeffs nInitChar(n_coeffType t, void * parameter)
415 {
416  n_Procs_s *n=cf_root;
417 
418  while((n!=NULL) && (n->nCoeffIsEqual!=NULL) && (!n->nCoeffIsEqual(n,t,parameter)))
419  n=n->next;
420 
421  if (n==NULL)
422  {
423  n=(n_Procs_s*)omAlloc0(sizeof(n_Procs_s));
424  n->next=cf_root;
425  n->ref=1;
426  n->type=t;
427 
428  // default entries (different from NULL) for some routines:
430  n->cfSize = ndSize;
433  n->cfImPart=ndReturn0;
434  n->cfDelete= ndDelete;
435  n->cfAnn = ndAnn;
438  n->cfCoeffName = ndCoeffName; // should alway be changed!
439  n->cfInpAdd=ndInpAdd;
440  n->cfInpMult=ndInpMult;
441  n->cfCopy = ndCopy;
442  n->cfIntMod=ndIntMod; /* dummy !! */
444  n->cfGcd = ndGcd;
445  n->cfNormalizeHelper = ndGcd; /* tricky, isn't it ?*/
446  n->cfLcm = ndGcd; /* tricky, isn't it ?*/
447  n->cfInitMPZ = ndInitMPZ;
448  n->cfMPZ = ndMPZ;
449  n->cfPower = ndPower;
450  n->cfQuotRem = ndQuotRem;
451  n->cfInvers = ndInvers;
452  n->cfRandom = ndRandom;
453 
454  n->cfKillChar = ndKillChar; /* dummy */
455  n->cfSetChar = ndSetChar; /* dummy */
456  // temp. removed to catch all the coeffs which miss to implement this!
457 
458  n->cfChineseRemainder = ndChineseRemainder; /* not implemented */
459  n->cfFarey = ndFarey; /* not implemented */
460  n->cfParDeg = ndParDeg; /* not implemented */
461  n->cfReadFd = ndReadFd; /* not implemented */
462  n->cfWriteFd = ndWriteFd; /* not implemented */
463 
465 
468 
469  n->cfEucNorm = ndEucNorm;
470 #ifdef HAVE_RINGS
471  n->cfDivComp = ndDivComp;
472  n->cfDivBy = ndDivBy;
473  n->cfExtGcd = ndExtGcd;
474  n->cfXExtGcd = ndXExtGcd;
475  //n->cfGetUnit = ndGetUnit_Ring;// set afterwards
476 #endif
477 
478  // report error, if not redefined
479  n->cfRead=ndRead;
480  n->cfSetMap=ndSetMap;
481 
482 #ifdef LDEBUG
483  n->cfDBTest=ndDBTest;
484 #endif
485 
488 
489  BOOLEAN nOK=TRUE;
490  // init
491  if ((t<=nLastCoeffs) && (nInitCharTable[t]!=NULL))
492  nOK = (nInitCharTable[t])(n,parameter);
493  else
494  Werror("Sorry: the coeff type [%d] was not registered: it is missing in nInitCharTable", (int)t);
495  if (nOK)
496  {
497  omFreeSize(n,sizeof(*n));
498  return NULL;
499  }
500  cf_root=n;
501  // post init settings:
502  if (n->cfRePart==NULL) n->cfRePart=n->cfCopy;
503  if (n->cfExactDiv==NULL) n->cfExactDiv=n->cfDiv;
504  if (n->cfSubringGcd==NULL) n->cfSubringGcd=n->cfGcd;
505  if (n->cfWriteShort==NULL) n->cfWriteShort = n->cfWriteLong;
506  if (n->cfIsUnit==NULL)
507  {
508  if (n->is_field) n->cfIsUnit=ndIsUnit_Field;
509  else n->cfIsUnit=ndIsUnit_Ring;
510  }
511  #ifdef HAVE_RINGS
512  if (n->cfGetUnit==NULL)
513  {
514  if (n->is_field) n->cfGetUnit=n->cfCopy;
515  else n->cfGetUnit=ndGetUnit_Ring;
516  }
517  if ((n->cfInvers==ndInvers)&&(n->is_field))
518  {
520  }
521  #endif
522 
523 
524  if(n->cfMult==NULL) PrintS("cfMult missing\n");
525  if(n->cfSub==NULL) PrintS("cfSub missing\n");
526  if(n->cfAdd==NULL) PrintS("cfAdd missing\n");
527  if(n->cfDiv==NULL) PrintS("cfDiv missing\n");
528  if(n->cfExactDiv==NULL) PrintS("cfExactDiv missing\n");
529  if(n->cfInit==NULL) PrintS("cfInit missing\n");
530  if(n->cfInt==NULL) PrintS("cfInt missing\n");
531  if(n->cfIsUnit==NULL) PrintS("cfIsUnit missing\n");
532  if(n->cfGetUnit==NULL) PrintS("cfGetUnit missing\n");
533  if(n->cfInpNeg==NULL) PrintS("cfInpNeg missing\n");
534  if(n->cfXExtGcd==NULL) PrintS("cfXExtGcd missing\n");
535  if(n->cfAnn==NULL) PrintS("cfAnn missing\n");
536  if(n->cfWriteLong==NULL) PrintS("cfWriteLong missing\n");
537 
538  assume(n->iNumberOfParameters>= 0);
539 
540  assume( (n->iNumberOfParameters == 0 && n->pParameterNames == NULL) ||
541  (n->iNumberOfParameters > 0 && n->pParameterNames != NULL) );
542 
543 
544  if(n->cfGreater==NULL) PrintS("cfGreater missing\n");
545  if(n->cfEqual==NULL) PrintS("cfEqual missing\n");
546  if(n->cfIsZero==NULL) PrintS("cfIsZero missing\n");
547  if(n->cfIsOne==NULL) PrintS("cfIsOne missing\n");
548  if(n->cfIsMOne==NULL) PrintS("cfIsMOne missing\n");
549  if(n->cfGreaterZero==NULL) PrintS("cfGreaterZero missing\n");
550  /* error reporter:
551  if(n->cfRead==ndRead) PrintS("cfRead missing\n");
552  if(n->cfSetMap==ndSetMap) PrintS("cfSetMap missing\n");
553  */
554 
555  assume(n->type==t);
556 
557 #ifndef SING_NDEBUG
558  if(n->cfWriteLong==NULL) Warn("cfWrite is NULL for coeff %d",t);
559  if(n->cfWriteShort==NULL) Warn("cfWriteShort is NULL for coeff %d",t);
560 #endif
561  }
562  else
563  {
564  n->ref++;
565  }
566  return n;
567 }
568 
569 void nKillChar(coeffs r)
570 {
571  if (r!=NULL)
572  {
573  r->ref--;
574  if (r->ref<=0)
575  {
576  n_Procs_s tmp;
577  n_Procs_s* n=&tmp;
578  tmp.next=cf_root;
579  while((n->next!=NULL) && (n->next!=r)) n=n->next;
580  if (n->next==r)
581  {
582  n->next=n->next->next;
583  if (cf_root==r) cf_root=n->next;
584  assume (r->cfKillChar!=NULL); r->cfKillChar(r);
585  omFreeSize((void *)r, sizeof(n_Procs_s));
586  r=NULL;
587  }
588  else
589  {
590  WarnS("cf_root list destroyed");
591  }
592  }
593  }
594 }
595 
597 {
598  if (n==n_unknown)
599  {
602  {
604  ((int)nLastCoeffs+1)*sizeof(cfInitCharProc));
606  ((int)nLastCoeffs)*sizeof(cfInitCharProc));
607  }
608  else
609  {
611  ((int)nLastCoeffs)*sizeof(cfInitCharProc),
612  (((int)nLastCoeffs)+1)*sizeof(cfInitCharProc));
613  }
614 
616  return nLastCoeffs;
617  }
618  else
619  {
620  if (nInitCharTable[n]!=NULL) Print("coeff %d already initialized\n",n);
621  nInitCharTable[n]=p;
622  return n;
623  }
624 }
625 
626 struct nFindCoeffByName_s;
627 typedef struct nFindCoeffByName_s* nFindCoeffByName_p;
628 
629 struct nFindCoeffByName_s
630 {
633  nFindCoeffByName_p next;
634 };
635 
636 VAR nFindCoeffByName_p nFindCoeffByName_Root=NULL;
638 {
639  nFindCoeffByName_p h=(nFindCoeffByName_p)omAlloc0(sizeof(*h));
640  h->p=p;
641  h->n=n;
642  h->next=nFindCoeffByName_Root;
644 }
645 
646 coeffs nFindCoeffByName(char *cf_name)
647 {
648  n_Procs_s* n=cf_root;
649  // try existings coeffs:
650  while(n!=NULL)
651  {
652  if ((n->cfCoeffName!=NULL)
653  && (strcmp(cf_name,n->cfCoeffName(n))==0)) return n;
654  n=n->next;
655  }
656  // TODO: parametrized cf, e.g. flint:Z/26[a]
657  // try existing types:
658  nFindCoeffByName_p p=nFindCoeffByName_Root;
659  while(p!=NULL)
660  {
661  coeffs cf=p->p(cf_name,p->n);
662  if (cf!=NULL) return cf;
663  p=p->next;
664  }
665  return NULL;
666 }
667 
668 void n_Print(number& a, const coeffs r)
669 {
670  assume(r != NULL);
671  n_Test(a,r);
672 
673  StringSetS("");
674  n_Write(a, r);
675  { char* s = StringEndS(); Print("%s", s); omFree(s); }
676 }
677 
678 char* nEati(char *s, int *i, int m)
679 {
680 
681  if (((*s) >= '0') && ((*s) <= '9'))
682  {
683  unsigned long ii=0L;
684  do
685  {
686  ii *= 10;
687  ii += *s++ - '0';
688  if ((m!=0) && (ii > (MAX_INT_VAL / 10))) ii = ii % m;
689  }
690  while (((*s) >= '0') && ((*s) <= '9'));
691  if ((m!=0) && (ii>=(unsigned)m)) ii=ii%m;
692  *i=(int)ii;
693  }
694  else (*i) = 1;
695  return s;
696 }
697 
698 /// extracts a long integer from s, returns the rest
699 char * nEatLong(char *s, mpz_ptr i)
700 {
701  const char * start=s;
702 
703  while (*s >= '0' && *s <= '9') s++;
704  if (*s=='\0')
705  {
706  mpz_set_str(i,start,10);
707  }
708  else
709  {
710  char c=*s;
711  *s='\0';
712  mpz_set_str(i,start,10);
713  *s=c;
714  }
715  return s;
716 }
717 
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
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_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
Definition: coeffs.h:633
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition: coeffs.h:448
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:956
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:794
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:836
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:709
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:661
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:561
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition: coeffs.h:829
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
Definition: coeffs.h:856
static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext(const coeffs r)
is it an alg. ext. of Q?
Definition: coeffs.h:911
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:612
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:803
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:461
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:529
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete is empty operation.
Definition: coeffs.h:903
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
Definition: coeffs.h:652
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:727
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:441
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:452
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:588
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:797
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:535
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:907
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:638
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:575
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:465
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:915
#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
void WerrorS(const char *s)
Definition: feFopen.cc:24
BOOLEAN nfInitChar(coeffs r, void *parameter)
Definition: ffields.cc:854
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:560
BOOLEAN ngfInitChar(coeffs n, void *parameter)
Initialize r.
Definition: gnumpfl.cc:511
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:338
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:76
static BOOLEAN ndIsUnit_Field(number a, const coeffs r)
Definition: numbers.cc:124
void nRegisterCfByName(cfInitCfByNameProc p, n_coeffType n)
Definition: numbers.cc:636
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:313
number ndReadFd(const ssiInfo *, const coeffs r)
Definition: numbers.cc:152
static int ndDivComp(number, number, const coeffs)
Definition: numbers.cc:309
static number ndEucNorm(number a, const coeffs cf)
Definition: numbers.cc:130
VAR nFindCoeffByName_p nFindCoeffByName_Root
Definition: numbers.cc:635
static number ndGetUnit_Ring(number, const coeffs r)
Definition: numbers.cc:126
static BOOLEAN ndDBTest(number, const char *, const int, const coeffs)
Definition: numbers.cc:134
number ndGcd(number, number, const coeffs r)
Definition: numbers.cc:189
static void ndKillChar(coeffs)
Definition: numbers.cc:301
static number ndConvFactoryNSingN(const CanonicalForm, const coeffs)
[in, out] a bigint number >= 0
Definition: numbers.cc:320
static void ndClearDenominators(ICoeffsEnumerator &, number &d, const coeffs r)
Definition: numbers.cc:282
static void ndClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Definition: numbers.cc:208
static int ndParDeg(number n, const coeffs r)
Definition: numbers.cc:163
static BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void *)
Definition: numbers.cc:350
static char * ndCoeffString(const coeffs r)
Definition: numbers.cc:49
VAR n_Procs_s * cf_root
Definition: numbers.cc:45
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
Definition: numbers.cc:291
static BOOLEAN ndIsUnit_Ring(number a, const coeffs r)
Definition: numbers.cc:122
static char * ndCoeffName(const coeffs r)
Definition: numbers.cc:57
void ndNormalize(number &, const coeffs)
Definition: numbers.cc:187
void n_Print(number &a, const coeffs r)
print a number (BEWARE of string buffers!) mostly for debugging
Definition: numbers.cc:667
nFindCoeffByName_p next
Definition: numbers.cc:632
static int ndSize(number a, const coeffs r)
Definition: numbers.cc:206
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:413
static number ndFarey(number, number, const coeffs r)
Definition: numbers.cc:137
static number ndRandom(siRandProc p, number, number, const coeffs cf)
Definition: numbers.cc:128
static void ndMPZ(mpz_t result, number &n, const coeffs r)
Converts a non-negative bigint number into a GMP number.
Definition: numbers.cc:328
STATIC_VAR n_coeffType nLastCoeffs
Definition: numbers.cc:375
static number ndGetDenom(number &, const coeffs r)
Definition: numbers.cc:204
static void ndDelete(number *d, const coeffs)
Definition: numbers.cc:47
STATIC_VAR cfInitCharProc * nInitCharTable
Definition: numbers.cc:409
n_coeffType n
Definition: numbers.cc:630
static number ndInvers_Ring(number a, const coeffs r)
Definition: numbers.cc:113
static number ndParameter(const int, const coeffs r)
Definition: numbers.cc:168
static number ndCopy(number a, const coeffs)
Definition: numbers.cc:304
static void ndInpMult(number &a, number b, const coeffs r)
Definition: numbers.cc:63
static const char * ndRead(const char *s, number *, const coeffs r)
Definition: numbers.cc:338
VAR cfInitCharProc nInitCharTableDefault[]
Definition: numbers.cc:376
static void ndWriteFd(number, const ssiInfo *, const coeffs r)
Definition: numbers.cc:158
static number ndChineseRemainder(number *, number *, int, BOOLEAN, CFArray &, const coeffs r)
Definition: numbers.cc:147
coeffs nFindCoeffByName(char *cf_name)
find an existing coeff by its "CoeffName"
Definition: numbers.cc:645
static number ndGetNumerator(number &a, const coeffs r)
Definition: numbers.cc:205
static BOOLEAN ndDivBy(number, number, const coeffs)
Definition: numbers.cc:308
static number ndInitMPZ(mpz_t m, const coeffs r)
Definition: numbers.cc:333
cfInitCfByNameProc p
Definition: numbers.cc:631
char * nEatLong(char *s, mpz_ptr i)
extracts a long integer from s, returns the rest
Definition: numbers.cc:698
static void ndInpAdd(number &a, number b, const coeffs r)
Definition: numbers.cc:69
number nd_Copy(number a, const coeffs r)
Definition: numbers.cc:305
static nMapFunc ndSetMap(const coeffs src, const coeffs dst)
Definition: numbers.cc:343
static number ndAnn(number, const coeffs cf)
Definition: numbers.cc:48
static number ndInvers(number a, const coeffs r)
Definition: numbers.cc:106
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:173
static number ndIntMod(number a, number b, const coeffs R)
Definition: numbers.cc:190
static void ndCoeffWrite(const coeffs r, BOOLEAN)
Definition: numbers.cc:53
n_coeffType nRegister(n_coeffType n, cfInitCharProc p)
Definition: numbers.cc:595
static number ndReturn0(number, const coeffs r)
Definition: numbers.cc:188
static number ndExtGcd(number, number, number *, number *, const coeffs r)
Definition: numbers.cc:310
char * nEati(char *s, int *i, int m)
divide by the first (leading) number and return it, i.e. make monic
Definition: numbers.cc:677
static void ndSetChar(const coeffs)
Definition: numbers.cc:302
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:568
static number ndXExtGcd(number, number, number *, number *, number *, number *, const coeffs r)
Definition: numbers.cc:142
number ndQuotRem(number a, number b, number *r, const coeffs R)
Definition: numbers.cc:357
coeffs(* cfInitCfByNameProc)(char *s, n_coeffType n)
initialize an object of type coeffs by its name, return NULL otherwise
Definition: numbers.h:99
BOOLEAN(* cfInitCharProc)(coeffs, void *)
initialize an object of type coeff, return FALSE in case of success
Definition: numbers.h:95
#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:993
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)(void)
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:416
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)
test if b divides a cfDivBy(zero,b,r) is true, if b is a zero divisor
Definition: coeffs.h:382
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