My Project
rintegers2.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT: numbers (integers)
6 */
7 
8 
9 #ifdef HAVE_RINGS
10 #if SI_INTEGER_VARIANT == 2
11 
12 #include "coeffs/si_gmp.h"
13 
14 /*
15  * Multiply two numbers
16  */
17 static number nrzMult (number a, number b, const coeffs)
18 {
19  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
20  mpz_init(erg);
21  mpz_mul(erg, (mpz_ptr) a, (mpz_ptr) b);
22  return (number) erg;
23 }
24 
25 /*
26  * Give the smallest non unit k, such that a * x = k = b * y has a solution
27  */
28 static number nrzLcm (number a,number b,const coeffs)
29 {
30  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
31  mpz_init(erg);
32  mpz_lcm(erg, (mpz_ptr) a, (mpz_ptr) b);
33  return (number) erg;
34 }
35 
36 /*
37  * Give the largest non unit k, such that a = x * k, b = y * k has
38  * a solution.
39  */
40 static number nrzGcd (number a,number b,const coeffs)
41 {
42  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
43  mpz_init(erg);
44  mpz_gcd(erg, (mpz_ptr) a, (mpz_ptr) b);
45  return (number) erg;
46 }
47 
48 /*
49  * Give the largest non unit k, such that a = x * k, b = y * k has
50  * a solution and r, s, s.t. k = s*a + t*b
51  */
52 static number nrzExtGcd (number a, number b, number *s, number *t, const coeffs)
53 {
54  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
55  mpz_ptr bs = (mpz_ptr) omAllocBin(gmp_nrz_bin);
56  mpz_ptr bt = (mpz_ptr) omAllocBin(gmp_nrz_bin);
57  mpz_init(erg);
58  mpz_init(bs);
59  mpz_init(bt);
60  mpz_gcdext(erg, bs, bt, (mpz_ptr) a, (mpz_ptr) b);
61  *s = (number) bs;
62  *t = (number) bt;
63  return (number) erg;
64 }
65 
66 static number nrzXExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs )
67 {
68  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
69  mpz_ptr bs = (mpz_ptr) omAllocBin(gmp_nrz_bin);
70  mpz_ptr bt = (mpz_ptr) omAllocBin(gmp_nrz_bin);
71  mpz_init(erg);
72  mpz_init(bs);
73  mpz_init(bt);
74 
75  mpz_gcdext(erg, bs, bt, (mpz_ptr)a, (mpz_ptr)b);
76 
77  mpz_ptr bu = (mpz_ptr) omAllocBin(gmp_nrz_bin);
78  mpz_ptr bv = (mpz_ptr) omAllocBin(gmp_nrz_bin);
79 
80  mpz_init_set(bu, (mpz_ptr) b);
81  mpz_init_set(bv, (mpz_ptr) a);
82 
83  assume(mpz_cmp_si(erg, 0));
84 
85  mpz_div(bu, bu, erg);
86  mpz_div(bv, bv, erg);
87 
88  mpz_mul_si(bu, bu, -1);
89  *u = (number) bu;
90  *v = (number) bv;
91 
92  *s = (number) bs;
93  *t = (number) bt;
94  return (number) erg;
95 }
96 
97 static void nrzPower (number a, int i, number * result, const coeffs)
98 {
99  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
100  mpz_init(erg);
101  mpz_pow_ui(erg, (mpz_ptr) a, i);
102  *result = (number) erg;
103 }
104 
105 /*
106  * create a number from int
107  */
108 number nrzInit (long i, const coeffs)
109 {
110  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
111  mpz_init_set_si(erg, i);
112  return (number) erg;
113 }
114 
115 void nrzDelete(number *a, const coeffs)
116 {
117  if (*a != NULL)
118  {
119  mpz_clear((mpz_ptr) *a);
121  *a = NULL;
122  }
123 }
124 
125 static number nrzCopy(number a, const coeffs)
126 {
127  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
128  mpz_init_set(erg, (mpz_ptr) a);
129  return (number) erg;
130 }
131 
132 #if 0
133 number nrzCopyMap(number a, const coeffs /*src*/, const coeffs dst)
134 {
135  return nrzCopy(a,dst);
136 }
137 #endif
138 
139 int nrzSize(number a, const coeffs)
140 {
141  mpz_ptr p=(mpz_ptr)a;
142  int s=p->_mp_alloc;
143  if (s==1) s=(mpz_cmp_ui(p,0)!=0);
144  return s;
145 
146 }
147 
148 /*
149  * convert a number to int
150  */
151 static long nrzInt(number &n, const coeffs)
152 {
153  return mpz_get_si( (mpz_ptr)n);
154 }
155 
156 static number nrzAdd (number a, number b, const coeffs)
157 {
158  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
159  mpz_init(erg);
160  mpz_add(erg, (mpz_ptr) a, (mpz_ptr) b);
161  return (number) erg;
162 }
163 
164 static number nrzSub (number a, number b, const coeffs)
165 {
166  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
167  mpz_init(erg);
168  mpz_sub(erg, (mpz_ptr) a, (mpz_ptr) b);
169  return (number) erg;
170 }
171 
172 static number nrzGetUnit (number, const coeffs r)
173 {
174  return nrzInit(1, r);
175 }
176 
177 static BOOLEAN nrzIsUnit (number a, const coeffs)
178 {
179  return 0 == mpz_cmpabs_ui((mpz_ptr) a, 1);
180 }
181 
182 static BOOLEAN nrzIsZero (number a, const coeffs)
183 {
184  return 0 == mpz_cmpabs_ui((mpz_ptr) a, 0);
185 }
186 
187 static BOOLEAN nrzIsOne (number a, const coeffs)
188 {
189  return (0 == mpz_cmp_ui((mpz_ptr) a, 1));
190 }
191 
192 static BOOLEAN nrzIsMOne (number a, const coeffs)
193 {
194  return (0 == mpz_cmp_si((mpz_ptr) a, -1));
195 }
196 
197 static BOOLEAN nrzEqual (number a,number b, const coeffs)
198 {
199  return 0 == mpz_cmp((mpz_ptr) a, (mpz_ptr) b);
200 }
201 
202 static BOOLEAN nrzGreater (number a,number b, const coeffs)
203 {
204  return 0 < mpz_cmp((mpz_ptr) a, (mpz_ptr) b);
205 }
206 
207 static BOOLEAN nrzGreaterZero (number k, const coeffs)
208 {
209  return 0 < mpz_sgn1((mpz_ptr) k);
210 }
211 
212 static BOOLEAN nrzDivBy (number a,number b, const coeffs)
213 {
214  return mpz_divisible_p((mpz_ptr) a, (mpz_ptr) b) != 0;
215 }
216 
217 static int nrzDivComp(number a, number b, const coeffs r)
218 {
219  if (nrzDivBy(a, b, r))
220  {
221  if (nrzDivBy(b, a, r)) return 2;
222  return -1;
223  }
224  if (nrzDivBy(b, a, r)) return 1;
225  return 0;
226 }
227 
228 static number nrzDiv (number a,number b, const coeffs r)
229 {
230  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
231  mpz_init(erg);
232  if (nrzIsZero(b,r))
233  {
234  WerrorS(nDivBy0);
235  }
236  else
237  {
238  mpz_ptr r = (mpz_ptr) omAllocBin(gmp_nrz_bin);
239  mpz_init(r);
240  mpz_tdiv_qr(erg, r, (mpz_ptr) a, (mpz_ptr) b);
241  mpz_clear(r);
243  }
244  return (number) erg;
245 }
246 
247 static number nrzExactDiv (number a,number b, const coeffs r)
248 {
249  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
250  mpz_init(erg);
251  if (nrzIsZero(b,r))
252  {
253  WerrorS(nDivBy0);
254  }
255  else
256  {
257  mpz_tdiv_q(erg, (mpz_ptr) a, (mpz_ptr) b);
258  }
259  return (number) erg;
260 }
261 
262 static number nrzEucNorm (number a, const coeffs )
263 {
264  mpz_ptr abs = (mpz_ptr) omAllocBin(gmp_nrz_bin);
265  mpz_init(abs);
266  mpz_abs(abs, (mpz_ptr)a);
267 
268  return (number) abs;
269 }
270 
271 static number nrzSmallestQuotRem (number a, number b, number * r, const coeffs )
272 {
273  mpz_ptr qq = (mpz_ptr) omAllocBin(gmp_nrz_bin);
274  mpz_init(qq);
275  mpz_ptr rr = (mpz_ptr) omAllocBin(gmp_nrz_bin);
276  mpz_init(rr);
277  int gsign = mpz_sgn((mpz_ptr) b);
278  mpz_t gg, ghalf;
279  mpz_init(gg);
280  mpz_init(ghalf);
281  mpz_abs(gg, (mpz_ptr) b);
282  mpz_fdiv_qr(qq, rr, (mpz_ptr) a, gg);
283  mpz_tdiv_q_2exp(ghalf, gg, 1);
284  if (mpz_cmp(rr, ghalf) > 0) // r > ghalf
285  {
286  mpz_sub(rr, rr, gg);
287  mpz_add_ui(qq, qq, 1);
288  }
289  if (gsign < 0) mpz_neg(qq, qq);
290 
291  mpz_clear(gg);
292  mpz_clear(ghalf);
293  if (r==NULL)
294  {
295  mpz_clear(rr);
297  }
298  else
299  {
300  *r=(number)rr;
301  }
302  return (number) qq;
303 }
304 
305 /*
306 static number nrzQuotRem (number a, number b, number * r, const coeffs )
307 {
308  mpz_ptr qq = (mpz_ptr) omAllocBin(gmp_nrz_bin);
309  mpz_init(qq);
310  mpz_ptr rr = (mpz_ptr) omAllocBin(gmp_nrz_bin);
311  mpz_init(rr);
312  mpz_tdiv_qr(qq, rr, (mpz_ptr) a, (mpz_ptr) b);
313  if (r==NULL)
314  {
315  mpz_clear(rr);
316  omFreeBin(rr,gmp_nrz_bin);
317  }
318  else
319  {
320  *r=(number)rr;
321  }
322  return (number) qq;
323 }
324 */
325 
326 static number nrzIntMod (number a,number b, const coeffs)
327 {
328  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
329  mpz_init(erg);
330  mpz_ptr r = (mpz_ptr) omAllocBin(gmp_nrz_bin);
331  mpz_init(r);
332  mpz_tdiv_qr(erg, r, (mpz_ptr) a, (mpz_ptr) b);
333  mpz_clear(erg);
334  omFreeBin(erg, gmp_nrz_bin);
335  return (number) r;
336 }
337 
338 static number nrzInvers (number c, const coeffs r)
339 {
340  if (!nrzIsUnit((number) c, r))
341  {
342  WerrorS("Non invertible element.");
343  return nrzInit(0,r);
344  }
345  return nrzCopy(c,r);
346 }
347 
348 static number nrzNeg (number c, const coeffs)
349 {
350 // nNeg inplace !!!
351  mpz_mul_si((mpz_ptr) c, (mpz_ptr) c, -1);
352  return c;
353 }
354 
355 static number nrzMapMachineInt(number from, const coeffs /*src*/, const coeffs /*dst*/)
356 {
357  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
358  mpz_init_set_ui(erg, (unsigned long) from);
359  return (number) erg;
360 }
361 
362 static number nrzMapZp(number from, const coeffs /*src*/, const coeffs /*dst*/)
363 {
364  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
365  mpz_init_set_si(erg, (long) from);
366  return (number) erg;
367 }
368 
369 static number nrzMapQ(number from, const coeffs src, const coeffs /*dst*/)
370 {
371  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
372  mpz_init(erg);
373  nlMPZ(erg, from, src);
374  return (number) erg;
375 }
376 
377 static number nrzMaplongR(number from, const coeffs src, const coeffs dst)
378 {
379  gmp_float *ff=(gmp_float*)from;
380  if (mpf_fits_slong_p(ff->t))
381  {
382  long l=mpf_get_si(ff->t);
383  return nrzInit(l,dst);
384  }
385  char *out=floatToStr(*(gmp_float*)from, src->float_len);
386  char *p=strchr(out,'.');
387  *p='\0';
388  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
389  mpz_init(erg);
390  if (out[0]=='-')
391  {
392  mpz_set_str(erg,out+1,10);
393  mpz_mul_si(erg, erg, -1);
394  }
395  else
396  {
397  mpz_set_str(erg,out,10);
398  }
399  omFree( (void *)out );
400  return (number) erg;
401 }
402 
403 static nMapFunc nrzSetMap(const coeffs src, const coeffs /*dst*/)
404 {
405  /* dst = currRing */
406  /* dst = nrn */
407  if ((src->rep==n_rep_gmp)
408  && (nCoeff_is_Z(src) || nCoeff_is_Zn(src) || nCoeff_is_Ring_PtoM(src)))
409  {
410  return ndCopyMap; //nrzCopyMap;
411  }
412  if ((src->rep==n_rep_gap_gmp) /*&& nCoeff_is_Z(src)*/)
413  {
414  return ndCopyMap; //nrzCopyMap;
415  }
416  if (nCoeff_is_Ring_2toM(src))
417  {
418  return nrzMapMachineInt;
419  }
420  if (nCoeff_is_Zp(src))
421  {
422  return nrzMapZp;
423  }
424  if (getCoeffType(src)==n_Q /*nCoeff_is_Q(src) or coeffs_BIGINT*/)
425  {
426  return nrzMapQ;
427  }
428  if (nCoeff_is_long_R(src))
429  {
430  return nrzMaplongR;
431  }
432  return NULL; // default
433 }
434 
435 /*
436  * set the exponent (allocate and init tables) (TODO)
437  */
438 
439 void nrzSetExp(int, coeffs)
440 {
441 }
442 
443 void nrzInitExp(int, coeffs)
444 {
445 }
446 
447 #ifdef LDEBUG
448 static BOOLEAN nrzDBTest (number, const char *, const int, const coeffs)
449 {
450  return TRUE;//TODO
451 }
452 #endif
453 
454 void nrzWrite (number a, const coeffs)
455 {
456  char *s,*z;
457  if (a==NULL)
458  {
459  StringAppendS("o");
460  }
461  else
462  {
463  int l=mpz_sizeinbase((mpz_ptr) a, 10) + 2;
464  s=(char*)omAlloc(l);
465  z=mpz_get_str(s,10,(mpz_ptr) a);
466  StringAppendS(z);
467  omFreeSize((ADDRESS)s,l);
468  }
469 }
470 
471 /*2
472 * extracts a long integer from s, returns the rest (COPY FROM longrat0.cc)
473 */
474 static const char * nlEatLongC(char *s, mpz_ptr i)
475 {
476  const char * start=s;
477 
478  if (*s<'0' || *s>'9')
479  {
480  mpz_set_ui(i,1);
481  return s;
482  }
483  while (*s >= '0' && *s <= '9') s++;
484  if (*s=='\0')
485  {
486  mpz_set_str(i,start,10);
487  }
488  else
489  {
490  char c=*s;
491  *s='\0';
492  mpz_set_str(i,start,10);
493  *s=c;
494  }
495  return s;
496 }
497 
498 
499 static CanonicalForm nrzConvSingNFactoryN(number n, BOOLEAN setChar, const coeffs /*r*/)
500 {
501  if (setChar) setCharacteristic( 0 );
502 
504  mpz_t num;
505  mpz_init_set(num, *((mpz_t*)n));
506  term = make_cf(num);
507  return term;
508 }
509 
510 static number nrzConvFactoryNSingN(const CanonicalForm n, const coeffs r)
511 {
512  if (n.isImm())
513  return nrzInit(n.intval(),r);
514  else
515  {
516  mpz_ptr m = (mpz_ptr) omAllocBin(gmp_nrz_bin);
517  gmp_numerator(n,m);
518  if (!n.den().isOne())
519  {
520  WarnS("denominator is not 1 in factory");
521  }
522  return (number) m;
523  }
524 }
525 
526 static const char * nrzRead (const char *s, number *a, const coeffs)
527 {
528  mpz_ptr z = (mpz_ptr) omAllocBin(gmp_nrz_bin);
529  {
530  mpz_init(z);
531  s = nlEatLongC((char *) s, z);
532  }
533  *a = (number) z;
534  return s;
535 }
536 
537 static coeffs nrzQuot1(number c, const coeffs r)
538 {
539  long ch = r->cfInt(c, r);
540  mpz_t dummy;
541  mpz_init_set_ui(dummy, ch);
542  ZnmInfo info;
543  info.base = dummy;
544  info.exp = (unsigned long) 1;
545  coeffs rr = nInitChar(n_Zn, (void*)&info);
546  mpz_clear(dummy);
547  return(rr);
548 }
549 
550 static number nrzInitMPZ(mpz_t m, const coeffs)
551 {
552  mpz_ptr z = (mpz_ptr) omAllocBin(gmp_nrz_bin);
553  mpz_init_set(z, m);
554  return (number)z;
555 }
556 
557 static void nrzMPZ(mpz_t res, number &a, const coeffs)
558 {
559  mpz_init_set(res, (mpz_ptr) a);
560 }
561 
562 static number nrzFarey(number r, number N, const coeffs R)
563 {
564  number a0 = nrzCopy(N, R);
565  number b0 = nrzInit(0, R);
566  number a1 = nrzCopy(r, R);
567  number b1 = nrzInit(1, R);
568  number two = nrzInit(2, R);
569 #if 0
570  PrintS("Farey start with ");
571  n_Print(r, R);
572  PrintS(" mod ");
573  n_Print(N, R);
574  PrintLn();
575 #endif
576  while (1)
577  {
578  number as = nrzMult(a1, a1, R);
579  n_InpMult(as, two, R);
580  if (nrzGreater(N, as, R))
581  {
582  nrzDelete(&as, R);
583  break;
584  }
585  nrzDelete(&as, R);
586  number q = nrzDiv(a0, a1, R);
587  number t = nrzMult(a1, q, R),
588  s = nrzSub(a0, t, R);
589  nrzDelete(&a0, R);
590  a0 = a1;
591  a1 = s;
592  nrzDelete(&t, R);
593 
594  t = nrzMult(b1, q, R);
595  s = nrzSub(b0, t, R);
596  nrzDelete(&b0, R);
597  b0 = b1;
598  b1 = s;
599  nrzDelete(&t, R);
600  nrzDelete(&q, R);
601  }
602  number as = nrzMult(b1, b1, R);
603  n_InpMult(as, two, R);
604  nrzDelete(&two, R);
605  if (nrzGreater(as, N, R))
606  {
607  nrzDelete(&a0, R);
608  nrzDelete(&a1, R);
609  nrzDelete(&b0, R);
610  nrzDelete(&b1, R);
611  nrzDelete(&as, R);
612  return NULL;
613  }
614  nrzDelete(&as, R);
615  nrzDelete(&a0, R);
616  nrzDelete(&b0, R);
617 
618  number a, b, ab;
619  coeffs Q = nInitChar(n_Q, 0);
620  nMapFunc f = n_SetMap(R, Q);
621  a = f(a1, R, Q);
622  b = f(b1, R, Q);
623  ab = n_Div(a, b, Q);
624  n_Delete(&a, Q);
625  n_Delete(&b, Q);
626  nKillChar(Q);
627 
628  nrzDelete(&a1, R);
629  nrzDelete(&b1, R);
630  return ab;
631 }
632 
633 void nrzWriteFd(number n, const ssiInfo* d, const coeffs)
634 {
635  mpz_out_str (d->f_write,SSI_BASE, (mpz_ptr)n);
636  fputc(' ',d->f_write);
637 }
638 
639 number nrzReadFd(const ssiInfo *d, const coeffs)
640 {
641  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
642  mpz_init(erg);
644  return (number)erg;
645 }
646 
647 BOOLEAN nrzInitChar(coeffs r, void *)
648 {
649  assume( getCoeffType(r) == n_Z );
650 
651  r->is_field=FALSE;
652  r->is_domain=TRUE;
653  r->rep=n_rep_gmp;
654 
655  //r->nCoeffIsEqual = ndCoeffIsEqual;
656  r->cfCoeffName = nrzCoeffName;
657  //r->cfKillChar = ndKillChar;
658  r->cfMult = nrzMult;
659  r->cfSub = nrzSub;
660  r->cfAdd = nrzAdd;
661  r->cfDiv = nrzDiv;
662  r->cfIntMod= nrzIntMod;
663  r->cfExactDiv= nrzExactDiv;
664  r->cfInit = nrzInit;
665  r->cfInitMPZ = nrzInitMPZ;
666  r->cfMPZ = nrzMPZ;
667  r->cfSize = nrzSize;
668  r->cfInt = nrzInt;
669  r->cfDivComp = nrzDivComp;
670  r->cfIsUnit = nrzIsUnit;
671  r->cfGetUnit = nrzGetUnit;
672  r->cfExtGcd = nrzExtGcd;
673  r->cfXExtGcd = nrzXExtGcd;
674  r->cfDivBy = nrzDivBy;
675  r->cfEucNorm = nrzEucNorm;
676  r->cfQuotRem = nrzSmallestQuotRem;
677  r->cfInpNeg = nrzNeg;
678  r->cfInvers= nrzInvers;
679  r->cfCopy = nrzCopy;
680  r->cfWriteLong = nrzWrite;
681  r->cfRead = nrzRead;
682  r->cfGreater = nrzGreater;
683  r->cfEqual = nrzEqual;
684  r->cfIsZero = nrzIsZero;
685  r->cfIsOne = nrzIsOne;
686  r->cfIsMOne = nrzIsMOne;
687  r->cfGreaterZero = nrzGreaterZero;
688  r->cfPower = nrzPower;
689  r->cfGcd = nrzGcd;
690  r->cfLcm = nrzLcm;
691  r->cfDelete= nrzDelete;
692  r->cfSetMap = nrzSetMap;
693  r->cfQuot1 = nrzQuot1;
694  r->convSingNFactoryN=nrzConvSingNFactoryN;
695  r->convFactoryNSingN=nrzConvFactoryNSingN;
696  r->cfChineseRemainder=nlChineseRemainderSym;
697  r->cfFarey=nrzFarey;
698  r->cfWriteFd=nrzWriteFd;
699  r->cfReadFd=nrzReadFd;
700  // debug stuff
701 
702 #ifdef LDEBUG
703  r->cfDBTest=nrzDBTest;
704 #endif
705 
706  r->ch = 0;
707  r->has_simple_Alloc=FALSE;
708  r->has_simple_Inverse=FALSE;
709  return FALSE;
710 }
711 #endif
712 #endif
Rational abs(const Rational &a)
Definition: GMPrat.cc:436
#define SSI_BASE
Definition: auxiliary.h:135
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
void * ADDRESS
Definition: auxiliary.h:119
void FACTORY_PUBLIC setCharacteristic(int c)
Definition: cf_char.cc:28
CanonicalForm num(const CanonicalForm &f)
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
int l
Definition: cfEzgcd.cc:100
int m
Definition: cfEzgcd.cc:128
int i
Definition: cfEzgcd.cc:132
int k
Definition: cfEzgcd.cc:99
int p
Definition: cfModGcd.cc:4078
CanonicalForm b
Definition: cfModGcd.cc:4103
FILE * f
Definition: checklibs.c:9
factory's main class
Definition: canonicalform.h:86
CanonicalForm den() const
den() returns the denominator of CO if CO is a rational number, 1 (from the current domain!...
CF_NO_INLINE bool isOne() const
long intval() const
conversion functions
bool isImm() const
Definition: int_poly.h:33
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:816
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition: numbers.cc:255
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:891
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
Definition: coeffs.h:727
@ n_Q
rational (GMP) numbers
Definition: coeffs.h:30
@ n_Zn
only used if HAVE_RINGS is defined
Definition: coeffs.h:44
@ n_Z
only used if HAVE_RINGS is defined
Definition: coeffs.h:43
void n_Print(number &a, const coeffs r)
print a number (BEWARE of string buffers!) mostly for debugging
Definition: numbers.cc:621
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:700
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
Definition: coeffs.h:615
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:354
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
static FORCE_INLINE BOOLEAN nCoeff_is_Zn(const coeffs r)
Definition: coeffs.h:826
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:800
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition: coeffs.h:724
static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
multiplication of 'a' and 'b'; replacement of 'a' by the product a*b
Definition: coeffs.h:641
@ n_rep_gap_gmp
(), see rinteger.h, new impl.
Definition: coeffs.h:112
@ n_rep_gmp
(mpz_ptr), see rmodulon,h
Definition: coeffs.h:115
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:522
#define WarnS
Definition: emacs.cc:78
return result
Definition: facAbsBiFact.cc:75
const CanonicalForm int s
Definition: facAbsFact.cc:51
CanonicalForm res
Definition: facAbsFact.cc:60
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
const ExtensionInfo & info
< [in] sqrfree poly
CanonicalForm FACTORY_PUBLIC make_cf(const mpz_ptr n)
Definition: singext.cc:66
void FACTORY_PUBLIC gmp_numerator(const CanonicalForm &f, mpz_ptr result)
Definition: singext.cc:20
void WerrorS(const char *s)
Definition: feFopen.cc:24
STATIC_VAR jList * Q
Definition: janet.cc:30
void mpz_mul_si(mpz_ptr r, mpz_srcptr s, long int si)
Definition: longrat.cc:177
void nlMPZ(mpz_t m, number &n, const coeffs r)
Definition: longrat.cc:2819
number nlChineseRemainderSym(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs CF)
Definition: longrat.cc:3095
#define assume(x)
Definition: mod2.h:387
char * floatToStr(const gmp_float &r, const unsigned int oprec)
Definition: mpr_complex.cc:578
The main handler for Singular numbers which are suitable for Singular polynomials.
const char *const nDivBy0
Definition: numbers.h:87
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
#define omFree(addr)
Definition: omAllocDecl.h:261
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define NULL
Definition: omList.c:12
void StringAppendS(const char *st)
Definition: reporter.cc:107
void PrintS(const char *s)
Definition: reporter.cc:284
void PrintLn()
Definition: reporter.cc:310
static char * nrzCoeffName(const coeffs)
Definition: rintegers.cc:26
VAR omBin gmp_nrz_bin
Definition: rintegers.cc:24
number nrzReadFd(const ssiInfo *d, const coeffs)
void nrzWrite(number a, const coeffs r)
void nrzDelete(number *a, const coeffs)
int nrzSize(number a, const coeffs)
BOOLEAN nrzInitChar(coeffs r, void *parameter)
number nrzInit(long i, const coeffs r)
void nrzWriteFd(number n, const ssiInfo *d, const coeffs)
void s_readmpz_base(s_buff F, mpz_ptr a, int base)
Definition: s_buff.cc:209
s_buff f_read
Definition: s_buff.h:22
FILE * f_write
Definition: s_buff.h:23
Definition: s_buff.h:21
#define mpz_sgn1(A)
Definition: si_gmp.h:13
#define R
Definition: sirandom.c:27