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