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