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 */
17static 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
25static 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 */
33static 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 */
45static 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 */
57static 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
71static 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
102static 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 */
113number 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
120void nrzDelete(number *a, const coeffs)
121{
122 if (*a != NULL)
123 {
124 mpz_clear((mpz_ptr) *a);
126 *a = NULL;
127 }
128}
129
130static 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
138number nrzCopyMap(number a, const coeffs /*src*/, const coeffs dst)
139{
140 return nrzCopy(a,dst);
141}
142#endif
143
144int 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 */
156static long nrzInt(number &n, const coeffs)
157{
158 return mpz_get_si( (mpz_ptr)n);
159}
160
161static 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
169static void nrzInpAdd (number &a, number b, const coeffs)
170{
171 mpz_add((mpz_ptr) a, (mpz_ptr) a, (mpz_ptr) b);
172}
173
174static 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
182static number nrzGetUnit (number, const coeffs r)
183{
184 return nrzInit(1, r);
185}
186
187static BOOLEAN nrzIsUnit (number a, const coeffs)
188{
189 return 0 == mpz_cmpabs_ui((mpz_ptr) a, 1);
190}
191
192static BOOLEAN nrzIsZero (number a, const coeffs)
193{
194 return 0 == mpz_cmpabs_ui((mpz_ptr) a, 0);
195}
196
197static BOOLEAN nrzIsOne (number a, const coeffs)
198{
199 return (0 == mpz_cmp_ui((mpz_ptr) a, 1));
200}
201
202static BOOLEAN nrzIsMOne (number a, const coeffs)
203{
204 return (0 == mpz_cmp_si((mpz_ptr) a, -1));
205}
206
207static BOOLEAN nrzEqual (number a,number b, const coeffs)
208{
209 return 0 == mpz_cmp((mpz_ptr) a, (mpz_ptr) b);
210}
211
212static BOOLEAN nrzGreater (number a,number b, const coeffs)
213{
214 return 0 < mpz_cmp((mpz_ptr) a, (mpz_ptr) b);
215}
216
217static BOOLEAN nrzGreaterZero (number k, const coeffs)
218{
219 return 0 < mpz_sgn1((mpz_ptr) k);
220}
221
222static BOOLEAN nrzDivBy (number a,number b, const coeffs)
223{
224 return mpz_divisible_p((mpz_ptr) a, (mpz_ptr) b) != 0;
225}
226
227static 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
238static 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 {
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
257static 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 {
264 }
265 else
266 {
267 mpz_tdiv_q(erg, (mpz_ptr) a, (mpz_ptr) b);
268 }
269 return (number) erg;
270}
271
272static 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
281static 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/*
316static 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
336static 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);
345 return (number) r;
346}
347
348static 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
358static 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
365static 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
372static 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
379static 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
387static 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
413static 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
449void nrzSetExp(int, coeffs)
450{
451}
452
453void nrzInitExp(int, coeffs)
454{
455}
456
457#ifdef LDEBUG
458static BOOLEAN nrzDBTest (number, const char *, const int, const coeffs)
459{
460 return TRUE;//TODO
461}
462#endif
463
464void 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);
478 }
479}
480
481/*2
482* extracts a long integer from s, returns the rest (COPY FROM longrat0.cc)
483*/
484static 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
509static 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
520static 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
536static 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
547static 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);
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
560static 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
567static void nrzMPZ(mpz_t res, number &a, const coeffs)
568{
569 mpz_init_set(res, (mpz_ptr) a);
570}
571
572static 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
643void 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
649number 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
657BOOLEAN 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