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