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