My Project  debian-1:4.1.1-p2+ds-4
numbers.cc
Go to the documentation of this file.
1 /*****************************************
2 * Computer Algebra System SINGULAR *
3 *****************************************/
4 
5 /*
6 * ABSTRACT: interface to coefficient aritmetics
7 */
8 
9 #include <string.h>
10 #include <stdlib.h>
11 
12 #include "misc/auxiliary.h"
13 #include "omalloc/omalloc.h"
14 #include "factory/factory.h"
15 
16 #include "reporter/reporter.h"
17 
18 #include "coeffs/coeffs.h"
19 #include "coeffs/numbers.h"
20 
21 #include "coeffs/longrat.h"
22 #include "coeffs/modulop.h"
23 #include "coeffs/gnumpfl.h"
24 #include "coeffs/gnumpc.h"
25 #include "coeffs/ffields.h"
26 #include "coeffs/shortfl.h"
27 #include "coeffs/ntupel.h"
28 
29 #ifdef HAVE_RINGS
30 #include "coeffs/rmodulo2m.h"
31 #include "coeffs/rmodulon.h"
32 #include "coeffs/rintegers.h"
33 #endif
34 
35 #ifdef HAVE_POLYEXTENSIONS
38 #endif
39 
40 
41 #ifdef HAVE_NUMSTATS
42 struct SNumberStatistic number_stats;
43 #endif /* HAVE_NUMSTATS */
44 
45 //static int characteristic = 0;
46 //extern int IsPrime(int p);
47 
49 
50 void nNew(number* d) { *d=NULL; }
51 
52 
53 static void ndDelete(number* d, const coeffs) { *d=NULL; }
54 static number ndAnn(number, const coeffs) { return NULL;}
55 static char* ndCoeffString(const coeffs r)
56 {
57  char *s=(char *)omAlloc(11);snprintf(s,11,"Coeffs(%d)",r->type);
58  return s;
59 }
60 static char* ndCoeffName(const coeffs r)
61 {
62  static 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 static 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 
117 static BOOLEAN ndIsUnit(number a, const coeffs r) { return !r->cfIsZero(a,r); }
118 #ifdef LDEBUG
119 // static void nDBDummy1(number* d,char *, int) { *d=NULL; }
120 static BOOLEAN ndDBTest(number, const char *, const int, const coeffs){ return TRUE; }
121 #endif
122 
123 static number ndFarey(number,number,const coeffs r)
124 {
125  Werror("farey not implemented for %s (c=%d)",r->cfCoeffString(r),getCoeffType(r));
126  return NULL;
127 }
128 static number ndChineseRemainder(number *,number *,int,BOOLEAN,CFArray&,const coeffs r)
129 {
130  Werror("ChineseRemainder not implemented for %s (c=%d)",r->cfCoeffString(r),getCoeffType(r));
131  return r->cfInit(0,r);
132 }
133 
134 static int ndParDeg(number n, const coeffs r)
135 {
136  return (-r->cfIsZero(n,r));
137 }
138 
139 static number ndParameter(const int, const coeffs r)
140 {
141  Werror("ndParameter: n_Parameter is not implemented/relevant for (coeff_type = %d)",getCoeffType(r));
142  return NULL;
143 }
144 
145 BOOLEAN n_IsZeroDivisor( number a, const coeffs r)
146 {
147  BOOLEAN ret = n_IsZero(a, r);
148  int c = n_GetChar(r);
149  if (ret || (c==0) || (r->is_field))
150  return ret; /*n_IsZero(a, r)*/
151  number ch = n_Init( c, r );
152  number g = n_Gcd( ch, a, r );
153  ret = !n_IsOne (g, r);
154  n_Delete(&ch, r);
155  n_Delete(&g, r);
156  return ret;
157 }
158 
159 static void ndNormalize(number&, const coeffs) { }
160 static number ndReturn0(number, const coeffs r) { return r->cfInit(0,r); }
161 number ndGcd(number, number, const coeffs r) { return r->cfInit(1,r); }
162 static number ndIntMod(number, number, const coeffs r) { return r->cfInit(0,r); }
163 static number ndGetDenom(number &, const coeffs r) { return r->cfInit(1,r); }
164 static number ndGetNumerator(number &a,const coeffs r) { return r->cfCopy(a,r); }
165 static int ndSize(number a, const coeffs r) { return (int)r->cfIsZero(a,r)==FALSE; }
166 
167 static void ndClearContent(ICoeffsEnumerator& numberCollectionEnumerator, number& c, const coeffs r)
168 {
169  assume(r != NULL);
170 
171  // no fractions
172  assume(!( nCoeff_is_Q(r) ));
173  // all coeffs are given by integers!!!
174 
175  numberCollectionEnumerator.Reset();
176 
177  if( !numberCollectionEnumerator.MoveNext() ) // empty zero polynomial?
178  {
179  c = n_Init(1, r);
180  return;
181  }
182 
183  number &curr = numberCollectionEnumerator.Current();
184 
185 #ifdef HAVE_RINGS
186  /// TODO: move to a separate implementation
187  if (nCoeff_is_Ring(r))
188  {
189  if (nCoeff_has_Units(r))
190  {
191  c = n_GetUnit(curr, r);
192 
193  if (!n_IsOne(c, r))
194  {
195  number inv = n_Invers(c, r);
196 
197  n_InpMult(curr, inv, r);
198 
199  while( numberCollectionEnumerator.MoveNext() )
200  {
201  number &n = numberCollectionEnumerator.Current();
202  n_Normalize(n, r); // ?
203  n_InpMult(n, inv, r); // TODO: either this or directly divide!!!?
204  }
205 
206  n_Delete(&inv, r);
207  }
208  } else c = n_Init(1, r);
209 
210  return;
211  }
212 #endif
213 
214  assume(!nCoeff_is_Ring(r));
216 
217  n_Normalize(curr, r); // Q: good/bad/ugly??
218 
219  if (!n_IsOne(curr, r))
220  {
221  number t = curr; // takes over the curr! note: not a reference!!!
222 
223  curr = n_Init(1, r); // ???
224 
225  number inv = n_Invers(t, r);
226 
227  while( numberCollectionEnumerator.MoveNext() )
228  {
229  number &n = numberCollectionEnumerator.Current();
230  n_InpMult(n, inv, r); // TODO: either this or directly divide!!!?
231 // n_Normalize(n, r); // ?
232  }
233 
234  n_Delete(&inv, r);
235 
236  c = t;
237  } else
238  c = n_Copy(curr, r); // c == 1 and nothing else to do...
239 }
240 
241 static void ndClearDenominators(ICoeffsEnumerator& /*numberCollectionEnumerator*/, number& d, const coeffs r)
242 {
243  assume( r != NULL );
246 
247  d = n_Init(1, r);
248 }
249 
250 static number ndCopy(number a, const coeffs) { return a; }
251 number ndCopyMap(number a, const coeffs aRing, const coeffs r)
252 {
253  // aRing and r need not be the same, but must be the same representation
254  assume(aRing->rep==r->rep);
256  return a;
257  else
258  return r->cfCopy(a, r);
259 }
260 
261 static void ndKillChar(coeffs) {}
262 static void ndSetChar(const coeffs) {}
263 
264 number nd_Copy(number a, const coeffs r) { return r->cfCopy(a, r); }
265 
266 #ifdef HAVE_RINGS
267 static BOOLEAN ndDivBy(number, number, const coeffs) { return TRUE; } // assume a,b !=0
268 static int ndDivComp(number, number, const coeffs) { return 2; }
269 static number ndExtGcd (number, number, number *, number *, const coeffs r) { return r->cfInit(1,r); }
270 #endif
271 
272 CanonicalForm ndConvSingNFactoryN( number, BOOLEAN /*setChar*/, const coeffs)
273 {
274  CanonicalForm term(0);
275  WerrorS("no conversion to factory");
276  return term;
277 }
278 
279 static number ndConvFactoryNSingN( const CanonicalForm, const coeffs)
280 {
281  WerrorS("no conversion from factory");
282  return NULL;
283 }
284 
285 /**< [in, out] a bigint number >= 0 */
286 /**< [out] the GMP equivalent */
287 /// Converts a non-negative bigint number into a GMP number.
288 static void ndMPZ(mpz_t result, number &n, const coeffs r)
289 {
290  mpz_init_set_si( result, r->cfInt(n, r) );
291 }
292 
293 static number ndInitMPZ(mpz_t m, const coeffs r)
294 {
295  return r->cfInit( mpz_get_si(m), r);
296 }
297 
298 
299 static BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void *)
300 {
301  /* test, if r is an instance of nInitCoeffs(n,parameter) */
302  /* if parameter is not needed */
303  return (n==r->type);
304 }
305 
306 static number ndQuotRem (number a, number b, number * r, const coeffs R)
307 {
308  // implementation for a field: r: 0, result: n_Div
309  assume(R->is_field);
310  *r=n_Init(0,R);
311  return n_Div(a,b,R);
312 }
315 { NULL, /*n_unknown */
316  npInitChar, /* n_Zp */
317  nlInitChar, /* n_Q */
318  nrInitChar, /* n_R */
319  nfInitChar, /* n_GF */
320  ngfInitChar, /* n_long_R */
321  #ifdef HAVE_POLYEXTENSIONS
322  n2pInitChar, /* n_polyExt */
323  naInitChar, /* n_algExt */
324  ntInitChar, /* n_transExt */
325  #else
326  NULL, /* n_polyExt */
327  NULL, /* n_algExt */
328  NULL, /* n_transExt */
329  #endif
330  ngcInitChar, /* n_long_C */
331  nnInitChar, /* n_nTupel */
332  #ifdef HAVE_RINGS
333  nrzInitChar, /* n_Z */
334  nrnInitChar, /* n_Zn */
335  nrnInitChar, /* n_Znm */
336  nr2mInitChar, /* n_Z2m */
337  #else
338  NULL, /* n_Z */
339  NULL, /* n_Zn */
340  NULL, /* n_Znm */
341  NULL, /* n_Z2m */
342  #endif
343  NULL /* n_CF */
344 };
345 
347 /*2
348 * init operations for coeffs r
349 */
350 coeffs nInitChar(n_coeffType t, void * parameter)
351 {
352  n_Procs_s *n=cf_root;
353 
354  while((n!=NULL) && (n->nCoeffIsEqual!=NULL) && (!n->nCoeffIsEqual(n,t,parameter)))
355  n=n->next;
356 
357  if (n==NULL)
358  {
359  n=(n_Procs_s*)omAlloc0(sizeof(n_Procs_s));
360  n->next=cf_root;
361  n->ref=1;
362  n->type=t;
363 
364  // default entries (different from NULL) for some routines:
366  n->cfSize = ndSize;
369  n->cfImPart=ndReturn0;
370  n->cfDelete= ndDelete;
371  n->cfAnn = ndAnn;
372  n->cfCoeffString = ndCoeffString; // should alway be changed!
373  n->cfCoeffName = ndCoeffName; // should alway be changed!
374  n->cfInpMult=ndInpMult;
375  n->cfInpAdd=ndInpAdd;
376  n->cfCopy = ndCopy;
377  n->cfIntMod=ndIntMod; /* dummy !! */
379  n->cfGcd = ndGcd;
380  n->cfNormalizeHelper = ndGcd; /* tricky, isn't it ?*/
381  n->cfLcm = ndGcd; /* tricky, isn't it ?*/
382  n->cfInitMPZ = ndInitMPZ;
383  n->cfMPZ = ndMPZ;
384  n->cfPower = ndPower;
385  n->cfQuotRem = ndQuotRem;
386  n->cfInvers = ndInvers;
387 
388  n->cfKillChar = ndKillChar; /* dummy */
389  n->cfSetChar = ndSetChar; /* dummy */
390  // temp. removed to catch all the coeffs which miss to implement this!
391 
393  n->cfFarey = ndFarey;
394  n->cfParDeg = ndParDeg;
395 
397 
400 
401  n->cfIsUnit = ndIsUnit;
402 #ifdef HAVE_RINGS
403  n->cfDivComp = ndDivComp;
404  n->cfDivBy = ndDivBy;
405  n->cfExtGcd = ndExtGcd;
406  //n->cfGetUnit = (nMapFunc)NULL;
407 #endif
408 
409 #ifdef LDEBUG
410  n->cfDBTest=ndDBTest;
411 #endif
412 
415 
416  BOOLEAN nOK=TRUE;
417  // init
418  if ((t<=nLastCoeffs) && (nInitCharTable[t]!=NULL))
419  nOK = (nInitCharTable[t])(n,parameter);
420  else
421  Werror("Sorry: the coeff type [%d] was not registered: it is missing in nInitCharTable", (int)t);
422  if (nOK)
423  {
424  omFreeSize(n,sizeof(*n));
425  return NULL;
426  }
427  cf_root=n;
428  // post init settings:
429  if (n->cfRePart==NULL) n->cfRePart=n->cfCopy;
430  if (n->cfExactDiv==NULL) n->cfExactDiv=n->cfDiv;
431  if (n->cfSubringGcd==NULL) n->cfSubringGcd=n->cfGcd;
432 
433 #ifdef HAVE_RINGS
434  if (n->cfGetUnit==NULL) n->cfGetUnit=n->cfCopy;
435 #endif
436 
437  if(n->cfWriteShort==NULL)
438  n->cfWriteShort = n->cfWriteLong;
439 
441  assume(n->cfSetChar!=NULL);
444  assume(n->cfMult!=NULL);
445  assume(n->cfSub!=NULL);
446  assume(n->cfAdd!=NULL);
447  assume(n->cfDiv!=NULL);
448  assume(n->cfIntMod!=NULL);
449  assume(n->cfExactDiv!=NULL);
450  assume(n->cfInit!=NULL);
451  assume(n->cfInitMPZ!=NULL);
452  assume(n->cfSize!=NULL);
453  assume(n->cfInt!=NULL);
454  assume(n->cfMPZ!=NULL);
455  //assume(n->n->cfDivComp!=NULL);
456  //assume(n->cfIsUnit!=NULL);
457  //assume(n->cfGetUnit!=NULL);
458  //assume(n->cfExtGcd!=NULL);
459  assume(n->cfInpNeg!=NULL);
460  assume(n->cfCopy!=NULL);
461 
462  assume(n->cfWriteLong!=NULL);
463  assume(n->cfWriteShort!=NULL);
464 
465  assume(n->iNumberOfParameters>= 0);
466 
467  assume( (n->iNumberOfParameters == 0 && n->pParameterNames == NULL) ||
468  (n->iNumberOfParameters > 0 && n->pParameterNames != NULL) );
469 
470  assume(n->cfParameter!=NULL);
471  assume(n->cfParDeg!=NULL);
472 
473  assume(n->cfRead!=NULL);
474  assume(n->cfNormalize!=NULL);
475  assume(n->cfGreater!=NULL);
476  //assume(n->cfDivBy!=NULL);
477  assume(n->cfEqual!=NULL);
478  assume(n->cfIsZero!=NULL);
479  assume(n->cfIsOne!=NULL);
480  assume(n->cfIsMOne!=NULL);
482  assume(n->cfGetDenom!=NULL);
484  assume(n->cfGcd!=NULL);
486  assume(n->cfDelete!=NULL);
487  assume(n->cfSetMap!=NULL);
488  assume(n->cfInpMult!=NULL);
489 // assume(n->cfInit_bigint!=NULL);
490  assume(n->cfCoeffWrite != NULL);
491 
492  assume(n->cfClearContent != NULL);
494 
495  assume(n->type==t);
496 
497 #ifndef SING_NDEBUG
498  if(n->cfKillChar==NULL) Warn("cfKillChar is NULL for coeff %d",t);
499  if(n->cfWriteLong==NULL) Warn("cfWrite is NULL for coeff %d",t);
500  if(n->cfWriteShort==NULL) Warn("cfWriteShort is NULL for coeff %d",t);
501  if(n->cfCoeffString==ndCoeffString) Warn("cfCoeffString is undefined for coeff %d",t);
502 #endif
503  }
504  else
505  {
506  n->ref++;
507  }
508  return n;
509 }
510 
511 void nKillChar(coeffs r)
512 {
514  if (r!=NULL)
515  {
516  r->ref--;
517  if (r->ref<=0)
518  {
519  n_Procs_s tmp;
520  n_Procs_s* n=&tmp;
521  tmp.next=cf_root;
522  while((n->next!=NULL) && (n->next!=r)) n=n->next;
523  if (n->next==r)
524  {
525  n->next=n->next->next;
526  if (cf_root==r) cf_root=n->next;
527  assume (r->cfKillChar!=NULL); r->cfKillChar(r); // STATISTIC(nKillChar);
528  omFreeSize((void *)r, sizeof(n_Procs_s));
529  r=NULL;
530  }
531  else
532  {
533  WarnS("cf_root list destroyed");
534  }
535  }
536  }
537 }
538 
540 {
541  if (n==n_unknown)
542  {
545  {
547  ((int)nLastCoeffs+1)*sizeof(cfInitCharProc));
549  ((int)nLastCoeffs)*sizeof(cfInitCharProc));
550  }
551  else
552  {
554  ((int)nLastCoeffs)*sizeof(cfInitCharProc),
555  (((int)nLastCoeffs)+1)*sizeof(cfInitCharProc));
556  }
557 
559  return nLastCoeffs;
560  }
561  else
562  {
563  if (nInitCharTable[n]!=NULL) Print("coeff %d already initialized\n",n);
564  nInitCharTable[n]=p;
565  return n;
566  }
567 }
568 
569 coeffs nFindCoeffByName(const char *cf_name)
570 {
571  n_Procs_s* n=cf_root;
572  while(n!=NULL)
573  {
574  if ((n->cfCoeffName!=NULL)
575  && (strcmp(cf_name,n->cfCoeffName(n))==0)) return n;
576  n=n->next;
577  }
578  // TODO: parametrized cf, e.g. flint:Z/26[a]
579  return NULL;
580 }
581 
582 void n_Print(number& a, const coeffs r)
583 {
584  assume(r != NULL);
585  n_Test(a,r);
586 
587  StringSetS("");
588  n_Write(a, r);
589  { char* s = StringEndS(); Print("%s", s); omFree(s); }
590 }
591 
592 
593 number n_convFactoryNSingN( const CanonicalForm n, const coeffs r)
594 { STATISTIC(n_convFactoryNSingN); assume(r != NULL); assume(r->convFactoryNSingN != NULL); return r->convFactoryNSingN(n, r); }
595 
596 
597 
598 CanonicalForm n_convSingNFactoryN( number n, BOOLEAN setChar, const coeffs r )
599 { STATISTIC(n_convSingNFactoryN); assume(r != NULL); assume(r->convSingNFactoryN != NULL); return r->convSingNFactoryN(n, setChar, r); }
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:167
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:845
ndClearDenominators
static void ndClearDenominators(ICoeffsEnumerator &, number &d, const coeffs r)
Definition: numbers.cc:241
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:267
ndConvFactoryNSingN
static number ndConvFactoryNSingN(const CanonicalForm, const coeffs)
[in, out] a bigint number >= 0
Definition: numbers.cc:279
nCoeff_is_Zp
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:830
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:259
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:262
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
ndCoeffIsEqual
static BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void *)
Definition: numbers.cc:298
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:581
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:160
naInitChar
BOOLEAN naInitChar(coeffs cf, void *infoStruct)
Initialize the coeffs object.
Definition: algext.cc:1395
ndIsUnit
static BOOLEAN ndIsUnit(number a, const coeffs r)
Definition: numbers.cc:117
ndCoeffString
static char * ndCoeffString(const coeffs r)
Definition: numbers.cc:55
gnumpc.h
nFindCoeffByName
coeffs nFindCoeffByName(const char *cf_name)
find an existing coeff by its "CoeffName"
Definition: numbers.cc:568
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:134
ndParameter
static number ndParameter(const int, const coeffs r)
Definition: numbers.cc:139
ndIntMod
static number ndIntMod(number, number, const coeffs r)
Definition: numbers.cc:162
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:251
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:305
auxiliary.h
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:852
reporter.h
StringEndS
char * StringEndS()
Definition: reporter.cc:150
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:349
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:555
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:145
ffields.h
CanonicalForm
factory's main class
Definition: canonicalform.h:77
npInitChar
BOOLEAN npInitChar(coeffs r, void *p)
Definition: modulop.cc:487
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:163
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
n_coeffType
n_coeffType
Definition: coeffs.h:26
nCoeff_is_Q
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:836
n_Procs_s::cfDiv
numberfunc cfDiv
Definition: coeffs.h:175
ndInpMult
static void ndInpMult(number &a, number b, const coeffs r)
Definition: numbers.cc:66
n_convSingNFactoryN
CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: numbers.cc:597
ndDivComp
static int ndDivComp(number, number, const coeffs)
Definition: numbers.cc:268
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:538
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:313
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:292
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
?
Definition: coeffs.h:47
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:258
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:923
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
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:758
ndCoeffName
static char * ndCoeffName(const coeffs r)
Definition: numbers.cc:60
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
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:94
ndGcd
number ndGcd(number, number, const coeffs r)
Definition: numbers.cc:161
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:919
ndAnn
static number ndAnn(number, const coeffs)
Definition: numbers.cc:54
n_Procs_s::cfGreaterZero
BOOLEAN(*)(*)(*)(*)(*)(*) cfGreaterZero(number a, const coeffs r)
Definition: coeffs.h:237
coeffs
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:902
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:208
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:261
cf_root
n_Procs_s * cf_root
Definition: numbers.cc:48
n_Procs_s::pParameterNames
const char ** pParameterNames
array containing the names of Parameters (default NULL)
Definition: coeffs.h:322
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:931
IEnumerator
Definition: Enumerator.h:124
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:2491
ndCopy
static number ndCopy(number a, const coeffs)
Definition: numbers.cc:250
ndDelete
static void ndDelete(number *d, const coeffs)
Definition: numbers.cc:53
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:827
n_convFactoryNSingN
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:592
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:709
transext.h
ndInvers
static number ndInvers(number a, const coeffs r)
Definition: numbers.cc:109
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:127
ndNormalize
static void ndNormalize(number &, const coeffs)
Definition: numbers.cc:159
Print
#define Print
Definition: emacs.cc:79
n_Procs_s::cfIsOne
BOOLEAN(*)(*)(*)(*) cfIsOne(number a, const coeffs r)
Definition: coeffs.h:229
n_Procs_s::cfAnn
number(* cfAnn)(number a, const coeffs r)
Definition: coeffs.h:261
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:188
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:165
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
WarnS
#define WarnS
Definition: emacs.cc:77
gnumpfl.h
assume
#define assume(x)
Definition: mod2.h:384
NULL
#define NULL
Definition: omList.c:9
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:852
nKillChar
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:510
ndPower
static void ndPower(number a, int i, number *res, const coeffs r)
Definition: numbers.cc:79
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:72
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:927
R
#define R
Definition: sirandom.c:26
Warn
#define Warn
Definition: emacs.cc:76
nd_Copy
number nd_Copy(number a, const coeffs r)
Definition: numbers.cc:264
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:272
nInitCharTable
static cfInitCharProc * nInitCharTable
Definition: numbers.cc:345
ndExtGcd
static number ndExtGcd(number, number, number *, number *, const coeffs r)
Definition: numbers.cc:269
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:123
ndChineseRemainder
static number ndChineseRemainder(number *, number *, int, BOOLEAN, CFArray &, const coeffs r)
Definition: numbers.cc:128
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:3318
nr2mInitChar
BOOLEAN nr2mInitChar(coeffs r, void *p)
Definition: rmodulo2m.cc:781
n_unknown
Definition: coeffs.h:28
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:1678
numbers.h
ndGetNumerator
static number ndGetNumerator(number &a, const coeffs r)
Definition: numbers.cc:164
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:209
ndDBTest
static BOOLEAN ndDBTest(number, const char *, const int, const coeffs)
Definition: numbers.cc:120
nrzInitChar
BOOLEAN nrzInitChar(coeffs r, void *)
Definition: rintegers.cc:570
n_Procs_s
Definition: coeffs.h:122
modulop.h
nLastCoeffs
static n_coeffType nLastCoeffs
Definition: numbers.cc:312
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:507
nCoeff_is_Zp_a
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
Definition: coeffs.h:872
nNew
void nNew(number *d)
Definition: numbers.cc:50
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:287
coeffs.h
omReallocSize
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:218