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