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