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 #define CF_DEBUG 0
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,(long)0)==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  int ui=mpz_get_si((mpz_ptr)x);
581  if ((((ui<<3)>>3)==ui)
582  && (mpz_cmp_si((mpz_ptr)x,(long)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 (n_Z_IS_SMALL(a)) return 1;
603  return ((mpz_ptr)a)->_mp_alloc;
604 }
605 
606 
607 /*
608  * Multiply two numbers
609  * check for 0, 1, -1 maybe
610  */
611 #if CF_DEBUG
612 number _nrzMult(number, number, const coeffs);
613 number nrzMult(number a, number b, const coeffs R)
614 {
615  StringSetS("Mult: ");
616  nrzWrite(a, R);
617  StringAppendS(" by ");
618  nrzWrite(b, R);
619  number c = _nrzMult(a, b, R);
620  StringAppendS(" is ");
621  nrzWrite(c, R);
622  char * s = StringEndS();
623  Print("%s\n", s);
624  omFree(s);
625  return c;
626 }
627 number _nrzMult (number a, number b, const coeffs R)
628 #else
629 number nrzMult (number a, number b, const coeffs R)
630 #endif
631 {
632  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b)) {
633  //from longrat.cc
634  if (SR_TO_INT(a)==0)
635  return a;
636  if (SR_TO_INT(b)==0)
637  return b;
638  long r=(long)((unsigned long)(SR_HDL(a)-1L))*((unsigned long)(SR_HDL(b)>>1));
639  if ((r/(SR_HDL(b)>>1))==(SR_HDL(a)-1L))
640  {
641  number u=((number) ((r>>1)+SR_INT));
642  // if (((((long)SR_HDL(u))<<1)>>1)==SR_HDL(u)) return (u);
643  return nrzInit(SR_HDL(u)>>2, R);
644  }
645  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
646  mpz_init(erg);
647  mpz_set_si(erg, SR_TO_INT(a));
648  mpz_mul_si(erg, erg, SR_TO_INT(b));
649  nrzTest((number)erg);
650  return (number) erg;
651  }
652  else if (n_Z_IS_SMALL(a))
653  {
654  if (SR_TO_INT(a)==0)
655  return a;
656  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
657  mpz_init_set(erg, (mpz_ptr) b);
658  mpz_mul_si(erg, erg, SR_TO_INT(a));
659  nrzTest((number)erg);
660  return (number) erg;
661  }
662  else if (n_Z_IS_SMALL(b))
663  {
664  if (SR_TO_INT(b)==0)
665  return b;
666  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
667  mpz_init_set(erg, (mpz_ptr) a);
668  mpz_mul_si(erg, erg, SR_TO_INT(b));
669  nrzTest((number)erg);
670  return (number) erg;
671  }
672  else
673  {
674  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
675  mpz_init(erg);
676  mpz_mul(erg, (mpz_ptr) a, (mpz_ptr) b);
677  nrzTest((number)erg);
678  return (number) erg;
679  }
680 }
681 
682 
683 static int int_gcd(int a, int b)
684 {
685  int r;
686  a = ABS(a);
687  b = ABS(b);
688  if (!a) return b;
689  if (!b) return a;
690  do
691  {
692  r = a % b;
693  a = b;
694  b = r;
695  } while (b);
696  return ABS(a); // % in c doeas not imply a signn
697  // it would be unlikely to see a negative here
698  // but who knows
699 }
700 
701 /*
702  * Give the smallest non unit k, such that a * x = k = b * y has a solution
703  */
704 number nrzLcm (number a, number b, const coeffs R)
705 {
706  PrintS("nrzLcm\n");
707  mpz_ptr erg;
708  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
709  {
710  int g = int_gcd(SR_TO_INT(a), SR_TO_INT(b));
711  return nrzMult(a, INT_TO_SR(SR_TO_INT(b)/g), R);
712  }
713  else
714  {
715  erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
716  if (n_Z_IS_SMALL(a))
717  {
718  mpz_init_set(erg, (mpz_ptr) b);
719  unsigned long g = mpz_gcd_ui(NULL, erg, (unsigned long) ABS(SR_TO_INT(a)));
720  mpz_mul_si(erg, erg, SR_TO_INT(a)/g);
721  }
722  else if (n_Z_IS_SMALL(b))
723  {
724  mpz_init_set(erg, (mpz_ptr) a);
725  unsigned long g = mpz_gcd_ui(NULL, erg, (unsigned long) ABS(SR_TO_INT(b)));
726  mpz_mul_si(erg, erg, SR_TO_INT(b)/g);
727  }
728  else
729  {
730  mpz_init(erg);
731  mpz_lcm(erg, (mpz_ptr) a, (mpz_ptr) b);
732  }
733  }
734  return (number) erg;
735 }
736 
737 /*
738  * Give the largest non unit k, such that a = x * k, b = y * k has
739  * a solution.
740  */
741 number nrzGcd (number a,number b,const coeffs R)
742 {
743  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
744  {
745  int g = int_gcd(SR_TO_INT(a), SR_TO_INT(b));
746  return INT_TO_SR(g);
747  }
748  else if (n_Z_IS_SMALL(a))
749  {
750  if (a==INT_TO_SR(0))
751  return nrzCopy(b, R);
752  unsigned long g = mpz_gcd_ui(NULL, (mpz_ptr)b, (unsigned long) ABS(SR_TO_INT(a)));
753  return INT_TO_SR( g);
754  }
755  else if (n_Z_IS_SMALL(b))
756  {
757  if (b==INT_TO_SR(0))
758  return nrzCopy(a, R);
759  unsigned long g = mpz_gcd_ui(NULL, (mpz_ptr)a, (unsigned long) ABS(SR_TO_INT(b)));
760  return INT_TO_SR(g);
761  }
762  else
763  {
764  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
765  mpz_init(erg);
766  mpz_gcd(erg, (mpz_ptr) a, (mpz_ptr) b);
767  return (number) erg;
768  }
769 }
770 
771 /*
772  * Give the largest non unit k, such that a = x * k, b = y * k has
773  * a solution and r, s, s.t. k = s*a + t*b
774  */
775 static int int_extgcd(int a, int b, int * u, int* x, int * v, int* y)
776 {
777  int q, r;
778  if (!a)
779  {
780  *u = 0;
781  *v = 1;
782  *x = -1;
783  *y = 0;
784  return b;
785  }
786  if (!b)
787  {
788  *u = 1;
789  *v = 0;
790  *x = 0;
791  *y = 1;
792  return a;
793  }
794  *u=1;
795  *v=0;
796  *x=0;
797  *y=1;
798  do
799  {
800  q = a/b;
801  r = a%b;
802  assume (q*b+r == a);
803  a = b;
804  b = r;
805 
806  r = -(*v)*q+(*u);
807  (*u) =(*v);
808  (*v) = r;
809 
810  r = -(*y)*q+(*x);
811  (*x) = (*y);
812  (*y) = r;
813  } while (b);
814 
815  return a;
816 }
817 
818 number nrzExtGcd (number a, number b, number *s, number *t, const coeffs)
819 {
820  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
821  {
822  int u, v, x, y;
823  int g = int_extgcd(SR_TO_INT(a), SR_TO_INT(b), &u, &v, &x, &y);
824  *s = INT_TO_SR(u);
825  *t = INT_TO_SR(v);
826  return INT_TO_SR(g);
827  }
828  else
829  {
830  mpz_t aa, bb;
831  if (n_Z_IS_SMALL(a))
832  {
833  mpz_init_set_si(aa, SR_TO_INT(a));
834  }
835  else
836  {
837  mpz_init_set(aa, (mpz_ptr) a);
838  }
839  if (n_Z_IS_SMALL(b))
840  {
841  mpz_init_set_si(bb, SR_TO_INT(b));
842  }
843  else
844  {
845  mpz_init_set(bb, (mpz_ptr) b);
846  }
847  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
848  mpz_ptr bs = (mpz_ptr) omAllocBin(gmp_nrz_bin);
849  mpz_ptr bt = (mpz_ptr) omAllocBin(gmp_nrz_bin);
850  mpz_init(erg);
851  mpz_init(bs);
852  mpz_init(bt);
853  mpz_gcdext(erg, bs, bt, aa, bb);
854  *s = nrz_short((number) bs);
855  *t = nrz_short((number) bt);
856  mpz_clear(aa);
857  mpz_clear(bb);
858  return nrz_short((number) erg);
859  }
860 }
861 #if CF_DEBUG
862 number _nrzXExtGcd(number, number, number *, number *, number *, number *, const coeffs);
863 number nrzXExtGcd(number a, number b, number *x, number * y, number * u, number * v, const coeffs R)
864 {
865  char * s;
866  StringSetS("XExtGcd: ");
867  nrzWrite(a, R);
868  StringAppendS(" by ");
869  nrzWrite(b, R);
870  number c = _nrzXExtGcd(a, b, x, y, u, v, R);
871  StringAppendS(" is ");
872  nrzWrite(c, R);
873  StringAppendS("[[");
874  nrzWrite(*x, R);
875  StringAppendS(", ");
876  nrzWrite(*y, R);
877  StringAppendS("], ");
878  nrzWrite(*u, R);
879  StringAppendS(", ");
880  nrzWrite(*v, R);
881  s=StringEndS();
882  Print("%s]]\n", s);
883  omFree(s);
884  return c;
885 }
886 number _nrzXExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs )
887 #else
888 number nrzXExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs )
889 #endif
890 {
891  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
892  {
893  int uu, vv, x, y;
894  int g = int_extgcd(SR_TO_INT(a), SR_TO_INT(b), &uu, &vv, &x, &y);
895  *s = INT_TO_SR(uu);
896  *t = INT_TO_SR(vv);
897  *u = INT_TO_SR(x);
898  *v = INT_TO_SR(y);
899  return INT_TO_SR(g);
900  }
901  else
902  {
903  mpz_t aa, bb;
904  if (n_Z_IS_SMALL(a))
905  {
906  mpz_init_set_si(aa, SR_TO_INT(a));
907  }
908  else
909  {
910  mpz_init_set(aa, (mpz_ptr) a);
911  }
912  if (n_Z_IS_SMALL(b))
913  {
914  mpz_init_set_si(bb, SR_TO_INT(b));
915  }
916  else
917  {
918  mpz_init_set(bb, (mpz_ptr) b);
919  }
920  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
921  mpz_ptr bs = (mpz_ptr) omAllocBin(gmp_nrz_bin);
922  mpz_ptr bt = (mpz_ptr) omAllocBin(gmp_nrz_bin);
923  mpz_init(erg);
924  mpz_init(bs);
925  mpz_init(bt);
926 
927  mpz_gcdext(erg, bs, bt, aa, bb);
928 
929  mpz_ptr bu = (mpz_ptr) omAllocBin(gmp_nrz_bin);
930  mpz_ptr bv = (mpz_ptr) omAllocBin(gmp_nrz_bin);
931 
932  mpz_init_set(bu, (mpz_ptr) bb);
933  mpz_init_set(bv, (mpz_ptr) aa);
934 
935  mpz_clear(aa);
936  mpz_clear(bb);
937  assume(mpz_cmp_si(erg, 0));
938 
939  mpz_div(bu, bu, erg);
940  mpz_div(bv, bv, erg);
941 
942  mpz_mul_si(bu, bu, -1);
943  *u = nrz_short((number) bu);
944  *v = nrz_short((number) bv);
945 
946  *s = nrz_short((number) bs);
947  *t = nrz_short((number) bt);
948  return nrz_short((number) erg);
949  }
950 }
951 #if CF_DEBUG
952 number _nrzQuotRem(number, number, number *, const coeffs);
953 number nrzQuotRem(number a, number b, number * r, const coeffs R)
954 {
955  StringSetS("QuotRem: ");
956  nrzWrite(a, R);
957  StringAppendS(" by ");
958  nrzWrite(b, R);
959  number c = _nrzQuotRem(a, b, r, R);
960  StringAppendS(" is ");
961  nrzWrite(c, R);
962  if (r) {
963  StringAppendS("+R(");
964  nrzWrite(*r, R);
965  StringAppendS(")");
966  }
967  char * s = StringEndS();
968  Print("%s\n", s);
969  omFree(s);
970  return c;
971 }
972 number _nrzQuotRem (number a, number b, number * r, const coeffs )
973 #else
974 number nrzQuotRem (number a, number b, number * r, const coeffs )
975 #endif
976 {
977  assume(SR_TO_INT(b));
978  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
979  {
980  if (r)
981  *r = INT_TO_SR(SR_TO_INT(a) % SR_TO_INT(b));
982  return INT_TO_SR(SR_TO_INT(a)/SR_TO_INT(b));
983  }
984  else if (n_Z_IS_SMALL(a))
985  {
986  //a is small, b is not, so q=0, r=a
987  if (r)
988  *r = a;
989  return INT_TO_SR(0);
990  }
991  else if (n_Z_IS_SMALL(b))
992  {
993  unsigned long rr;
994  mpz_ptr qq = (mpz_ptr) omAllocBin(gmp_nrz_bin);
995  mpz_init(qq);
996  mpz_t rrr;
997  mpz_init(rrr);
998  rr = mpz_divmod_ui(qq, rrr, (mpz_ptr) a, (unsigned long)ABS(SR_TO_INT(b)));
999  mpz_clear(rrr);
1000 
1001  if (r)
1002  *r = INT_TO_SR(rr);
1003  if (SR_TO_INT(b)<0)
1004  {
1005  mpz_mul_si(qq, qq, -1);
1006  }
1007  return nrz_short((number)qq);
1008  }
1009  mpz_ptr qq = (mpz_ptr) omAllocBin(gmp_nrz_bin),
1010  rr = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1011  mpz_init(qq);
1012  mpz_init(rr);
1013  mpz_divmod(qq, rr, (mpz_ptr)a, (mpz_ptr)b);
1014  if (r)
1015  *r = (number) rr;
1016  else
1017  {
1018  mpz_clear(rr);
1019  }
1020  nrzTest((number)qq);
1021  return (number) qq;
1022 }
1023 
1024 
1025 void nrzPower (number a, int i, number * result, const coeffs)
1026 {
1027  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1028  mpz_init(erg);
1029  mpz_t aa;
1030  if (n_Z_IS_SMALL(a))
1031  mpz_init_set_si(aa, SR_TO_INT(a));
1032  else
1033  mpz_init_set(aa, (mpz_ptr) a);
1034  mpz_pow_ui(erg, aa, i);
1035  *result = nrz_short((number) erg);
1036 }
1037 
1038 /*
1039  * create a number from int
1040  * TODO: do not create an mpz if not necessary
1041  */
1042 number nrzInit (long i, const coeffs)
1043 {
1044  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1045  mpz_init_set_si(erg, i);
1046  return nrz_short((number) erg);
1047 }
1048 
1049 void nrzDelete(number *a, const coeffs)
1050 {
1051  if (*a == NULL) return;
1052  if (n_Z_IS_SMALL(*a)==0)
1053  {
1054  mpz_clear((mpz_ptr) *a);
1055  omFreeBin((ADDRESS) *a, gmp_nrz_bin);
1056  }
1057  *a = NULL;
1058 }
1059 
1060 number nrzCopy(number a, const coeffs)
1061 {
1062  if (n_Z_IS_SMALL(a)) return a;
1063  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1064  mpz_init_set(erg, (mpz_ptr) a);
1065  return (number) erg;
1066 }
1067 
1068 int nrzSize(number a, const coeffs)
1069 {
1070  if (a == NULL) return 0;
1071  if (n_Z_IS_SMALL(a)) return 1;
1072  return mpz_size1((mpz_ptr)a)+1;
1073 }
1074 
1075 /*
1076  * convert a number to int
1077  */
1078 long nrzInt(number &n, const coeffs)
1079 {
1080  if (n_Z_IS_SMALL(n)) return SR_TO_INT(n);
1081  return mpz_get_si( (mpz_ptr)n);
1082 }
1083 #if CF_DEBUG
1084 number _nrzAdd(number, number, const coeffs);
1085 number nrzAdd(number a, number b, const coeffs R)
1086 {
1087  StringSetS("Add: ");
1088  nrzWrite(a, R);
1089  StringAppendS(" to ");
1090  nrzWrite(b, R);
1091  number c = _nrzAdd(a, b, R);
1092  StringAppendS(" is ");
1093  nrzWrite(c, R);
1094  char * s = StringEndS();
1095  Print("%s\n", s);
1096  omFree(s);
1097  return c;
1098 }
1099 number _nrzAdd (number a, number b, const coeffs )
1100 #else
1101 number nrzAdd (number a, number b, const coeffs )
1102 #endif
1103 {
1104  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
1105  {
1106  int c = SR_TO_INT(a) + SR_TO_INT(b);
1107  if (INT_IS_SMALL(c))
1108  return INT_TO_SR(c);
1109  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1110  mpz_init_set_si(erg, c);
1111 
1112  nrzTest((number)erg);
1113  return (number) erg;
1114  }
1115  else if (n_Z_IS_SMALL(a))
1116  {
1117  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1118  mpz_init(erg);
1119  if (SR_TO_INT(a)>0)
1120  mpz_add_ui(erg, (mpz_ptr) b, (unsigned long)SR_TO_INT(a));
1121  else
1122  mpz_sub_ui(erg, (mpz_ptr) b, (unsigned long)-(SR_TO_INT(a)));
1123  return nrz_short((number) erg);
1124  }
1125  else if (n_Z_IS_SMALL(b))
1126  {
1127  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1128  mpz_init(erg);
1129  if (SR_TO_INT(b)>0)
1130  mpz_add_ui(erg, (mpz_ptr) a, (unsigned long)SR_TO_INT(b));
1131  else
1132  mpz_sub_ui(erg, (mpz_ptr) a, (unsigned long)-(SR_TO_INT(b)));
1133  return nrz_short((number) erg);
1134  }
1135  else
1136  {
1137  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1138  mpz_init(erg);
1139  mpz_add(erg, (mpz_ptr) a, (mpz_ptr) b);
1140  return nrz_short((number) erg);
1141  }
1142 }
1143 
1144 number nrzSub (number a, number b, const coeffs )
1145 {
1146  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
1147  {
1148  int c = SR_TO_INT(a) - SR_TO_INT(b);
1149  if (INT_IS_SMALL(c))
1150  return INT_TO_SR(c);
1151  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1152  mpz_init_set_si(erg, c);
1153  nrzTest((number)erg);
1154  return (number) erg;
1155  }
1156  else if (n_Z_IS_SMALL(a))
1157  {
1158  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1159  mpz_init(erg);
1160 
1161  if (SR_TO_INT(a)>0)
1162  mpz_ui_sub(erg, (unsigned long)SR_TO_INT(a), (mpz_ptr) b);
1163  else
1164  {
1165  mpz_add_ui(erg, (mpz_ptr) b, (unsigned long)-SR_TO_INT(a));
1166  mpz_neg(erg, erg);
1167  }
1168  return nrz_short((number) erg);
1169  }
1170  else if (n_Z_IS_SMALL(b))
1171  {
1172  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1173  mpz_init(erg);
1174  if (SR_TO_INT(b)>0)
1175  mpz_sub_ui(erg, (mpz_ptr) a, (unsigned long)SR_TO_INT(b));
1176  else
1177  mpz_add_ui(erg, (mpz_ptr) a, (unsigned long)-SR_TO_INT(b));
1178  return nrz_short((number) erg);
1179  }
1180  else
1181  {
1182  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1183  mpz_init(erg);
1184  mpz_sub(erg, (mpz_ptr) a, (mpz_ptr) b);
1185  return nrz_short((number) erg);
1186  }
1187 }
1188 
1189 number nrzGetUnit (number n, const coeffs r)
1190 {
1191  if (nrzGreaterZero(n, r))
1192  return INT_TO_SR(1);
1193  else
1194  return INT_TO_SR(-1);
1195 }
1196 
1197 number nrzAnn(number n, const coeffs)
1198 {
1199  if (SR_TO_INT(n)) // in Z: the annihilator of !=0 is 0
1200  return INT_TO_SR(0);
1201  else
1202  return INT_TO_SR(1);
1203 }
1204 
1205 BOOLEAN nrzIsUnit (number a, const coeffs)
1206 {
1207  return ABS(SR_TO_INT(a))==1;
1208 }
1209 
1210 BOOLEAN nrzIsZero (number a, const coeffs)
1211 {
1212  return a==INT_TO_SR(0);
1213 }
1214 
1215 BOOLEAN nrzIsOne (number a, const coeffs)
1216 {
1217  return a==INT_TO_SR(1);
1218 }
1219 
1220 BOOLEAN nrzIsMOne (number a, const coeffs)
1221 {
1222  return a==INT_TO_SR(-1);
1223 }
1224 
1225 BOOLEAN nrzEqual (number a,number b, const coeffs)
1226 {
1227  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
1228  return a==b;
1229  else if (n_Z_IS_SMALL(a) || n_Z_IS_SMALL(b))
1230  return FALSE;
1231  else
1232  return 0 == mpz_cmp((mpz_ptr) a, (mpz_ptr) b);
1233 }
1234 
1235 BOOLEAN nrzGreater (number a,number b, const coeffs)
1236 {
1237  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
1238  return ((long)a)>((long)b);
1239  else if (n_Z_IS_SMALL(a))
1240  return 0 > mpz_cmp_si((mpz_ptr)b,SR_TO_INT(a));
1241  else if (n_Z_IS_SMALL(b))
1242  return 0 < mpz_cmp_si((mpz_ptr)a,SR_TO_INT(b));
1243  return 0 < mpz_cmp((mpz_ptr) a, (mpz_ptr) b);
1244 }
1245 
1246 BOOLEAN nrzGreaterZero (number k, const coeffs C)
1247 {
1248  return nrzGreater(k, INT_TO_SR(0), C);
1249 }
1250 
1251 int nrzDivComp(number a, number b, const coeffs r)
1252 {
1253  if (nrzDivBy(a, b, r))
1254  {
1255  if (nrzDivBy(b, a, r)) return 2;
1256  return -1;
1257  }
1258  if (nrzDivBy(b, a, r)) return 1;
1259  return 0;
1260 }
1261 
1262 BOOLEAN nrzDivBy (number a,number b, const coeffs)
1263 {
1264  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
1265  {
1266  return SR_TO_INT(a) %SR_TO_INT(b) ==0;
1267  }
1268  else if (n_Z_IS_SMALL(a))
1269  {
1270  return a==INT_TO_SR(0);
1271  }
1272  else if (n_Z_IS_SMALL(b))
1273  {
1274  return mpz_divisible_ui_p((mpz_ptr)a, (unsigned long)ABS(SR_TO_INT(b))) != 0;
1275  }
1276  else
1277  return mpz_divisible_p((mpz_ptr) a, (mpz_ptr) b) != 0;
1278 }
1279 
1280 number nrzDiv (number a,number b, const coeffs)
1281 {
1282  assume(SR_TO_INT(b));
1283  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
1284  {
1285  //if (SR_TO_INT(a) % SR_TO_INT(b))
1286  //{
1287  // WerrorS("1:Division by non divisible element.");
1288  // WerrorS("Result is without remainder.");
1289  //}
1290  return INT_TO_SR(SR_TO_INT(a)/SR_TO_INT(b));
1291  }
1292  else if (n_Z_IS_SMALL(a))
1293  {
1294  //if (SR_TO_INT(a))
1295  //{
1296  // WerrorS("2:Division by non divisible element.");
1297  // WerrorS("Result is without remainder.");
1298  //}
1299  return INT_TO_SR(0);
1300  }
1301  else if (n_Z_IS_SMALL(b))
1302  {
1303  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1304  mpz_t r;
1305  mpz_init(r);
1306  mpz_init(erg);
1307  if (mpz_divmod_ui(erg, r, (mpz_ptr) a, (unsigned long)ABS(SR_TO_INT(b)))) {
1308  // WerrorS("3:Division by non divisible element.");
1309  // WerrorS("Result is without remainder.");
1310  }
1311  mpz_clear(r);
1312  if (SR_TO_INT(b)<0)
1313  mpz_neg(erg, erg);
1314  return nrz_short((number) erg);
1315  }
1316  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1317  mpz_init(erg);
1318  mpz_t r;
1319  mpz_init(r);
1320  mpz_tdiv_qr(erg, r, (mpz_ptr) a, (mpz_ptr) b);
1321 #if CF_DEBUG
1322  StringSetS("division of");
1323  nrzWrite(a, R);
1324  StringAppendS(" by ");
1325  nrzWrite(b, R);
1326  StringAppendS(" is ");
1327  number du;
1328  nrzWrite(du = (number)erg, R);
1329  StringAppendS(" rest ");
1330  nrzWrite(du = (number)r, R);
1331  char * s = StringEndS();
1332  Print("%s\n", s);
1333  omFree(s);
1334 #endif
1335 
1336  if (mpz_cmp_si(r, 0)!=0)
1337  {
1338  //WerrorS("4:Division by non divisible element.");
1339  //WerrorS("Result is without remainder.");
1340  }
1341  mpz_clear(r);
1342  return nrz_short((number) erg);
1343 }
1344 
1345 number nrzExactDiv (number a,number b, const coeffs)
1346 {
1347  assume(SR_TO_INT(b));
1348  mpz_t aa, bb;
1349  if (n_Z_IS_SMALL(a))
1350  mpz_init_set_si(aa, SR_TO_INT(a));
1351  else
1352  mpz_init_set(aa, (mpz_ptr) a);
1353  if (n_Z_IS_SMALL(b))
1354  mpz_init_set_si(bb, SR_TO_INT(b));
1355  else
1356  mpz_init_set(bb, (mpz_ptr) b);
1357  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1358  mpz_init(erg);
1359  mpz_tdiv_q(erg, (mpz_ptr) aa, (mpz_ptr) bb);
1360  mpz_clear(aa);
1361  mpz_clear(bb);
1362  nrzTest((number)erg);
1363  return (number) erg;
1364 }
1365 
1366 number nrzIntMod (number a,number b, const coeffs)
1367 {
1368  mpz_t aa, bb;
1369  assume(SR_TO_INT(b));
1370  if (n_Z_IS_SMALL(a))
1371  mpz_init_set_si(aa, SR_TO_INT(a));
1372  else
1373  mpz_init_set(aa, (mpz_ptr) a);
1374  if (n_Z_IS_SMALL(b))
1375  mpz_init_set_si(bb, SR_TO_INT(b));
1376  else
1377  mpz_init_set(bb, (mpz_ptr) b);
1378 
1379  mpz_t erg;
1380  mpz_init(erg);
1381  mpz_ptr r = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1382  mpz_init(r);
1383  mpz_tdiv_qr(erg, r, (mpz_ptr) aa, (mpz_ptr) bb);
1384  mpz_clear(erg);
1385  mpz_clear(aa);
1386  mpz_clear(bb);
1387 
1388  return nrz_short((number) r);
1389 }
1390 
1391 number nrzInvers (number c, const coeffs r)
1392 {
1393  if (!nrzIsUnit((number) c, r))
1394  {
1395  WerrorS("Non invertible element.");
1396  return (number)0; //TODO
1397  }
1398  return c; // has to be 1 or -1....
1399 }
1400 
1401 number nrzNeg (number c, const coeffs)
1402 {
1403 // nNeg inplace !!!
1404  if (n_Z_IS_SMALL(c))
1405  return INT_TO_SR(-SR_TO_INT(c));
1406  mpz_mul_si((mpz_ptr) c, (mpz_ptr) c, -1);
1407  return c;
1408 }
1409 
1410 static number nrzFarey(number r, number N, const coeffs R)
1411 {
1412  number a0 = nrzCopy(N, R);
1413  number b0 = nrzInit(0, R);
1414  number a1 = nrzCopy(r, R);
1415  number b1 = nrzInit(1, R);
1416  number two = nrzInit(2, R);
1417 #if 0
1418  Print("Farey start with ");
1419  n_Print(r, R);
1420  Print(" mod ");
1421  n_Print(N, R);
1422  Print("\n");
1423 #endif
1424  while (1)
1425  {
1426  number as = nrzMult(a1, a1, R);
1427  n_InpMult(as, two, R);
1428  if (nrzGreater(N, as, R))
1429  {
1430  nrzDelete(&as, R);
1431  break;
1432  }
1433  nrzDelete(&as, R);
1434  number q = nrzDiv(a0, a1, R);
1435  number t = nrzMult(a1, q, R),
1436  s = nrzSub(a0, t, R);
1437  nrzDelete(&a0, R);
1438  a0 = a1;
1439  a1 = s;
1440  nrzDelete(&t, R);
1441 
1442  t = nrzMult(b1, q, R);
1443  s = nrzSub(b0, t, R);
1444  nrzDelete(&b0, R);
1445  b0 = b1;
1446  b1 = s;
1447  nrzDelete(&t, R);
1448  nrzDelete(&q, R);
1449  }
1450  number as = nrzMult(b1, b1, R);
1451  n_InpMult(as, two, R);
1452  nrzDelete(&two, R);
1453  if (nrzGreater(as, N, R))
1454  {
1455  nrzDelete(&a0, R);
1456  nrzDelete(&a1, R);
1457  nrzDelete(&b0, R);
1458  nrzDelete(&b1, R);
1459  nrzDelete(&as, R);
1460  return NULL;
1461  }
1462  nrzDelete(&as, R);
1463  nrzDelete(&a0, R);
1464  nrzDelete(&b0, R);
1465 
1466  number a, b, ab;
1467  coeffs Q = nInitChar(n_Q, 0);
1468  nMapFunc f = n_SetMap(R, Q);
1469  a = f(a1, R, Q);
1470  b = f(b1, R, Q);
1471  ab = n_Div(a, b, Q);
1472  n_Delete(&a, Q);
1473  n_Delete(&b, Q);
1474  nKillChar(Q);
1475 
1476  nrzDelete(&a1, R);
1477  nrzDelete(&b1, R);
1478  return ab;
1479 }
1480 
1481 number nrzMapMachineInt(number from, const coeffs /*src*/, const coeffs /*dst*/)
1482 {
1483  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1484  mpz_init_set_ui(erg, (unsigned long) from);
1485  return nrz_short((number) erg);
1486 }
1487 
1488 number nrzMapZp(number from, const coeffs /*src*/, const coeffs /*dst*/)
1489 {
1490  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1491  mpz_init_set_si(erg, (long) from);
1492  return nrz_short((number) erg);
1493 }
1494 
1495 number nrzModNMap(number from, const coeffs /* src */, const coeffs /*dst*/)
1496 {
1497  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1498  mpz_init_set(erg, (mpz_ptr) from);
1499  return nrz_short((number) erg);
1500 }
1501 
1502 number nrzMapQ(number from, const coeffs /* src */, const coeffs dst)
1503 {
1504  if (SR_HDL(from) & SR_INT)
1505  return nrzInit(SR_TO_INT(from),dst);
1506  if (from->s!=3)
1507  {
1508  WerrorS("rational in map to integer");
1509  return NULL;
1510  }
1511  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1512  mpz_init_set(erg, from->z);
1513  return nrz_short((number) erg);
1514 }
1515 
1516 nMapFunc nrzSetMap(const coeffs src, const coeffs /*dst*/)
1517 {
1518  /* dst = rintegers */
1519  if (src->rep==n_rep_gmp) //nCoeff_is_Ring_ModN(src) || nCoeff_is_Ring_PtoM(src))
1520  return nrzModNMap;
1521 
1522  if ((src->rep==n_rep_gap_gmp) && nCoeff_is_Ring_Z(src))
1523  {
1524  return ndCopyMap; //nrzCopyMap;
1525  }
1526  if (src->rep==n_rep_gap_rat) /*&& nCoeff_is_Ring_Z(src)) Q, bigint*/
1527  {
1528  return nrzMapQ;
1529  }
1530  if ((src->rep==n_rep_int) && nCoeff_is_Ring_2toM(src))
1531  {
1532  return nrzMapMachineInt;
1533  }
1534  if ((src->rep==n_rep_int) && nCoeff_is_Zp(src))
1535  {
1536  return nrzMapZp;
1537  }
1538  return NULL; // default
1539 }
1540 
1541 
1542 /*
1543  * set the exponent (allocate and init tables) (TODO)
1544  */
1545 
1546 void nrzSetExp(int, coeffs)
1547 {
1548 }
1549 
1550 void nrzInitExp(int, coeffs)
1551 {
1552 }
1553 
1554 #ifdef LDEBUG
1555 BOOLEAN nrzDBTest (number x, const char *f, const int l, const coeffs)
1556 {
1557  if (SR_HDL(x) & SR_INT) return TRUE;
1558  if (mpz_cmp_ui((mpz_ptr) x,(long)0)==0)
1559  {
1560  Print("gmp-0 %s:%d\n",f,l);
1561  return FALSE;
1562  }
1563  if (mpz_size1((mpz_ptr)x)<=MP_SMALL)
1564  {
1565  int ui=mpz_get_si((mpz_ptr)x);
1566  if ((((ui<<3)>>3)==ui)
1567  && (mpz_cmp_si((mpz_ptr)x,(long)ui)==0))
1568  {
1569  Print("gmp-small %s:%d\n",f,l);
1570  return FALSE;
1571  }
1572  }
1573  return TRUE;
1574 }
1575 #endif
1576 
1577 void nrzWrite (number &a, const coeffs)
1578 {
1579  char *s,*z;
1580  if (a==NULL)
1581  {
1582  StringAppendS("o");
1583  }
1584  else
1585  {
1586  if (n_Z_IS_SMALL(a))
1587  {
1588  StringAppend("%d", SR_TO_INT(a));
1589  }
1590  else
1591  {
1592  int l=mpz_sizeinbase((mpz_ptr) a, 10) + 2;
1593  s=(char*)omAlloc(l);
1594  z=mpz_get_str(s,10,(mpz_ptr) a);
1595  StringAppendS(z);
1596  omFreeSize((ADDRESS)s,l);
1597  }
1598  }
1599 }
1600 
1601 /*2
1602 * extracts a long integer from s, returns the rest (COPY FROM longrat0.cc)
1603 */
1604 static const char * nlEatLongC(char *s, mpz_ptr i)
1605 {
1606  const char * start=s;
1607 
1608  if (*s<'0' || *s>'9')
1609  {
1610  mpz_set_si(i,1);
1611  return s;
1612  }
1613  while (*s >= '0' && *s <= '9') s++;
1614  if (*s=='\0')
1615  {
1616  mpz_set_str(i,start,10);
1617  }
1618  else
1619  {
1620  char c=*s;
1621  *s='\0';
1622  mpz_set_str(i,start,10);
1623  *s=c;
1624  }
1625  return s;
1626 }
1627 
1628 const char * nrzRead (const char *s, number *a, const coeffs)
1629 {
1630  mpz_ptr z = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1631  {
1632  mpz_init(z);
1633  s = nlEatLongC((char *) s, z);
1634  }
1635  *a = nrz_short((number) z);
1636  return s;
1637 }
1638 
1639 void nrzCoeffWrite (const coeffs, BOOLEAN /*details*/)
1640 {
1641  //PrintS("// ZZ\n");
1642  PrintS("// coeff. ring is : Integers\n");
1643 }
1644 
1645 static char* nrzCoeffString(const coeffs)
1646 {
1647  return omStrDup("integer");
1648 }
1649 
1650 static CanonicalForm nrzConvSingNFactoryN( number n, BOOLEAN setChar, const coeffs /*r*/ )
1651 {
1652  if (setChar) setCharacteristic( 0 );
1653 
1655  if ( n_Z_IS_SMALL(n))
1656  {
1657  term = SR_TO_INT(n);
1658  }
1659  else
1660  {
1661  mpz_t dummy;
1662  mpz_init_set( dummy,n->z );
1663  term = make_cf( dummy );
1664  }
1665  return term;
1666 }
1667 
1668 static number nrzConvFactoryNSingN( const CanonicalForm n, const coeffs r)
1669 {
1670  if (n.isImm())
1671  {
1672  return nrzInit(n.intval(),r);
1673  }
1674  else
1675  {
1676  if ( !n.den().isOne() )
1677  {
1678  WerrorS("rational in conversion to integer");
1679  return NULL;
1680  }
1681  mpz_ptr z = (mpz_ptr) omAlloc0Bin(gmp_nrz_bin);
1682  gmp_numerator( n,z);
1683  return nrz_short((number)z);
1684  }
1685 }
1686 
1687 static void nrzMPZ(mpz_t res, number &a, const coeffs)
1688 {
1689  if (n_Z_IS_SMALL(a))
1690  mpz_init_set_si(res, SR_TO_INT(a));
1691  else
1692  mpz_init_set(res, (mpz_ptr) a);
1693 }
1694 
1695 coeffs nrzQuot1(number c, const coeffs r)
1696 {
1697  mpz_ptr dummy;
1698  dummy = (mpz_ptr) omAlloc(sizeof(mpz_t));
1699  if(n_Z_IS_SMALL(c))
1700  {
1701  long ch = r->cfInt(c, r);
1702  mpz_init_set_ui(dummy, ch);
1703  }
1704  else
1705  {
1706  mpz_init_set(dummy, (mpz_ptr)c);
1707  }
1708  ZnmInfo info;
1709  info.base = dummy;
1710  info.exp = (unsigned long) 1;
1711  coeffs rr = nInitChar(n_Zn, (void*)&info);
1712  return(rr);
1713 }
1714 
1715 BOOLEAN nrzInitChar(coeffs r, void *)
1716 {
1717  assume( getCoeffType(r) == ID );
1718 
1719  r->is_field=FALSE;
1720  r->is_domain=TRUE;
1721  r->rep=n_rep_gap_gmp;
1722 
1723  //r->nCoeffIsEqual = ndCoeffIsEqual;
1724  r->cfCoeffString = nrzCoeffString;
1725  //r->cfKillChar = ndKillChar;
1726  r->cfMult = nrzMult;
1727  r->cfSub = nrzSub;
1728  r->cfAdd = nrzAdd;
1729  r->cfDiv = nrzDiv;
1730  r->cfIntMod= nrzIntMod;
1731  r->cfExactDiv= nrzExactDiv;
1732  r->cfInit = nrzInit;
1733  r->cfSize = nrzSize;
1734  r->cfInt = nrzInt;
1735  //#ifdef HAVE_RINGS
1736  r->cfDivComp = nrzDivComp; // only for ring stuff
1737  r->cfIsUnit = nrzIsUnit; // only for ring stuff
1738  r->cfGetUnit = nrzGetUnit; // only for ring stuff
1739  r->cfAnn = nrzAnn;
1740  r->cfExtGcd = nrzExtGcd; // only for ring stuff
1741  r->cfXExtGcd = nrzXExtGcd; // only for ring stuff
1742  r->cfQuotRem = nrzQuotRem;
1743  r->cfDivBy = nrzDivBy; // only for ring stuff
1744  //#endif
1745  r->cfInpNeg = nrzNeg;
1746  r->cfInvers= nrzInvers;
1747  r->cfCopy = nrzCopy;
1748  r->cfWriteLong = nrzWrite;
1749  r->cfRead = nrzRead;
1750  r->cfGreater = nrzGreater;
1751  r->cfEqual = nrzEqual;
1752  r->cfIsZero = nrzIsZero;
1753  r->cfIsOne = nrzIsOne;
1754  r->cfIsMOne = nrzIsMOne;
1755  r->cfGreaterZero = nrzGreaterZero;
1756  r->cfPower = nrzPower;
1757  r->cfGcd = nrzGcd;
1758  r->cfLcm = nrzLcm;
1759  r->cfDelete= nrzDelete;
1760  r->cfSetMap = nrzSetMap;
1761  r->cfCoeffWrite = nrzCoeffWrite;
1762  r->convSingNFactoryN = nrzConvSingNFactoryN;
1763  r->convFactoryNSingN = nrzConvFactoryNSingN;
1764  r->cfMPZ = nrzMPZ;
1765  r->cfFarey = nrzFarey;
1766 
1767  r->cfQuot1 = nrzQuot1;
1768  // debug stuff
1769 
1770 #ifdef LDEBUG
1771  r->cfDBTest=nrzDBTest;
1772 #endif
1773 
1774  r->nNULL = 0;
1775  r->ch = 0;
1776  r->has_simple_Alloc=FALSE;
1777  r->has_simple_Inverse=FALSE;
1778  return FALSE;
1779 }
1780 
1781 #elif SI_INTEGER_VARIANT == 1
1782 BOOLEAN nrzInitChar(coeffs r, void *)
1783 {
1784  return nlInitChar(r,(void*)1);
1785 }
1786 #else
1787 #error set SI_INTEGER_VARIANT
1788 #endif
1789 #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:744
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:181
#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:818
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 'a' and 'b'; replacement of 'a' by the product a*b
Definition: coeffs.h:640
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:750
void nrzSetExp(int c, coeffs r)
Definition: rintegers.cc:371
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition: coeffs.h:741
(), see rinteger.h, new impl.
Definition: coeffs.h:111
BOOLEAN nrzEqual(number a, number b, const coeffs r)
Definition: rintegers.cc:231
factory'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:23
int k
Definition: cfEzgcd.cc:93
char * StringEndS()
Definition: reporter.cc:151
void nlGMP(number &i, number n, const coeffs r)
Definition: longrat.cc:1410
#define Q
Definition: sirandom.c:25
BOOLEAN nlInitChar(coeffs r, void *p)
Definition: longrat.cc:3138
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
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
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
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:747
unsigned long exp
Definition: rmodulon.h:18
#define info
Definition: libparse.cc:1254
#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:720
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 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
Definition: coeffs.h:615
#define ABS(x)
Definition: auxiliary.h:157
#define R
Definition: sirandom.c:26
#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 'p'
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:549
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