rintegers.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT: numbers (integers)
6 */
7 
8 #include <misc/auxiliary.h>
9 #include <omalloc/omalloc.h>
10 
11 #include <factory/factory.h>
12 
13 #include <misc/mylimits.h>
14 #include <reporter/reporter.h>
15 
16 #include "coeffs.h"
17 #include "numbers.h"
18 
19 #include "si_gmp.h"
20 
21 #include "mpr_complex.h"
22 #include "rintegers.h"
23 #include "rmodulon.h"
24 #include "longrat.h"
25 
26 #include <string.h>
27 
28 #ifdef HAVE_RINGS
29 
30 
31 /// Our Type!
32 static const n_coeffType ID = n_Z;
33 
34 number nrzCopy (number a, const coeffs r);
35 int nrzSize (number a, const coeffs r);
36 void nrzDelete (number *a, const coeffs r);
37 BOOLEAN nrzGreaterZero (number k, const coeffs r);
38 number nrzMult (number a, number b, const coeffs r);
39 number nrzInit (long i, const coeffs r);
40 long nrzInt (number &n, const coeffs r);
41 number nrzAdd (number a, number b, const coeffs r);
42 number nrzSub (number a, number b, const coeffs r);
43 void nrzPower (number a, int i, number * result, const coeffs r);
44 BOOLEAN nrzIsZero (number a, const coeffs r);
45 BOOLEAN nrzIsOne (number a, const coeffs r);
46 BOOLEAN nrzIsMOne (number a, const coeffs r);
47 BOOLEAN nrzIsUnit (number a, const coeffs r);
48 number nrzGetUnit (number a, const coeffs r);
49 number nrzDiv (number a, number b, const coeffs r);
50 number nrzExactDiv (number a, number b, const coeffs r);
51 number nrzIntMod (number a, number b, const coeffs r);
52 number nrzNeg (number c, const coeffs r);
53 number nrzInvers (number c, const coeffs r);
54 BOOLEAN nrzGreater (number a, number b, const coeffs r);
55 BOOLEAN nrzDivBy (number a, number b, const coeffs r);
56 int nrzDivComp (number a, number b, const coeffs r);
57 BOOLEAN nrzEqual (number a, number b, const coeffs r);
58 number nrzLcm (number a,number b, const coeffs r);
59 number nrzGcd (number a,number b, const coeffs r);
60 number nrzExtGcd (number a, number b, number *s, number *t, const coeffs r);
61 nMapFunc nrzSetMap (const coeffs src, const coeffs dst);
62 void nrzWrite (number a, const coeffs r);
63 const char * nrzRead (const char *s, number *a, const coeffs r);
64 char * nrzName (number n, const coeffs r);
65 void nrzCoeffWrite (const coeffs r, BOOLEAN details);
66 #ifdef LDEBUG
67 BOOLEAN nrzDBTest (number a, const char *f, const int l, const coeffs r);
68 #endif
69 void nrzSetExp(int c, coeffs r);
70 void nrzInitExp(int c, coeffs r);
71 void nrzDelete(number *a, const coeffs r);
72 coeffs nrzQuot1(number c, const coeffs r);
73 
74 //CanonicalForm nrzConvSingNFactoryN(number n, BOOLEAN setChar, const coeffs /*r*/);
75 //number nrzConvFactoryNSingN(const CanonicalForm n, const coeffs r);
76 
77 number nrzMapQ(number from, const coeffs src, const coeffs dst);
78 
79 
80 omBin gmp_nrz_bin = omGetSpecBin(sizeof(mpz_t));
81 
82 #if SI_INTEGER_VARIANT == 2
83 /*
84  * Multiply two numbers
85  */
86 number nrzMult (number a, number b, const coeffs)
87 {
88  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
89  mpz_init(erg);
90  mpz_mul(erg, (mpz_ptr) a, (mpz_ptr) b);
91  return (number) erg;
92 }
93 
94 /*
95  * Give the smallest non unit k, such that a * x = k = b * y has a solution
96  */
97 number nrzLcm (number a,number b,const coeffs)
98 {
99  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
100  mpz_init(erg);
101  mpz_lcm(erg, (mpz_ptr) a, (mpz_ptr) b);
102  return (number) erg;
103 }
104 
105 /*
106  * Give the largest non unit k, such that a = x * k, b = y * k has
107  * a solution.
108  */
109 number nrzGcd (number a,number b,const coeffs)
110 {
111  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
112  mpz_init(erg);
113  mpz_gcd(erg, (mpz_ptr) a, (mpz_ptr) b);
114  return (number) erg;
115 }
116 
117 /*
118  * Give the largest non unit k, such that a = x * k, b = y * k has
119  * a solution and r, s, s.t. k = s*a + t*b
120  */
121 number nrzExtGcd (number a, number b, number *s, number *t, const coeffs)
122 {
123  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
124  mpz_ptr bs = (mpz_ptr) omAllocBin(gmp_nrz_bin);
125  mpz_ptr bt = (mpz_ptr) omAllocBin(gmp_nrz_bin);
126  mpz_init(erg);
127  mpz_init(bs);
128  mpz_init(bt);
129  mpz_gcdext(erg, bs, bt, (mpz_ptr) a, (mpz_ptr) b);
130  *s = (number) bs;
131  *t = (number) bt;
132  return (number) erg;
133 }
134 
135 void nrzPower (number a, int i, number * result, const coeffs)
136 {
137  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
138  mpz_init(erg);
139  mpz_pow_ui(erg, (mpz_ptr) a, i);
140  *result = (number) erg;
141 }
142 
143 /*
144  * create a number from int
145  */
146 number nrzInit (long i, const coeffs)
147 {
148  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
149  mpz_init_set_si(erg, i);
150  return (number) erg;
151 }
152 
153 void nrzDelete(number *a, const coeffs)
154 {
155  if (*a == NULL) return;
156  mpz_clear((mpz_ptr) *a);
158  *a = NULL;
159 }
160 
161 number nrzCopy(number a, const coeffs)
162 {
163  if (a==NULL) return NULL;
164  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
165  mpz_init_set(erg, (mpz_ptr) a);
166  return (number) erg;
167 }
168 
169 #if 0
170 number nrzCopyMap(number a, const coeffs /*src*/, const coeffs dst)
171 {
172  return nrzCopy(a,dst);
173 }
174 #endif
175 
176 int nrzSize(number a, const coeffs)
177 {
178  if (a == NULL) return 0;
179  return ((mpz_ptr)a)->_mp_alloc;
180 }
181 
182 /*
183  * convert a number to int
184  */
185 long nrzInt(number &n, const coeffs)
186 {
187  return mpz_get_si( (mpz_ptr)n);
188 }
189 
190 number nrzAdd (number a, number b, const coeffs)
191 {
192  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
193  mpz_init(erg);
194  mpz_add(erg, (mpz_ptr) a, (mpz_ptr) b);
195  return (number) erg;
196 }
197 
198 number nrzSub (number a, number b, const coeffs)
199 {
200  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
201  mpz_init(erg);
202  mpz_sub(erg, (mpz_ptr) a, (mpz_ptr) b);
203  return (number) erg;
204 }
205 
206 number nrzGetUnit (number, const coeffs r)
207 {
208  return nrzInit(1, r);
209 }
210 
211 BOOLEAN nrzIsUnit (number a, const coeffs)
212 {
213  return 0 == mpz_cmpabs_ui((mpz_ptr) a, 1);
214 }
215 
216 BOOLEAN nrzIsZero (number a, const coeffs)
217 {
218  return 0 == mpz_cmpabs_ui((mpz_ptr) a, 0);
219 }
220 
221 BOOLEAN nrzIsOne (number a, const coeffs)
222 {
223  return (a!=NULL) && (0 == mpz_cmp_si((mpz_ptr) a, 1));
224 }
225 
226 BOOLEAN nrzIsMOne (number a, const coeffs)
227 {
228  return (a!=NULL) && (0 == mpz_cmp_si((mpz_ptr) a, -1));
229 }
230 
231 BOOLEAN nrzEqual (number a,number b, const coeffs)
232 {
233  return 0 == mpz_cmp((mpz_ptr) a, (mpz_ptr) b);
234 }
235 
236 BOOLEAN nrzGreater (number a,number b, const coeffs)
237 {
238  return 0 < mpz_cmp((mpz_ptr) a, (mpz_ptr) b);
239 }
240 
242 {
243  return 0 < mpz_cmp_si((mpz_ptr) k, 0);
244 }
245 
246 int nrzDivComp(number a, number b, const coeffs r)
247 {
248  if (nrzDivBy(a, b, r))
249  {
250  if (nrzDivBy(b, a, r)) return 2;
251  return -1;
252  }
253  if (nrzDivBy(b, a, r)) return 1;
254  return 0;
255 }
256 
257 BOOLEAN nrzDivBy (number a,number b, const coeffs)
258 {
259  return mpz_divisible_p((mpz_ptr) a, (mpz_ptr) b) != 0;
260 }
261 
262 number nrzDiv (number a,number b, const coeffs R)
263 {
264  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
265  mpz_init(erg);
266  mpz_ptr r = (mpz_ptr) omAllocBin(gmp_nrz_bin);
267  mpz_init(r);
268  mpz_tdiv_qr(erg, r, (mpz_ptr) a, (mpz_ptr) b);
269  //if (!nrzIsZero((number) r, R))
270  //{
271  // WerrorS("Division by non divisible element.");
272  // WerrorS("Result is without remainder.");
273  //}
274  mpz_clear(r);
276  return (number) erg;
277 }
278 
279 number nrzExactDiv (number a,number b, const coeffs)
280 {
281  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
282  mpz_init(erg);
283  mpz_tdiv_q(erg, (mpz_ptr) a, (mpz_ptr) b);
284  return (number) erg;
285 }
286 
287 number nrzIntMod (number a,number b, const coeffs)
288 {
289  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
290  mpz_init(erg);
291  mpz_ptr r = (mpz_ptr) omAllocBin(gmp_nrz_bin);
292  mpz_init(r);
293  mpz_tdiv_qr(erg, r, (mpz_ptr) a, (mpz_ptr) b);
294  mpz_clear(erg);
295  omFreeBin(erg, gmp_nrz_bin);
296  return (number) r;
297 }
298 
299 number nrzInvers (number c, const coeffs r)
300 {
301  if (!nrzIsUnit((number) c, r))
302  {
303  WerrorS("Non invertible element.");
304  return (number)0; //TODO
305  }
306  return nrzCopy(c,r);
307 }
308 
309 number nrzNeg (number c, const coeffs)
310 {
311 // nNeg inplace !!!
312  mpz_mul_si((mpz_ptr) c, (mpz_ptr) c, -1);
313  return c;
314 }
315 
316 number nrzMapMachineInt(number from, const coeffs /*src*/, const coeffs /*dst*/)
317 {
318  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
319  mpz_init_set_ui(erg, (unsigned long) from);
320  return (number) erg;
321 }
322 
323 number nrzMapZp(number from, const coeffs /*src*/, const coeffs /*dst*/)
324 {
325  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
326  mpz_init_set_si(erg, (long) from);
327  return (number) erg;
328 }
329 
330 number nrzMapQ(number from, const coeffs src, const coeffs /*dst*/)
331 {
332  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
333  mpz_init(erg);
334  nlGMP(from, (number) erg, src); // FIXME? TODO? // extern void nlGMP(number &i, number n, const coeffs r); // to be replaced with n_MPZ(erg, from, src); // ?
335  return (number) erg;
336 }
337 
338 nMapFunc nrzSetMap(const coeffs src, const coeffs /*dst*/)
339 {
340  /* dst = currRing */
341  /* dst = nrn */
342  if ((src->rep==n_rep_gmp)
343  && (nCoeff_is_Ring_Z(src) || nCoeff_is_Ring_ModN(src) || nCoeff_is_Ring_PtoM(src)))
344  {
345  return ndCopyMap; //nrzCopyMap;
346  }
347  if ((src->rep==n_rep_gap_gmp) /*&& nCoeff_is_Ring_Z(src)*/)
348  {
349  return ndCopyMap; //nrzCopyMap;
350  }
351  if (nCoeff_is_Ring_2toM(src))
352  {
353  return nrzMapMachineInt;
354  }
355  if (nCoeff_is_Zp(src))
356  {
357  return nrzMapZp;
358  }
359  if (getCoeffType(src)==n_Q /*nCoeff_is_Q(src) or coeffs_BIGINT*/)
360  {
361  return nrzMapQ;
362  }
363  return NULL; // default
364 }
365 
366 
367 /*
368  * set the exponent (allocate and init tables) (TODO)
369  */
370 
371 void nrzSetExp(int, coeffs)
372 {
373 }
374 
375 void nrzInitExp(int, coeffs)
376 {
377 }
378 
379 #ifdef LDEBUG
380 BOOLEAN nrzDBTest (number, const char *, const int, const coeffs)
381 {
382  return TRUE;//TODO
383 }
384 #endif
385 
386 void nrzWrite (number a, const coeffs)
387 {
388  char *s,*z;
389  if (a==NULL)
390  {
391  StringAppendS("o");
392  }
393  else
394  {
395  int l=mpz_sizeinbase((mpz_ptr) a, 10) + 2;
396  s=(char*)omAlloc(l);
397  z=mpz_get_str(s,10,(mpz_ptr) a);
398  StringAppendS(z);
399  omFreeSize((ADDRESS)s,l);
400  }
401 }
402 
403 /*2
404 * extracts a long integer from s, returns the rest (COPY FROM longrat0.cc)
405 */
406 static const char * nlEatLongC(char *s, mpz_ptr i)
407 {
408  const char * start=s;
409 
410  if (*s<'0' || *s>'9')
411  {
412  mpz_set_si(i,1);
413  return s;
414  }
415  while (*s >= '0' && *s <= '9') s++;
416  if (*s=='\0')
417  {
418  mpz_set_str(i,start,10);
419  }
420  else
421  {
422  char c=*s;
423  *s='\0';
424  mpz_set_str(i,start,10);
425  *s=c;
426  }
427  return s;
428 }
429 
430 
431 static CanonicalForm nrzConvSingNFactoryN(number n, BOOLEAN setChar, const coeffs /*r*/)
432 {
433  if (setChar) setCharacteristic( 0 );
434 
436  mpz_t num;
437  mpz_init_set(num, *((mpz_t*)n));
438  term = make_cf(num);
439  return term;
440 }
441 
442 static number nrzConvFactoryNSingN(const CanonicalForm n, const coeffs r)
443 {
444  if (n.isImm())
445  return nrzInit(n.intval(),r);
446  else
447  {
448  mpz_ptr m = (mpz_ptr) omAllocBin(gmp_nrz_bin);
449  gmp_numerator(n,m);
450  return (number) m;
451  }
452 }
453 
454 const char * nrzRead (const char *s, number *a, const coeffs)
455 {
456  mpz_ptr z = (mpz_ptr) omAllocBin(gmp_nrz_bin);
457  {
458  mpz_init(z);
459  s = nlEatLongC((char *) s, z);
460  }
461  *a = (number) z;
462  return s;
463 }
464 
465 void nrzCoeffWrite (const coeffs, BOOLEAN /*details*/)
466 {
467  PrintS("// coeff. ring is : Integers\n");
468 }
469 
470 static char* nrzCoeffString(const coeffs)
471 {
472  return omStrDup("integer");
473 }
474 
475 coeffs nrzQuot1(number c, const coeffs r)
476 {
477  long ch = r->cfInt(c, r);
478  mpz_ptr dummy;
479  dummy = (mpz_ptr) omAlloc(sizeof(mpz_t));
480  mpz_init_set_ui(dummy, ch);
481  ZnmInfo info;
482  info.base = dummy;
483  info.exp = (unsigned long) 1;
484  coeffs rr = nInitChar(n_Zn, (void*)&info);
485  return(rr);
486 }
487 
489 {
490  assume( getCoeffType(r) == ID );
491 
492  r->is_field=FALSE;
493  r->is_domain=TRUE;
494  r->rep=n_rep_gmp;
495 
496  //r->nCoeffIsEqual = ndCoeffIsEqual;
497  r->cfCoeffString = nrzCoeffString;
498  //r->cfKillChar = ndKillChar;
499  r->cfMult = nrzMult;
500  r->cfSub = nrzSub;
501  r->cfAdd = nrzAdd;
502  r->cfDiv = nrzDiv;
503  r->cfIntMod= nrzIntMod;
504  r->cfExactDiv= nrzExactDiv;
505  r->cfInit = nrzInit;
506  r->cfSize = nrzSize;
507  r->cfInt = nrzInt;
508  //#ifdef HAVE_RINGS
509  r->cfDivComp = nrzDivComp; // only for ring stuff
510  r->cfIsUnit = nrzIsUnit; // only for ring stuff
511  r->cfGetUnit = nrzGetUnit; // only for ring stuff
512  r->cfExtGcd = nrzExtGcd; // only for ring stuff
513  r->cfDivBy = nrzDivBy; // only for ring stuff
514  //#endif
515  r->cfInpNeg = nrzNeg;
516  r->cfInvers= nrzInvers;
517  r->cfCopy = nrzCopy;
518  r->cfWriteLong = nrzWrite;
519  r->cfRead = nrzRead;
520  r->cfGreater = nrzGreater;
521  r->cfEqual = nrzEqual;
522  r->cfIsZero = nrzIsZero;
523  r->cfIsOne = nrzIsOne;
524  r->cfIsMOne = nrzIsMOne;
525  r->cfGreaterZero = nrzGreaterZero;
526  r->cfPower = nrzPower;
527  r->cfGcd = nrzGcd;
528  r->cfLcm = nrzLcm;
529  r->cfDelete= nrzDelete;
530  r->cfSetMap = nrzSetMap;
531  r->cfCoeffWrite = nrzCoeffWrite;
532  r->cfQuot1 = nrzQuot1;
533  r->convSingNFactoryN=nrzConvSingNFactoryN;
534  r->convFactoryNSingN=nrzConvFactoryNSingN;
535  // debug stuff
536 
537 #ifdef LDEBUG
538  r->cfDBTest=nrzDBTest;
539 #endif
540 
541  r->nNULL = 0;
542  r->ch = 0;
543  r->has_simple_Alloc=FALSE;
544  r->has_simple_Inverse=FALSE;
545  return FALSE;
546 }
547 
548 #elif SI_INTEGER_VARIANT == 3
549 
550 //make sure that a small number is an immediate integer
551 //bascially coped from longrat.cc nlShort3
552 //TODO: is there any point in checking 0 first???
553 //TODO: it is not clear that this works in 32/64 bit everywhere.
554 // too many hacks.
555 #ifdef LDEBUG
556 #define nrzTest(A) nrzDBTest(A,__FILE__,__LINE__,NULL)
557 BOOLEAN nrzDBTest (number x, const char *f, const int l, const coeffs);
558 #else
559 #define nrzTest(A)
560 #endif
561 
562 #undef CF_DEBUG
563 static inline number nrz_short(number x)
564 {
565 #if CF_DEBUG
566  StringAppendS("short(");
567  nrzWrite(x, NULL);
568 #endif
569  if (mpz_cmp_ui((mpz_ptr) x,0L)==0)
570  {
571  mpz_clear((mpz_ptr)x);
573 #if CF_DEBUG
574  StringAppendS(")=0");
575 #endif
576  return INT_TO_SR(0);
577  }
578  if (mpz_size1((mpz_ptr)x)<=MP_SMALL)
579  {
580  long ui=mpz_get_si((mpz_ptr)x);
581  if ((((ui<<3)>>3)==ui)
582  && (mpz_cmp_si((mpz_ptr)x,ui)==0))
583  {
584  mpz_clear((mpz_ptr)x);
586 #if CF_DEBUG
587  StringAppendS(")=imm");
588 #endif
589  return INT_TO_SR(ui);
590  }
591  }
592 #if CF_DEBUG
593  StringAppendS(")");
594 #endif
595  return x;
596 }
597 
598 
599 int nrzSize(number a, const coeffs)
600 {
601  if (a == NULL) return 0;
602  if (a==INT_TO_SR(0)) return 0;
603  if (n_Z_IS_SMALL(a)) return 1;
604  return ((mpz_ptr)a)->_mp_alloc;
605 }
606 
607 
608 /*
609  * Multiply two numbers
610  * check for 0, 1, -1 maybe
611  */
612 #if CF_DEBUG
613 number _nrzMult(number, number, const coeffs);
614 number nrzMult(number a, number b, const coeffs R)
615 {
616  StringSetS("Mult: ");
617  nrzWrite(a, R);
618  StringAppendS(" by ");
619  nrzWrite(b, R);
620  number c = _nrzMult(a, b, R);
621  StringAppendS(" is ");
622  nrzWrite(c, R);
623  char * s = StringEndS();
624  Print("%s\n", s);
625  omFree(s);
626  return c;
627 }
628 number _nrzMult (number a, number b, const coeffs R)
629 #else
630 number nrzMult (number a, number b, const coeffs R)
631 #endif
632 {
633  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b)) {
634  //from longrat.cc
635  if (SR_TO_INT(a)==0)
636  return a;
637  if (SR_TO_INT(b)==0)
638  return b;
639  long r=(long)((unsigned long)(SR_HDL(a)-1L))*((unsigned long)(SR_HDL(b)>>1));
640  if ((r/(SR_HDL(b)>>1))==(SR_HDL(a)-1L))
641  {
642  number u=((number) ((r>>1)+SR_INT));
643  // if (((((long)SR_HDL(u))<<1)>>1)==SR_HDL(u)) return (u);
644  return nrzInit(SR_HDL(u)>>2, R);
645  }
646  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
647  mpz_init(erg);
648  mpz_set_si(erg, SR_TO_INT(a));
649  mpz_mul_si(erg, erg, SR_TO_INT(b));
650  nrzTest((number)erg);
651  return (number) erg;
652  }
653  else if (n_Z_IS_SMALL(a))
654  {
655  if (SR_TO_INT(a)==0)
656  return a;
657  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
658  mpz_init_set(erg, (mpz_ptr) b);
659  mpz_mul_si(erg, erg, SR_TO_INT(a));
660  nrzTest((number)erg);
661  return (number) erg;
662  }
663  else if (n_Z_IS_SMALL(b))
664  {
665  if (SR_TO_INT(b)==0)
666  return b;
667  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
668  mpz_init_set(erg, (mpz_ptr) a);
669  mpz_mul_si(erg, erg, SR_TO_INT(b));
670  nrzTest((number)erg);
671  return (number) erg;
672  }
673  else
674  {
675  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
676  mpz_init(erg);
677  mpz_mul(erg, (mpz_ptr) a, (mpz_ptr) b);
678  nrzTest((number)erg);
679  return (number) erg;
680  }
681 }
682 
683 
684 static long int_gcd(long a, long b)
685 {
686  long r;
687  a = ABS(a);
688  b = ABS(b);
689  if (!a) return b;
690  if (!b) return a;
691  do
692  {
693  r = a % b;
694  a = b;
695  b = r;
696  } while (b);
697  return ABS(a); // % in c doeas not imply a signn
698  // it would be unlikely to see a negative here
699  // but who knows
700 }
701 
702 /*
703  * Give the smallest non unit k, such that a * x = k = b * y has a solution
704  */
705 number nrzLcm (number a, number b, const coeffs R)
706 {
707  #ifdef CF_DEBUG
708  PrintS("nrzLcm\n");
709  #endif
710  mpz_ptr erg;
711  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
712  {
713  long g = int_gcd(SR_TO_INT(a), SR_TO_INT(b));
714  return nrzMult(a, INT_TO_SR(SR_TO_INT(b)/g), R);
715  }
716  else
717  {
718  erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
719  if (n_Z_IS_SMALL(a))
720  {
721  mpz_init_set(erg, (mpz_ptr) b);
722  unsigned long g = mpz_gcd_ui(NULL, erg, (unsigned long) ABS(SR_TO_INT(a)));
723  mpz_mul_si(erg, erg, SR_TO_INT(a)/g);
724  }
725  else if (n_Z_IS_SMALL(b))
726  {
727  mpz_init_set(erg, (mpz_ptr) a);
728  unsigned long g = mpz_gcd_ui(NULL, erg, (unsigned long) ABS(SR_TO_INT(b)));
729  mpz_mul_si(erg, erg, SR_TO_INT(b)/g);
730  }
731  else
732  {
733  mpz_init(erg);
734  mpz_lcm(erg, (mpz_ptr) a, (mpz_ptr) b);
735  }
736  }
737  return (number) erg;
738 }
739 
740 /*
741  * Give the largest non unit k, such that a = x * k, b = y * k has
742  * a solution.
743  */
744 number nrzGcd (number a,number b,const coeffs R)
745 {
746  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
747  {
748  long g = int_gcd(SR_TO_INT(a), SR_TO_INT(b));
749  return INT_TO_SR(g);
750  }
751  else if (n_Z_IS_SMALL(a))
752  {
753  if (a==INT_TO_SR(0))
754  return nrzCopy(b, R);
755  unsigned long g = mpz_gcd_ui(NULL, (mpz_ptr)b, (unsigned long) ABS(SR_TO_INT(a)));
756  return INT_TO_SR( g);
757  }
758  else if (n_Z_IS_SMALL(b))
759  {
760  if (b==INT_TO_SR(0))
761  return nrzCopy(a, R);
762  unsigned long g = mpz_gcd_ui(NULL, (mpz_ptr)a, (unsigned long) ABS(SR_TO_INT(b)));
763  return INT_TO_SR(g);
764  }
765  else
766  {
767  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
768  mpz_init(erg);
769  mpz_gcd(erg, (mpz_ptr) a, (mpz_ptr) b);
770  return (number) erg;
771  }
772 }
773 
774 /*
775  * Give the largest non unit k, such that a = x * k, b = y * k has
776  * a solution and r, s, s.t. k = s*a + t*b
777  */
778 static long int_extgcd(long a, long b, long * u, long* x, long * v, long* y)
779 {
780  long q, r;
781  if (!a)
782  {
783  *u = 0;
784  *v = 1;
785  *x = -1;
786  *y = 0;
787  return b;
788  }
789  if (!b)
790  {
791  *u = 1;
792  *v = 0;
793  *x = 0;
794  *y = 1;
795  return a;
796  }
797  *u=1;
798  *v=0;
799  *x=0;
800  *y=1;
801  do
802  {
803  q = a/b;
804  r = a%b;
805  assume (q*b+r == a);
806  a = b;
807  b = r;
808 
809  r = -(*v)*q+(*u);
810  (*u) =(*v);
811  (*v) = r;
812 
813  r = -(*y)*q+(*x);
814  (*x) = (*y);
815  (*y) = r;
816  } while (b);
817 
818  return a;
819 }
820 
821 number nrzExtGcd (number a, number b, number *s, number *t, const coeffs)
822 {
823  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
824  {
825  long u, v, x, y;
826  long g = int_extgcd(SR_TO_INT(a), SR_TO_INT(b), &u, &v, &x, &y);
827  *s = INT_TO_SR(u);
828  *t = INT_TO_SR(v);
829  return INT_TO_SR(g);
830  }
831  else
832  {
833  mpz_t aa, bb;
834  if (n_Z_IS_SMALL(a))
835  {
836  mpz_init_set_si(aa, SR_TO_INT(a));
837  }
838  else
839  {
840  mpz_init_set(aa, (mpz_ptr) a);
841  }
842  if (n_Z_IS_SMALL(b))
843  {
844  mpz_init_set_si(bb, SR_TO_INT(b));
845  }
846  else
847  {
848  mpz_init_set(bb, (mpz_ptr) b);
849  }
850  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
851  mpz_ptr bs = (mpz_ptr) omAllocBin(gmp_nrz_bin);
852  mpz_ptr bt = (mpz_ptr) omAllocBin(gmp_nrz_bin);
853  mpz_init(erg);
854  mpz_init(bs);
855  mpz_init(bt);
856  mpz_gcdext(erg, bs, bt, aa, bb);
857  *s = nrz_short((number) bs);
858  *t = nrz_short((number) bt);
859  mpz_clear(aa);
860  mpz_clear(bb);
861  return nrz_short((number) erg);
862  }
863 }
864 #if CF_DEBUG
865 number _nrzXExtGcd(number, number, number *, number *, number *, number *, const coeffs);
866 number nrzXExtGcd(number a, number b, number *x, number * y, number * u, number * v, const coeffs R)
867 {
868  char * s;
869  StringSetS("XExtGcd: ");
870  nrzWrite(a, R);
871  StringAppendS(" by ");
872  nrzWrite(b, R);
873  number c = _nrzXExtGcd(a, b, x, y, u, v, R);
874  StringAppendS(" is ");
875  nrzWrite(c, R);
876  StringAppendS("[[");
877  nrzWrite(*x, R);
878  StringAppendS(", ");
879  nrzWrite(*y, R);
880  StringAppendS("], ");
881  nrzWrite(*u, R);
882  StringAppendS(", ");
883  nrzWrite(*v, R);
884  s=StringEndS();
885  Print("%s]]\n", s);
886  omFree(s);
887  return c;
888 }
889 number _nrzXExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs )
890 #else
891 number nrzXExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs )
892 #endif
893 {
894  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
895  {
896  long uu, vv, x, y;
897  long g = int_extgcd(SR_TO_INT(a), SR_TO_INT(b), &uu, &vv, &x, &y);
898  *s = INT_TO_SR(uu);
899  *t = INT_TO_SR(vv);
900  *u = INT_TO_SR(x);
901  *v = INT_TO_SR(y);
902  return INT_TO_SR(g);
903  }
904  else
905  {
906  mpz_t aa, bb;
907  if (n_Z_IS_SMALL(a))
908  {
909  mpz_init_set_si(aa, SR_TO_INT(a));
910  }
911  else
912  {
913  mpz_init_set(aa, (mpz_ptr) a);
914  }
915  if (n_Z_IS_SMALL(b))
916  {
917  mpz_init_set_si(bb, SR_TO_INT(b));
918  }
919  else
920  {
921  mpz_init_set(bb, (mpz_ptr) b);
922  }
923  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
924  mpz_ptr bs = (mpz_ptr) omAllocBin(gmp_nrz_bin);
925  mpz_ptr bt = (mpz_ptr) omAllocBin(gmp_nrz_bin);
926  mpz_init(erg);
927  mpz_init(bs);
928  mpz_init(bt);
929 
930  mpz_gcdext(erg, bs, bt, aa, bb);
931 
932  mpz_ptr bu = (mpz_ptr) omAllocBin(gmp_nrz_bin);
933  mpz_ptr bv = (mpz_ptr) omAllocBin(gmp_nrz_bin);
934 
935  mpz_init_set(bu, (mpz_ptr) bb);
936  mpz_init_set(bv, (mpz_ptr) aa);
937 
938  mpz_clear(aa);
939  mpz_clear(bb);
940  assume(mpz_cmp_si(erg, 0));
941 
942  mpz_div(bu, bu, erg);
943  mpz_div(bv, bv, erg);
944 
945  mpz_mul_si(bu, bu, -1);
946  *u = nrz_short((number) bu);
947  *v = nrz_short((number) bv);
948 
949  *s = nrz_short((number) bs);
950  *t = nrz_short((number) bt);
951  return nrz_short((number) erg);
952  }
953 }
954 #if CF_DEBUG
955 number _nrzQuotRem(number, number, number *, const coeffs);
956 number nrzQuotRem(number a, number b, number * r, const coeffs R)
957 {
958  StringSetS("QuotRem: ");
959  nrzWrite(a, R);
960  StringAppendS(" by ");
961  nrzWrite(b, R);
962  number c = _nrzQuotRem(a, b, r, R);
963  StringAppendS(" is ");
964  nrzWrite(c, R);
965  if (r) {
966  StringAppendS("+R(");
967  nrzWrite(*r, R);
968  StringAppendS(")");
969  }
970  char * s = StringEndS();
971  Print("%s\n", s);
972  omFree(s);
973  return c;
974 }
975 number _nrzQuotRem (number a, number b, number * r, const coeffs )
976 #else
977 number nrzQuotRem (number a, number b, number * r, const coeffs )
978 #endif
979 {
980  assume(SR_TO_INT(b));
981  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
982  {
983  if (r)
984  *r = INT_TO_SR(SR_TO_INT(a) % SR_TO_INT(b));
985  return INT_TO_SR(SR_TO_INT(a)/SR_TO_INT(b));
986  }
987  else if (n_Z_IS_SMALL(a))
988  {
989  //a is small, b is not, so q=0, r=a
990  if (r)
991  *r = a;
992  return INT_TO_SR(0);
993  }
994  else if (n_Z_IS_SMALL(b))
995  {
996  unsigned long rr;
997  mpz_ptr qq = (mpz_ptr) omAllocBin(gmp_nrz_bin);
998  mpz_init(qq);
999  mpz_t rrr;
1000  mpz_init(rrr);
1001  rr = mpz_divmod_ui(qq, rrr, (mpz_ptr) a, (unsigned long)ABS(SR_TO_INT(b)));
1002  mpz_clear(rrr);
1003 
1004  if (r)
1005  *r = INT_TO_SR(rr);
1006  if (SR_TO_INT(b)<0)
1007  {
1008  mpz_mul_si(qq, qq, -1);
1009  }
1010  return nrz_short((number)qq);
1011  }
1012  mpz_ptr qq = (mpz_ptr) omAllocBin(gmp_nrz_bin),
1013  rr = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1014  mpz_init(qq);
1015  mpz_init(rr);
1016  mpz_divmod(qq, rr, (mpz_ptr)a, (mpz_ptr)b);
1017  if (r)
1018  *r = (number) rr;
1019  else
1020  {
1021  mpz_clear(rr);
1022  }
1023  nrzTest((number)qq);
1024  return (number) qq;
1025 }
1026 
1027 
1028 void nrzPower (number a, int i, number * result, const coeffs)
1029 {
1030  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1031  mpz_init(erg);
1032  mpz_t aa;
1033  if (n_Z_IS_SMALL(a))
1034  mpz_init_set_si(aa, SR_TO_INT(a));
1035  else
1036  mpz_init_set(aa, (mpz_ptr) a);
1037  mpz_pow_ui(erg, aa, i);
1038  *result = nrz_short((number) erg);
1039 }
1040 
1041 /*
1042  * create a number from int
1043  * TODO: do not create an mpz if not necessary
1044  */
1045 number nrzInit (long i, const coeffs)
1046 {
1047  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1048  mpz_init_set_si(erg, i);
1049  return nrz_short((number) erg);
1050 }
1051 
1052 void nrzDelete(number *a, const coeffs)
1053 {
1054  if (*a == NULL) return;
1055  if (n_Z_IS_SMALL(*a)==0)
1056  {
1057  mpz_clear((mpz_ptr) *a);
1058  omFreeBin((ADDRESS) *a, gmp_nrz_bin);
1059  }
1060  *a = NULL;
1061 }
1062 
1063 number nrzCopy(number a, const coeffs)
1064 {
1065  if (n_Z_IS_SMALL(a)) return a;
1066  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1067  mpz_init_set(erg, (mpz_ptr) a);
1068  return (number) erg;
1069 }
1070 
1071 /*
1072  * convert a number to int
1073  */
1074 long nrzInt(number &n, const coeffs)
1075 {
1076  if (n_Z_IS_SMALL(n)) return SR_TO_INT(n);
1077  return mpz_get_si( (mpz_ptr)n);
1078 }
1079 #if CF_DEBUG
1080 number _nrzAdd(number, number, const coeffs);
1081 number nrzAdd(number a, number b, const coeffs R)
1082 {
1083  StringSetS("Add: ");
1084  nrzWrite(a, R);
1085  StringAppendS(" to ");
1086  nrzWrite(b, R);
1087  number c = _nrzAdd(a, b, R);
1088  StringAppendS(" is ");
1089  nrzWrite(c, R);
1090  char * s = StringEndS();
1091  Print("%s\n", s);
1092  omFree(s);
1093  return c;
1094 }
1095 number _nrzAdd (number a, number b, const coeffs )
1096 #else
1097 number nrzAdd (number a, number b, const coeffs )
1098 #endif
1099 {
1100  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
1101  {
1102  long c = SR_TO_INT(a) + SR_TO_INT(b);
1103  if (INT_IS_SMALL(c))
1104  return INT_TO_SR(c);
1105  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1106  mpz_init_set_si(erg, c);
1107 
1108  nrzTest((number)erg);
1109  return (number) erg;
1110  }
1111  else if (n_Z_IS_SMALL(a))
1112  {
1113  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1114  mpz_init(erg);
1115  if (SR_TO_INT(a)>0)
1116  mpz_add_ui(erg, (mpz_ptr) b, (unsigned long)SR_TO_INT(a));
1117  else
1118  mpz_sub_ui(erg, (mpz_ptr) b, (unsigned long)-(SR_TO_INT(a)));
1119  return nrz_short((number) erg);
1120  }
1121  else if (n_Z_IS_SMALL(b))
1122  {
1123  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1124  mpz_init(erg);
1125  if (SR_TO_INT(b)>0)
1126  mpz_add_ui(erg, (mpz_ptr) a, (unsigned long)SR_TO_INT(b));
1127  else
1128  mpz_sub_ui(erg, (mpz_ptr) a, (unsigned long)-(SR_TO_INT(b)));
1129  return nrz_short((number) erg);
1130  }
1131  else
1132  {
1133  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1134  mpz_init(erg);
1135  mpz_add(erg, (mpz_ptr) a, (mpz_ptr) b);
1136  return nrz_short((number) erg);
1137  }
1138 }
1139 
1140 number nrzSub (number a, number b, const coeffs )
1141 {
1142  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
1143  {
1144  long c = SR_TO_INT(a) - SR_TO_INT(b);
1145  if (INT_IS_SMALL(c))
1146  return INT_TO_SR(c);
1147  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1148  mpz_init_set_si(erg, c);
1149  nrzTest((number)erg);
1150  return (number) erg;
1151  }
1152  else if (n_Z_IS_SMALL(a))
1153  {
1154  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1155  mpz_init(erg);
1156 
1157  if (SR_TO_INT(a)>0)
1158  mpz_ui_sub(erg, (unsigned long)SR_TO_INT(a), (mpz_ptr) b);
1159  else
1160  {
1161  mpz_add_ui(erg, (mpz_ptr) b, (unsigned long)-SR_TO_INT(a));
1162  mpz_neg(erg, erg);
1163  }
1164  return nrz_short((number) erg);
1165  }
1166  else if (n_Z_IS_SMALL(b))
1167  {
1168  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1169  mpz_init(erg);
1170  if (SR_TO_INT(b)>0)
1171  mpz_sub_ui(erg, (mpz_ptr) a, (unsigned long)SR_TO_INT(b));
1172  else
1173  mpz_add_ui(erg, (mpz_ptr) a, (unsigned long)-SR_TO_INT(b));
1174  return nrz_short((number) erg);
1175  }
1176  else
1177  {
1178  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1179  mpz_init(erg);
1180  mpz_sub(erg, (mpz_ptr) a, (mpz_ptr) b);
1181  return nrz_short((number) erg);
1182  }
1183 }
1184 
1185 number nrzGetUnit (number n, const coeffs r)
1186 {
1187  if (nrzGreaterZero(n, r))
1188  return INT_TO_SR(1);
1189  else
1190  return INT_TO_SR(-1);
1191 }
1192 
1193 number nrzAnn(number n, const coeffs)
1194 {
1195  if (SR_TO_INT(n)) // in Z: the annihilator of !=0 is 0
1196  return INT_TO_SR(0);
1197  else
1198  return INT_TO_SR(1);
1199 }
1200 
1201 BOOLEAN nrzIsUnit (number a, const coeffs)
1202 {
1203  return ABS(SR_TO_INT(a))==1;
1204 }
1205 
1206 BOOLEAN nrzIsZero (number a, const coeffs)
1207 {
1208  return (a==NULL) || (a==INT_TO_SR(0));
1209 }
1210 
1211 BOOLEAN nrzIsOne (number a, const coeffs)
1212 {
1213  return a==INT_TO_SR(1);
1214 }
1215 
1216 BOOLEAN nrzIsMOne (number a, const coeffs)
1217 {
1218  return a==INT_TO_SR(-1);
1219 }
1220 
1221 BOOLEAN nrzEqual (number a,number b, const coeffs)
1222 {
1223  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
1224  return a==b;
1225  else if (n_Z_IS_SMALL(a) || n_Z_IS_SMALL(b))
1226  return FALSE;
1227  else
1228  return 0 == mpz_cmp((mpz_ptr) a, (mpz_ptr) b);
1229 }
1230 
1231 BOOLEAN nrzGreater (number a,number b, const coeffs)
1232 {
1233  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
1234  return ((long)a)>((long)b);
1235  else if (n_Z_IS_SMALL(a))
1236  return 0 > mpz_cmp_si((mpz_ptr)b,SR_TO_INT(a));
1237  else if (n_Z_IS_SMALL(b))
1238  return 0 < mpz_cmp_si((mpz_ptr)a,SR_TO_INT(b));
1239  return 0 < mpz_cmp((mpz_ptr) a, (mpz_ptr) b);
1240 }
1241 
1242 BOOLEAN nrzGreaterZero (number k, const coeffs C)
1243 {
1244  return nrzGreater(k, INT_TO_SR(0), C);
1245 }
1246 
1247 int nrzDivComp(number a, number b, const coeffs r)
1248 {
1249  if (nrzDivBy(a, b, r))
1250  {
1251  if (nrzDivBy(b, a, r)) return 2;
1252  return -1;
1253  }
1254  if (nrzDivBy(b, a, r)) return 1;
1255  return 0;
1256 }
1257 
1258 BOOLEAN nrzDivBy (number a,number b, const coeffs)
1259 {
1260  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
1261  {
1262  return SR_TO_INT(a) %SR_TO_INT(b) ==0;
1263  }
1264  else if (n_Z_IS_SMALL(a))
1265  {
1266  return a==INT_TO_SR(0);
1267  }
1268  else if (n_Z_IS_SMALL(b))
1269  {
1270  return mpz_divisible_ui_p((mpz_ptr)a, (unsigned long)ABS(SR_TO_INT(b))) != 0;
1271  }
1272  else
1273  return mpz_divisible_p((mpz_ptr) a, (mpz_ptr) b) != 0;
1274 }
1275 
1276 number nrzDiv (number a,number b, const coeffs)
1277 {
1278  assume(SR_TO_INT(b));
1279  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
1280  {
1281  //if (SR_TO_INT(a) % SR_TO_INT(b))
1282  //{
1283  // WerrorS("1:Division by non divisible element.");
1284  // WerrorS("Result is without remainder.");
1285  //}
1286  return INT_TO_SR(SR_TO_INT(a)/SR_TO_INT(b));
1287  }
1288  else if (n_Z_IS_SMALL(a))
1289  {
1290  //if (SR_TO_INT(a))
1291  //{
1292  // WerrorS("2:Division by non divisible element.");
1293  // WerrorS("Result is without remainder.");
1294  //}
1295  return INT_TO_SR(0);
1296  }
1297  else if (n_Z_IS_SMALL(b))
1298  {
1299  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1300  mpz_t r;
1301  mpz_init(r);
1302  mpz_init(erg);
1303  if (mpz_divmod_ui(erg, r, (mpz_ptr) a, (unsigned long)ABS(SR_TO_INT(b)))) {
1304  // WerrorS("3:Division by non divisible element.");
1305  // WerrorS("Result is without remainder.");
1306  }
1307  mpz_clear(r);
1308  if (SR_TO_INT(b)<0)
1309  mpz_neg(erg, erg);
1310  return nrz_short((number) erg);
1311  }
1312  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1313  mpz_init(erg);
1314  mpz_t r;
1315  mpz_init(r);
1316  mpz_tdiv_qr(erg, r, (mpz_ptr) a, (mpz_ptr) b);
1317 #if CF_DEBUG
1318  StringSetS("division of");
1319  nrzWrite(a, R);
1320  StringAppendS(" by ");
1321  nrzWrite(b, R);
1322  StringAppendS(" is ");
1323  number du;
1324  nrzWrite(du = (number)erg, R);
1325  StringAppendS(" rest ");
1326  nrzWrite(du = (number)r, R);
1327  char * s = StringEndS();
1328  Print("%s\n", s);
1329  omFree(s);
1330 #endif
1331 
1332  if (mpz_cmp_si(r, 0)!=0)
1333  {
1334  //WerrorS("4:Division by non divisible element.");
1335  //WerrorS("Result is without remainder.");
1336  }
1337  mpz_clear(r);
1338  return nrz_short((number) erg);
1339 }
1340 
1341 number nrzExactDiv (number a,number b, const coeffs)
1342 {
1343  assume(SR_TO_INT(b));
1344  mpz_t aa, bb;
1345  if (n_Z_IS_SMALL(a))
1346  mpz_init_set_si(aa, SR_TO_INT(a));
1347  else
1348  mpz_init_set(aa, (mpz_ptr) a);
1349  if (n_Z_IS_SMALL(b))
1350  mpz_init_set_si(bb, SR_TO_INT(b));
1351  else
1352  mpz_init_set(bb, (mpz_ptr) b);
1353  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1354  mpz_init(erg);
1355  mpz_tdiv_q(erg, (mpz_ptr) aa, (mpz_ptr) bb);
1356  mpz_clear(aa);
1357  mpz_clear(bb);
1358  nrzTest((number)erg);
1359  return (number) erg;
1360 }
1361 
1362 number nrzIntMod (number a,number b, const coeffs)
1363 {
1364  mpz_t aa, bb;
1365  assume(SR_TO_INT(b));
1366  if (n_Z_IS_SMALL(a))
1367  mpz_init_set_si(aa, SR_TO_INT(a));
1368  else
1369  mpz_init_set(aa, (mpz_ptr) a);
1370  if (n_Z_IS_SMALL(b))
1371  mpz_init_set_si(bb, SR_TO_INT(b));
1372  else
1373  mpz_init_set(bb, (mpz_ptr) b);
1374 
1375  mpz_t erg;
1376  mpz_init(erg);
1377  mpz_ptr r = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1378  mpz_init(r);
1379  mpz_tdiv_qr(erg, r, (mpz_ptr) aa, (mpz_ptr) bb);
1380  mpz_clear(erg);
1381  mpz_clear(aa);
1382  mpz_clear(bb);
1383 
1384  return nrz_short((number) r);
1385 }
1386 
1387 number nrzInvers (number c, const coeffs r)
1388 {
1389  if (!nrzIsUnit((number) c, r))
1390  {
1391  WerrorS("Non invertible element.");
1392  return (number)0; //TODO
1393  }
1394  return c; // has to be 1 or -1....
1395 }
1396 
1397 number nrzNeg (number c, const coeffs)
1398 {
1399 // nNeg inplace !!!
1400  if (n_Z_IS_SMALL(c))
1401  return INT_TO_SR(-SR_TO_INT(c));
1402  mpz_mul_si((mpz_ptr) c, (mpz_ptr) c, -1);
1403  return c;
1404 }
1405 
1406 static number nrzFarey(number r, number N, const coeffs R)
1407 {
1408  number a0 = nrzCopy(N, R);
1409  number b0 = nrzInit(0, R);
1410  number a1 = nrzCopy(r, R);
1411  number b1 = nrzInit(1, R);
1412  number two = nrzInit(2, R);
1413 #if 0
1414  Print("Farey start with ");
1415  n_Print(r, R);
1416  Print(" mod ");
1417  n_Print(N, R);
1418  Print("\n");
1419 #endif
1420  while (1)
1421  {
1422  number as = nrzMult(a1, a1, R);
1423  n_InpMult(as, two, R);
1424  if (nrzGreater(N, as, R))
1425  {
1426  nrzDelete(&as, R);
1427  break;
1428  }
1429  nrzDelete(&as, R);
1430  number q = nrzDiv(a0, a1, R);
1431  number t = nrzMult(a1, q, R),
1432  s = nrzSub(a0, t, R);
1433  nrzDelete(&a0, R);
1434  a0 = a1;
1435  a1 = s;
1436  nrzDelete(&t, R);
1437 
1438  t = nrzMult(b1, q, R);
1439  s = nrzSub(b0, t, R);
1440  nrzDelete(&b0, R);
1441  b0 = b1;
1442  b1 = s;
1443  nrzDelete(&t, R);
1444  nrzDelete(&q, R);
1445  }
1446  number as = nrzMult(b1, b1, R);
1447  n_InpMult(as, two, R);
1448  nrzDelete(&two, R);
1449  if (nrzGreater(as, N, R))
1450  {
1451  nrzDelete(&a0, R);
1452  nrzDelete(&a1, R);
1453  nrzDelete(&b0, R);
1454  nrzDelete(&b1, R);
1455  nrzDelete(&as, R);
1456  return NULL;
1457  }
1458  nrzDelete(&as, R);
1459  nrzDelete(&a0, R);
1460  nrzDelete(&b0, R);
1461 
1462  number a, b, ab;
1463  coeffs Q = nInitChar(n_Q, 0);
1464  nMapFunc f = n_SetMap(R, Q);
1465  a = f(a1, R, Q);
1466  b = f(b1, R, Q);
1467  ab = n_Div(a, b, Q);
1468  n_Delete(&a, Q);
1469  n_Delete(&b, Q);
1470  nKillChar(Q);
1471 
1472  nrzDelete(&a1, R);
1473  nrzDelete(&b1, R);
1474  return ab;
1475 }
1476 
1477 number nrzMapMachineInt(number from, const coeffs /*src*/, const coeffs /*dst*/)
1478 {
1479  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1480  mpz_init_set_ui(erg, (unsigned long) from);
1481  return nrz_short((number) erg);
1482 }
1483 
1484 number nrzMapZp(number from, const coeffs /*src*/, const coeffs /*dst*/)
1485 {
1486  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1487  mpz_init_set_si(erg, (long) from);
1488  return nrz_short((number) erg);
1489 }
1490 
1491 number nrzModNMap(number from, const coeffs /* src */, const coeffs /*dst*/)
1492 {
1493  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1494  mpz_init_set(erg, (mpz_ptr) from);
1495  return nrz_short((number) erg);
1496 }
1497 
1498 number nrzMapQ(number from, const coeffs /* src */, const coeffs dst)
1499 {
1500  if (SR_HDL(from) & SR_INT)
1501  return nrzInit(SR_TO_INT(from),dst);
1502  if (from->s!=3)
1503  {
1504  WerrorS("rational in map to integer");
1505  return NULL;
1506  }
1507  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1508  mpz_init_set(erg, from->z);
1509  return nrz_short((number) erg);
1510 }
1511 
1512 nMapFunc nrzSetMap(const coeffs src, const coeffs /*dst*/)
1513 {
1514  /* dst = rintegers */
1515  if (src->rep==n_rep_gmp) //nCoeff_is_Ring_ModN(src) || nCoeff_is_Ring_PtoM(src))
1516  return nrzModNMap;
1517 
1518  if ((src->rep==n_rep_gap_gmp) && nCoeff_is_Ring_Z(src))
1519  {
1520  return ndCopyMap; //nrzCopyMap;
1521  }
1522  if (src->rep==n_rep_gap_rat) /*&& nCoeff_is_Ring_Z(src)) Q, bigint*/
1523  {
1524  return nrzMapQ;
1525  }
1526  if ((src->rep==n_rep_int) && nCoeff_is_Ring_2toM(src))
1527  {
1528  return nrzMapMachineInt;
1529  }
1530  if ((src->rep==n_rep_int) && nCoeff_is_Zp(src))
1531  {
1532  return nrzMapZp;
1533  }
1534  return NULL; // default
1535 }
1536 
1537 
1538 /*
1539  * set the exponent (allocate and init tables) (TODO)
1540  */
1541 
1542 void nrzSetExp(int, coeffs)
1543 {
1544 }
1545 
1546 void nrzInitExp(int, coeffs)
1547 {
1548 }
1549 
1550 #ifdef LDEBUG
1551 BOOLEAN nrzDBTest (number x, const char *f, const int l, const coeffs)
1552 {
1553  if (SR_HDL(x) & SR_INT) return TRUE;
1554  if (mpz_cmp_ui((mpz_ptr) x,0L)==0)
1555  {
1556  Print("gmp-0 %s:%d\n",f,l);
1557  return FALSE;
1558  }
1559  if (mpz_size1((mpz_ptr)x)<=MP_SMALL)
1560  {
1561  long ui=mpz_get_si((mpz_ptr)x);
1562  if ((((ui<<3)>>3)==ui)
1563  && (mpz_cmp_si((mpz_ptr)x,ui)==0))
1564  {
1565  Print("gmp-small %s:%d\n",f,l);
1566  return FALSE;
1567  }
1568  }
1569  return TRUE;
1570 }
1571 #endif
1572 
1573 void nrzWrite (number a, const coeffs)
1574 {
1575  char *s,*z;
1576  if (a==NULL)
1577  {
1578  StringAppendS("o");
1579  }
1580  else
1581  {
1582  if (n_Z_IS_SMALL(a))
1583  {
1584  StringAppend("%d", SR_TO_INT(a));
1585  }
1586  else
1587  {
1588  int l=mpz_sizeinbase((mpz_ptr) a, 10) + 2;
1589  s=(char*)omAlloc(l);
1590  z=mpz_get_str(s,10,(mpz_ptr) a);
1591  StringAppendS(z);
1592  omFreeSize((ADDRESS)s,l);
1593  }
1594  }
1595 }
1596 
1597 /*2
1598 * extracts a long integer from s, returns the rest (COPY FROM longrat0.cc)
1599 */
1600 static const char * nlEatLongC(char *s, mpz_ptr i)
1601 {
1602  const char * start=s;
1603 
1604  if (*s<'0' || *s>'9')
1605  {
1606  mpz_set_si(i,1);
1607  return s;
1608  }
1609  while (*s >= '0' && *s <= '9') s++;
1610  if (*s=='\0')
1611  {
1612  mpz_set_str(i,start,10);
1613  }
1614  else
1615  {
1616  char c=*s;
1617  *s='\0';
1618  mpz_set_str(i,start,10);
1619  *s=c;
1620  }
1621  return s;
1622 }
1623 
1624 const char * nrzRead (const char *s, number *a, const coeffs)
1625 {
1626  mpz_ptr z = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1627  {
1628  mpz_init(z);
1629  s = nlEatLongC((char *) s, z);
1630  }
1631  *a = nrz_short((number) z);
1632  return s;
1633 }
1634 
1635 void nrzCoeffWrite (const coeffs, BOOLEAN /*details*/)
1636 {
1637  //PrintS("// ZZ\n");
1638  PrintS("// coeff. ring is : Integers\n");
1639 }
1640 
1641 static char* nrzCoeffString(const coeffs)
1642 {
1643  return omStrDup("integer");
1644 }
1645 
1646 static CanonicalForm nrzConvSingNFactoryN( number n, BOOLEAN setChar, const coeffs /*r*/ )
1647 {
1648  if (setChar) setCharacteristic( 0 );
1649 
1651  if ( n_Z_IS_SMALL(n))
1652  {
1653  term = SR_TO_INT(n);
1654  }
1655  else
1656  {
1657  mpz_t dummy;
1658  mpz_init_set( dummy,n->z );
1659  term = make_cf( dummy );
1660  }
1661  return term;
1662 }
1663 
1664 static number nrzConvFactoryNSingN( const CanonicalForm n, const coeffs r)
1665 {
1666  if (n.isImm())
1667  {
1668  return nrzInit(n.intval(),r);
1669  }
1670  else
1671  {
1672  if ( !n.den().isOne() )
1673  {
1674  WerrorS("rational in conversion to integer");
1675  return NULL;
1676  }
1677  mpz_ptr z = (mpz_ptr) omAlloc0Bin(gmp_nrz_bin);
1678  gmp_numerator( n,z);
1679  return nrz_short((number)z);
1680  }
1681 }
1682 
1683 static void nrzMPZ(mpz_t res, number &a, const coeffs)
1684 {
1685  if (n_Z_IS_SMALL(a))
1686  mpz_init_set_si(res, SR_TO_INT(a));
1687  else
1688  mpz_init_set(res, (mpz_ptr) a);
1689 }
1690 
1691 coeffs nrzQuot1(number c, const coeffs r)
1692 {
1693  mpz_ptr dummy;
1694  dummy = (mpz_ptr) omAlloc(sizeof(mpz_t));
1695  if(n_Z_IS_SMALL(c))
1696  {
1697  long ch = r->cfInt(c, r);
1698  mpz_init_set_ui(dummy, ch);
1699  }
1700  else
1701  {
1702  mpz_init_set(dummy, (mpz_ptr)c);
1703  }
1704  ZnmInfo info;
1705  info.base = dummy;
1706  info.exp = (unsigned long) 1;
1707  coeffs rr = nInitChar(n_Zn, (void*)&info);
1708  return(rr);
1709 }
1710 
1711 BOOLEAN nrzInitChar(coeffs r, void *)
1712 {
1713  assume( getCoeffType(r) == ID );
1714 
1715  r->is_field=FALSE;
1716  r->is_domain=TRUE;
1717  r->rep=n_rep_gap_gmp;
1718 
1719  //r->nCoeffIsEqual = ndCoeffIsEqual;
1720  r->cfCoeffString = nrzCoeffString;
1721  //r->cfKillChar = ndKillChar;
1722  r->cfMult = nrzMult;
1723  r->cfSub = nrzSub;
1724  r->cfAdd = nrzAdd;
1725  r->cfDiv = nrzDiv;
1726  r->cfIntMod= nrzIntMod;
1727  r->cfExactDiv= nrzExactDiv;
1728  r->cfInit = nrzInit;
1729  r->cfSize = nrzSize;
1730  r->cfInt = nrzInt;
1731  //#ifdef HAVE_RINGS
1732  r->cfDivComp = nrzDivComp; // only for ring stuff
1733  r->cfIsUnit = nrzIsUnit; // only for ring stuff
1734  r->cfGetUnit = nrzGetUnit; // only for ring stuff
1735  r->cfAnn = nrzAnn;
1736  r->cfExtGcd = nrzExtGcd; // only for ring stuff
1737  r->cfXExtGcd = nrzXExtGcd; // only for ring stuff
1738  r->cfQuotRem = nrzQuotRem;
1739  r->cfDivBy = nrzDivBy; // only for ring stuff
1740  //#endif
1741  r->cfInpNeg = nrzNeg;
1742  r->cfInvers= nrzInvers;
1743  r->cfCopy = nrzCopy;
1744  r->cfWriteLong = nrzWrite;
1745  r->cfRead = nrzRead;
1746  r->cfGreater = nrzGreater;
1747  r->cfEqual = nrzEqual;
1748  r->cfIsZero = nrzIsZero;
1749  r->cfIsOne = nrzIsOne;
1750  r->cfIsMOne = nrzIsMOne;
1751  r->cfGreaterZero = nrzGreaterZero;
1752  r->cfPower = nrzPower;
1753  r->cfGcd = nrzGcd;
1754  r->cfLcm = nrzLcm;
1755  r->cfDelete= nrzDelete;
1756  r->cfSetMap = nrzSetMap;
1757  r->cfCoeffWrite = nrzCoeffWrite;
1758  r->convSingNFactoryN = nrzConvSingNFactoryN;
1759  r->convFactoryNSingN = nrzConvFactoryNSingN;
1760  r->cfMPZ = nrzMPZ;
1761  r->cfFarey = nrzFarey;
1762 
1763  r->cfQuot1 = nrzQuot1;
1764  // debug stuff
1765 
1766 #ifdef LDEBUG
1767  r->cfDBTest=nrzDBTest;
1768 #endif
1769 
1770  r->nNULL = 0;
1771  r->ch = 0;
1772  r->has_simple_Alloc=FALSE;
1773  r->has_simple_Inverse=FALSE;
1774  return FALSE;
1775 }
1776 
1777 #elif SI_INTEGER_VARIANT == 1
1778 BOOLEAN nrzInitChar(coeffs r, void *)
1779 {
1780  return nlInitChar(r,(void*)1);
1781 }
1782 #else
1783 #error set SI_INTEGER_VARIANT
1784 #endif
1785 #endif
mpz_ptr base
Definition: rmodulon.h:18
void gmp_numerator(const CanonicalForm &f, mpz_ptr result)
Definition: singext.cc:20
mpz_t z
Definition: longrat.h:48
void nrzInitExp(int c, coeffs r)
Definition: rintegers.cc:375
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
static char * nrzCoeffString(const coeffs)
Definition: rintegers.cc:470
const CanonicalForm int s
Definition: facAbsFact.cc:55
char * nrzName(number n, const coeffs r)
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_ModN(const coeffs r)
Definition: coeffs.h:749
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
void mpz_mul_si(mpz_ptr r, mpz_srcptr s, long int si)
Definition: longrat.cc:179
#define INT_TO_SR(INT)
Definition: longrat.h:66
const poly a
Definition: syzextra.cc:212
omBin_t * omBin
Definition: omStructs.h:12
#define Print
Definition: emacs.cc:83
omBin gmp_nrz_bin
Definition: rintegers.cc:80
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:43
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:823
static int int_extgcd(int a, int b, int *u, int *x, int *v, int *y)
Definition: longrat.cc:1263
number nrzGetUnit(number a, const coeffs r)
Definition: rintegers.cc:206
number nrzIntMod(number a, number b, const coeffs r)
Definition: rintegers.cc:287
CanonicalForm num(const CanonicalForm &f)
Definition: int_poly.h:36
void nrzDelete(number *a, const coeffs r)
Definition: rintegers.cc:153
#define FALSE
Definition: auxiliary.h:140
static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
multiplication of &#39;a&#39; and &#39;b&#39;; replacement of &#39;a&#39; by the product a*b
Definition: coeffs.h:642
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
Definition: numbers.cc:239
int nrzDivComp(number a, number b, const coeffs r)
Definition: rintegers.cc:246
number nrzMult(number a, number b, const coeffs r)
Definition: rintegers.cc:86
number nrzLcm(number a, number b, const coeffs r)
Definition: rintegers.cc:97
rational (GMP) numbers
Definition: coeffs.h:31
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_Z(const coeffs r)
Definition: coeffs.h:755
void nrzSetExp(int c, coeffs r)
Definition: rintegers.cc:371
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition: coeffs.h:746
(), see rinteger.h, new impl.
Definition: coeffs.h:111
BOOLEAN nrzEqual(number a, number b, const coeffs r)
Definition: rintegers.cc:231
factory&#39;s main class
Definition: canonicalform.h:75
#define TRUE
Definition: auxiliary.h:144
nMapFunc nrzSetMap(const coeffs src, const coeffs dst)
Definition: rintegers.cc:338
void * ADDRESS
Definition: auxiliary.h:161
number nrzMapQ(number from, const coeffs src, const coeffs dst)
Definition: rintegers.cc:330
BOOLEAN nrzDivBy(number a, number b, const coeffs r)
Definition: rintegers.cc:257
g
Definition: cfModGcd.cc:4031
void WerrorS(const char *s)
Definition: feFopen.cc:24
int k
Definition: cfEzgcd.cc:93
char * StringEndS()
Definition: reporter.cc:151
void nlGMP(number &i, number n, const coeffs r)
Definition: longrat.cc:1467
#define Q
Definition: sirandom.c:25
BOOLEAN nlInitChar(coeffs r, void *p)
Definition: longrat.cc:3301
long intval() const
conversion functions
#define omAlloc(size)
Definition: omAllocDecl.h:210
void setCharacteristic(int c)
Definition: cf_char.cc:23
number nrzDiv(number a, number b, const coeffs r)
Definition: rintegers.cc:262
BOOLEAN nrzGreaterZero(number k, const coeffs r)
Definition: rintegers.cc:241
BOOLEAN nrzGreater(number a, number b, const coeffs r)
Definition: rintegers.cc:236
CF_NO_INLINE bool isOne() const
CF_INLINE bool CanonicalForm::isOne, isZero () const.
Definition: cf_inline.cc:354
CanonicalForm make_cf(const mpz_ptr n)
Definition: singext.cc:67
poly res
Definition: myNF.cc:322
void nrzPower(number a, int i, number *result, const coeffs r)
Definition: rintegers.cc:135
const char * nrzRead(const char *s, number *a, const coeffs r)
Definition: rintegers.cc:454
#define MP_SMALL
Definition: longrat.cc:157
mpz_t n
Definition: longrat.h:49
number nrzCopy(number a, const coeffs r)
Definition: rintegers.cc:161
const ring r
Definition: syzextra.cc:208
number nrzNeg(number c, const coeffs r)
Definition: rintegers.cc:309
Coefficient rings, fields and other domains suitable for Singular polynomials.
int nrzSize(number a, const coeffs r)
Definition: rintegers.cc:176
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
void nrzWrite(number a, const coeffs r)
Definition: rintegers.cc:386
number nrzMapZp(number from, const coeffs, const coeffs)
Definition: rintegers.cc:323
BOOLEAN nrzIsOne(number a, const coeffs r)
Definition: rintegers.cc:221
#define omFree(addr)
Definition: omAllocDecl.h:261
number nrzGcd(number a, number b, const coeffs r)
Definition: rintegers.cc:109
#define assume(x)
Definition: mod2.h:405
The main handler for Singular numbers which are suitable for Singular polynomials.
BOOLEAN nrzInitChar(coeffs r, void *)
Definition: rintegers.cc:488
number nrzInvers(number c, const coeffs r)
Definition: rintegers.cc:299
void StringSetS(const char *st)
Definition: reporter.cc:128
void StringAppendS(const char *st)
Definition: reporter.cc:107
const ExtensionInfo & info
< [in] sqrfree poly
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:72
number nrzExtGcd(number a, number b, number *s, number *t, const coeffs r)
Definition: rintegers.cc:121
const ring R
Definition: DebugPrint.cc:36
number nrzSub(number a, number b, const coeffs r)
Definition: rintegers.cc:198
static CanonicalForm nrzConvSingNFactoryN(number n, BOOLEAN setChar, const coeffs)
Definition: rintegers.cc:431
All the auxiliary stuff.
coeffs nrzQuot1(number c, const coeffs r)
Definition: rintegers.cc:475
int m
Definition: cfEzgcd.cc:119
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:42
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
Definition: coeffs.h:752
unsigned long exp
Definition: rmodulon.h:18
#define StringAppend
Definition: emacs.cc:82
FILE * f
Definition: checklibs.c:7
CanonicalForm den() const
den() returns the denominator of CO if CO is a rational number, 1 (from the current domain!) otherwis...
int i
Definition: cfEzgcd.cc:123
void PrintS(const char *s)
Definition: reporter.cc:294
void nrzCoeffWrite(const coeffs r, BOOLEAN details)
Definition: rintegers.cc:465
(mpz_ptr), see rmodulon,h
Definition: coeffs.h:114
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition: coeffs.h:722
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
static const n_coeffType ID
Our Type!
Definition: rintegers.cc:32
#define SR_TO_INT(SR)
Definition: longrat.h:67
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
#define omGetSpecBin(size)
Definition: omBin.h:11
(number), see longrat.h
Definition: coeffs.h:110
bool isImm() const
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define mpz_size1(A)
Definition: si_gmp.h:12
n_coeffType
Definition: coeffs.h:27
number nrzMapMachineInt(number from, const coeffs, const coeffs)
Definition: rintegers.cc:316
#define NULL
Definition: omList.c:10
number nrzInit(long i, const coeffs r)
Definition: rintegers.cc:146
number nrzAdd(number a, number b, const coeffs r)
Definition: rintegers.cc:190
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:616
#define ABS(x)
Definition: auxiliary.h:157
#define SR_INT
Definition: longrat.h:65
number nrzExactDiv(number a, number b, const coeffs r)
Definition: rintegers.cc:279
Variable x
Definition: cfModGcd.cc:4023
BOOLEAN nrzIsMOne(number a, const coeffs r)
Definition: rintegers.cc:226
BOOLEAN nrzDBTest(number a, const char *f, const int l, const coeffs r)
Definition: rintegers.cc:380
(int), see modulop.h
Definition: coeffs.h:109
#define SR_HDL(A)
Definition: tgb.cc:35
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
BOOLEAN nrzIsUnit(number a, const coeffs r)
Definition: rintegers.cc:211
static number nrzConvFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: rintegers.cc:442
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
static const char * nlEatLongC(char *s, mpz_ptr i)
Definition: rintegers.cc:406
int BOOLEAN
Definition: auxiliary.h:131
const poly b
Definition: syzextra.cc:213
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:488
BOOLEAN nrzIsZero(number a, const coeffs r)
Definition: rintegers.cc:216
int l
Definition: cfEzgcd.cc:94
return result
Definition: facAbsBiFact.cc:76
long nrzInt(number &n, const coeffs r)
Definition: rintegers.cc:185
void n_Print(number &a, const coeffs r)
print a number (BEWARE of string buffers!) mostly for debugging
Definition: numbers.cc:561
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:327
#define omStrDup(s)
Definition: omAllocDecl.h:263