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