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