My Project
Loading...
Searching...
No Matches
rintegers3.cc
Go to the documentation of this file.
1/****************************************
2* Computer Algebra System SINGULAR *
3****************************************/
4/*
5* ABSTRACT: numbers (integers)
6*/
7#if SI_INTEGER_VARIANT == 3
8#define POW_2_28 (1L<<60)
9
10//make sure that a small number is an immediate integer
11//basically copied from longrat.cc nlShort3
12//TODO: is there any point in checking 0 first???
13//TODO: it is not clear that this works in 32/64 bit everywhere.
14// too many hacks.
15#ifdef LDEBUG
16#define nrzTest(A) nrzDBTest(A,__FILE__,__LINE__,NULL)
17BOOLEAN nrzDBTest (number x, const char *f, const int l, const coeffs);
18#else
19#define nrzTest(A)
20#endif
21
22#undef CF_DEBUG
23static inline number nrz_short(number x)
24{
25#if CF_DEBUG
26 StringAppendS("short(");
27 nrzWrite(x, NULL);
28#endif
29 if (mpz_sgn1((mpz_ptr) x)==0)
30 {
31 mpz_clear((mpz_ptr)x);
33#if CF_DEBUG
34 StringAppendS(")=0");
35#endif
36 return INT_TO_SR(0);
37 }
38 if (mpz_size1((mpz_ptr)x)<=MP_SMALL)
39 {
40 long ui=mpz_get_si((mpz_ptr)x);
41 if ((((ui<<3)>>3)==ui)
42 && (mpz_cmp_si((mpz_ptr)x,ui)==0))
43 {
44 mpz_clear((mpz_ptr)x);
46#if CF_DEBUG
47 StringAppendS(")=imm");
48#endif
49 return INT_TO_SR(ui);
50 }
51 }
52#if CF_DEBUG
53 StringAppendS(")");
54#endif
55 nrzTest(x);
56 return x;
57}
58
59
60int nrzSize(number a, const coeffs)
61{
62 if (a==INT_TO_SR(0)) return 0;
63 if (n_Z_IS_SMALL(a)) return 1;
64 return ((mpz_ptr)a)->_mp_alloc;
65}
66
67
68/*
69 * Multiply two numbers
70 * check for 0, 1, -1 maybe
71 */
72#if CF_DEBUG
73number _nrzMult(number, number, const coeffs);
74number nrzMult(number a, number b, const coeffs R)
75{
76 StringSetS("Mult: ");
77 nrzWrite(a, R);
78 StringAppendS(" by ");
79 nrzWrite(b, R);
80 number c = _nrzMult(a, b, R);
81 StringAppendS(" is ");
82 nrzWrite(c, R);
83 char * s = StringEndS();
84 Print("%s\n", s);
85 omFree(s);
86 return c;
87}
88number _nrzMult (number a, number b, const coeffs R)
89#else
90number nrzMult (number a, number b, const coeffs R)
91#endif
92{
93 if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
94 {
95 //from longrat.cc
96 if (a==INT_TO_SR(0)) return INT_TO_SR(0);
97 if (b==INT_TO_SR(0)) return INT_TO_SR(0);
98 long r=(long)((unsigned long)(SR_HDL(a)-1L))*((unsigned long)(SR_HDL(b)>>1));
99 if ((r/(SR_HDL(b)>>1))==(SR_HDL(a)-1L))
100 {
101 number u=((number) ((r>>1)+SR_INT));
102 if (((((long)SR_HDL(u))<<1)>>1)==SR_HDL(u)) return (u);
103 return nrzInit(SR_HDL(u)>>2, R);
104 }
105 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
106 mpz_init_set_si(erg, SR_TO_INT(a));
107 mpz_mul_si(erg, erg, SR_TO_INT(b));
108 nrzTest((number)erg);
109 return nrz_short((number) erg);
110 }
111 else if (n_Z_IS_SMALL(a))
112 {
113 if (a==INT_TO_SR(0)) return INT_TO_SR(0);
114 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
115 mpz_init_set(erg, (mpz_ptr) b);
116 mpz_mul_si(erg, erg, SR_TO_INT(a));
117 return nrz_short((number) erg);
118 }
119 else if (n_Z_IS_SMALL(b))
120 {
121 if (b==INT_TO_SR(0)) return INT_TO_SR(0);
122 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
123 mpz_init_set(erg, (mpz_ptr) a);
124 mpz_mul_si(erg, erg, SR_TO_INT(b));
125 return nrz_short((number) erg);
126 }
127 else
128 {
129 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
130 mpz_init(erg);
131 mpz_mul(erg, (mpz_ptr) a, (mpz_ptr) b);
132 nrzTest((number)erg);
133 return nrz_short((number) erg);
134 }
135}
136
137static long int_gcd(long a, long b)
138{
139 long r;
140 a = ABS(a);
141 b = ABS(b);
142 if (!a) return b;
143 if (!b) return a;
144 do
145 {
146 r = a % b;
147 a = b;
148 b = r;
149 } while (b);
150 return ABS(a); // % in C does not imply a sign
151 // it would be unlikely to see a negative here
152 // but who knows
153}
154
155/*
156 * Give the smallest non unit k, such that a * x = k = b * y has a solution
157 */
158static number nrzLcm (number a, number b, const coeffs R)
159{
160 #ifdef CF_DEBUG
161 PrintS("nrzLcm\n");
162 #endif
163 mpz_ptr erg;
164 if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
165 {
166 long g = int_gcd(SR_TO_INT(a), SR_TO_INT(b));
167 return nrzMult(a, INT_TO_SR(SR_TO_INT(b)/g), R);
168 }
169 else
170 {
171 erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
172 if (n_Z_IS_SMALL(a))
173 {
174 mpz_init_set(erg, (mpz_ptr) b);
175 unsigned long g = mpz_gcd_ui(NULL, erg, (unsigned long) ABS(SR_TO_INT(a)));
176 mpz_mul_si(erg, erg, SR_TO_INT(a)/g);
177 }
178 else if (n_Z_IS_SMALL(b))
179 {
180 mpz_init_set(erg, (mpz_ptr) a);
181 unsigned long g = mpz_gcd_ui(NULL, erg, (unsigned long) ABS(SR_TO_INT(b)));
182 mpz_mul_si(erg, erg, SR_TO_INT(b)/g);
183 }
184 else
185 {
186 mpz_init(erg);
187 mpz_lcm(erg, (mpz_ptr) a, (mpz_ptr) b);
188 }
189 }
190 nrzTest((number)erg);
191 return (number) erg;
192}
193
194static number nrzCopy(number a, const coeffs)
195{
196 if (n_Z_IS_SMALL(a)) return a;
197 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
198 mpz_init_set(erg, (mpz_ptr) a);
199 nrzTest((number)erg);
200 return (number) erg;
201}
202
203/*
204 * Give the largest non unit k, such that a = x * k, b = y * k has
205 * a solution.
206 */
207static number nrzGcd (number a,number b,const coeffs R)
208{
209 if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
210 {
211 long g = int_gcd(SR_TO_INT(a), SR_TO_INT(b));
212 return INT_TO_SR(g);
213 }
214 else if (n_Z_IS_SMALL(a))
215 {
216 if (a==INT_TO_SR(0))
217 return nrzCopy(b, R);
218 unsigned long g = mpz_gcd_ui(NULL, (mpz_ptr)b, (unsigned long) ABS(SR_TO_INT(a)));
219 return INT_TO_SR( g);
220 }
221 else if (n_Z_IS_SMALL(b))
222 {
223 if (b==INT_TO_SR(0))
224 return nrzCopy(a, R);
225 unsigned long g = mpz_gcd_ui(NULL, (mpz_ptr)a, (unsigned long) ABS(SR_TO_INT(b)));
226 return INT_TO_SR(g);
227 }
228 else
229 {
230 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
231 mpz_init(erg);
232 mpz_gcd(erg, (mpz_ptr) a, (mpz_ptr) b);
233 nrzTest((number)erg);
234 return (number) erg;
235 }
236}
237
238/*
239 * Give the largest non unit k, such that a = x * k, b = y * k has
240 * a solution and r, s, s.t. k = s*a + t*b
241 */
242static long int_extgcd(long a, long b, long * u, long* x, long * v, long* y)
243{
244 long q, r;
245 if (!a)
246 {
247 *u = 0;
248 *v = 1;
249 *x = -1;
250 *y = 0;
251 return b;
252 }
253 if (!b)
254 {
255 *u = 1;
256 *v = 0;
257 *x = 0;
258 *y = 1;
259 return a;
260 }
261 *u=1;
262 *v=0;
263 *x=0;
264 *y=1;
265 do
266 {
267 q = a/b;
268 r = a%b;
269 assume (q*b+r == a);
270 a = b;
271 b = r;
272
273 r = -(*v)*q+(*u);
274 (*u) =(*v);
275 (*v) = r;
276
277 r = -(*y)*q+(*x);
278 (*x) = (*y);
279 (*y) = r;
280 } while (b);
281
282 return a;
283}
284
285static number nrzExtGcd (number a, number b, number *s, number *t, const coeffs)
286{
287 if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
288 {
289 long u, v, x, y;
290 long g = int_extgcd(SR_TO_INT(a), SR_TO_INT(b), &u, &v, &x, &y);
291 *s = INT_TO_SR(u);
292 *t = INT_TO_SR(v);
293 return INT_TO_SR(g);
294 }
295 else
296 {
297 mpz_t aa, bb;
298 if (n_Z_IS_SMALL(a))
299 {
300 mpz_init_set_si(aa, SR_TO_INT(a));
301 }
302 else
303 {
304 mpz_init_set(aa, (mpz_ptr) a);
305 }
306 if (n_Z_IS_SMALL(b))
307 {
308 mpz_init_set_si(bb, SR_TO_INT(b));
309 }
310 else
311 {
312 mpz_init_set(bb, (mpz_ptr) b);
313 }
314 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
315 mpz_ptr bs = (mpz_ptr) omAllocBin(gmp_nrz_bin);
316 mpz_ptr bt = (mpz_ptr) omAllocBin(gmp_nrz_bin);
317 mpz_init(erg);
318 mpz_init(bs);
319 mpz_init(bt);
320 mpz_gcdext(erg, bs, bt, aa, bb);
321 *s = nrz_short((number) bs);
322 *t = nrz_short((number) bt);
323 mpz_clear(aa);
324 mpz_clear(bb);
325 return nrz_short((number) erg);
326 }
327}
328#if CF_DEBUG
329static number _nrzXExtGcd(number, number, number *, number *, number *, number *, const coeffs);
330static number nrzXExtGcd(number a, number b, number *x, number * y, number * u, number * v, const coeffs R)
331{
332 char * s;
333 StringSetS("XExtGcd: ");
334 nrzWrite(a, R);
335 StringAppendS(" by ");
336 nrzWrite(b, R);
337 number c = _nrzXExtGcd(a, b, x, y, u, v, R);
338 StringAppendS(" is ");
339 nrzWrite(c, R);
340 StringAppendS("[[");
341 nrzWrite(*x, R);
342 StringAppendS(", ");
343 nrzWrite(*y, R);
344 StringAppendS("], ");
345 nrzWrite(*u, R);
346 StringAppendS(", ");
347 nrzWrite(*v, R);
348 s=StringEndS();
349 Print("%s]]\n", s);
350 omFree(s);
351 return c;
352}
353static number _nrzXExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs )
354#else
355static number nrzXExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs )
356#endif
357{
358 if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
359 {
360 long uu, vv, x, y;
361 long g = int_extgcd(SR_TO_INT(a), SR_TO_INT(b), &uu, &vv, &x, &y);
362 *s = INT_TO_SR(uu);
363 *t = INT_TO_SR(vv);
364 *u = INT_TO_SR(x);
365 *v = INT_TO_SR(y);
366 return INT_TO_SR(g);
367 }
368 else
369 {
370 mpz_t aa, bb;
371 if (n_Z_IS_SMALL(a))
372 {
373 mpz_init_set_si(aa, SR_TO_INT(a));
374 }
375 else
376 {
377 mpz_init_set(aa, (mpz_ptr) a);
378 }
379 if (n_Z_IS_SMALL(b))
380 {
381 mpz_init_set_si(bb, SR_TO_INT(b));
382 }
383 else
384 {
385 mpz_init_set(bb, (mpz_ptr) b);
386 }
387 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
388 mpz_ptr bs = (mpz_ptr) omAllocBin(gmp_nrz_bin);
389 mpz_ptr bt = (mpz_ptr) omAllocBin(gmp_nrz_bin);
390 mpz_init(erg);
391 mpz_init(bs);
392 mpz_init(bt);
393
394 mpz_gcdext(erg, bs, bt, aa, bb);
395
396 mpz_ptr bu = (mpz_ptr) omAllocBin(gmp_nrz_bin);
397 mpz_ptr bv = (mpz_ptr) omAllocBin(gmp_nrz_bin);
398
399 mpz_init_set(bu, (mpz_ptr) bb);
400 mpz_init_set(bv, (mpz_ptr) aa);
401
402 mpz_clear(aa);
403 mpz_clear(bb);
404 assume(mpz_cmp_si(erg, 0));
405
406 mpz_div(bu, bu, erg);
407 mpz_div(bv, bv, erg);
408
409 mpz_mul_si(bu, bu, -1);
410 *u = nrz_short((number) bu);
411 *v = nrz_short((number) bv);
412
413 *s = nrz_short((number) bs);
414 *t = nrz_short((number) bt);
415 return nrz_short((number) erg);
416 }
417}
418#if CF_DEBUG
419static number _nrzQuotRem(number, number, number *, const coeffs);
420static number nrzQuotRem(number a, number b, number * r, const coeffs R)
421{
422 StringSetS("QuotRem: ");
423 nrzWrite(a, R);
424 StringAppendS(" by ");
425 nrzWrite(b, R);
426 number c = _nrzQuotRem(a, b, r, R);
427 StringAppendS(" is ");
428 nrzWrite(c, R);
429 if (r) {
430 StringAppendS("+R(");
431 nrzWrite(*r, R);
432 StringAppendS(")");
433 }
434 char * s = StringEndS();
435 Print("%s\n", s);
436 omFree(s);
437 return c;
438}
439static number _nrzQuotRem (number a, number b, number * r, const coeffs )
440#else
441static number nrzQuotRem (number a, number b, number * r, const coeffs )
442#endif
443{
444 mpz_ptr qq = (mpz_ptr) omAllocBin(gmp_nrz_bin);
445 mpz_init(qq);
446 mpz_ptr rr = (mpz_ptr) omAllocBin(gmp_nrz_bin);
447 mpz_init(rr);
448 mpz_t bb;
449 mpz_t aa;
450 int gsign;
451 if (SR_HDL(b) & SR_INT)
452 {
453 if (SR_HDL(b)<0) gsign=-1;
454 else gsign=1;
455 mpz_init_set_si(bb,SR_TO_INT(b));
456 }
457 else
458 {
459 gsign = mpz_sgn((mpz_ptr) b);
460 mpz_init_set(bb,(mpz_ptr) b);
461 }
462 if (SR_HDL(a) & SR_INT)
463 {
464 mpz_init_set_si(aa,SR_TO_INT(a));
465 }
466 else
467 {
468 mpz_init_set(aa,(mpz_ptr) a);
469 }
470 mpz_t gg, ghalf;
471 mpz_init(gg);
472 mpz_init(ghalf);
473 mpz_abs(gg, bb);
474 mpz_fdiv_qr(qq, rr, aa, gg);
475 mpz_tdiv_q_2exp(ghalf, gg, 1);
476 if (mpz_cmp(rr, ghalf) > 0) // r > ghalf
477 {
478 mpz_sub(rr, rr, gg);
479 mpz_add_ui(qq, qq, 1);
480 }
481 if (gsign < 0) mpz_neg(qq, qq);
482
483 mpz_clear(ghalf);
484 mpz_clear(gg);
485 mpz_clear(aa);
486 mpz_clear(bb);
487 if (r==NULL)
488 {
489 mpz_clear(rr);
491 }
492 else
493 {
494 *r=nrz_short((number)rr);
495 }
496 return nrz_short((number)qq);
497}
498
499static void nrzPower (number a, int i, number * result, const coeffs)
500{
501 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
502 mpz_init(erg);
503 mpz_t aa;
504 if (n_Z_IS_SMALL(a))
505 mpz_init_set_si(aa, SR_TO_INT(a));
506 else
507 mpz_init_set(aa, (mpz_ptr) a);
508 mpz_pow_ui(erg, aa, i);
509 *result = nrz_short((number) erg);
510}
511
512/*
513 * create a number from int
514 * TODO: do not create an mpz if not necessary
515 */
516number nrzInit (long i, const coeffs)
517{
518 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
519 mpz_init_set_si(erg, i);
520 return nrz_short((number) erg);
521}
522
523static number nrzInitMPZ(mpz_t m, const coeffs)
524{
525 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
526 mpz_init_set(erg, m);
527 return nrz_short((number) erg);
528}
529
530
531void nrzDelete(number *a, const coeffs)
532{
533 if (*a == NULL) return;
534 if (n_Z_IS_SMALL(*a)==0)
535 {
536 mpz_clear((mpz_ptr) *a);
538 }
539 *a = NULL;
540}
541
542/*
543 * convert a number to int
544 */
545static long nrzInt(number &n, const coeffs)
546{
547 if (n_Z_IS_SMALL(n)) return SR_TO_INT(n);
548 return mpz_get_si( (mpz_ptr)n);
549}
550#if CF_DEBUG
551static number _nrzAdd(number, number, const coeffs);
552static number nrzAdd(number a, number b, const coeffs R)
553{
554 StringSetS("Add: ");
555 nrzWrite(a, R);
556 StringAppendS(" to ");
557 nrzWrite(b, R);
558 number c = _nrzAdd(a, b, R);
559 StringAppendS(" is ");
560 nrzWrite(c, R);
561 char * s = StringEndS();
562 Print("%s\n", s);
563 omFree(s);
564 return c;
565}
566static number _nrzAdd (number a, number b, const coeffs )
567#else
568static number nrzAdd (number a, number b, const coeffs )
569#endif
570{
571 if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
572 {
573 long c = SR_HDL(a)+SR_HDL(b)-1L;
574 if (INT_IS_SMALL(c))
575 return (number)c;
576 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
577 mpz_init_set_si(erg,SR_TO_INT(a));
578 if (SR_HDL(b)>0)
579 mpz_add_ui(erg, erg, (unsigned long)SR_TO_INT(b));
580 else
581 mpz_sub_ui(erg, erg, (unsigned long)-(SR_TO_INT(b)));
582 return nrz_short((number)erg);
583 }
584 else if (n_Z_IS_SMALL(a))
585 {
586 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
587 mpz_init(erg);
588 if (SR_HDL(a)>0)
589 mpz_add_ui(erg, (mpz_ptr) b, (unsigned long)SR_TO_INT(a));
590 else
591 mpz_sub_ui(erg, (mpz_ptr) b, (unsigned long)-(SR_TO_INT(a)));
592 return nrz_short((number) erg);
593 }
594 else if (n_Z_IS_SMALL(b))
595 {
596 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
597 mpz_init(erg);
598 if (SR_HDL(b)>0)
599 mpz_add_ui(erg, (mpz_ptr) a, (unsigned long)SR_TO_INT(b));
600 else
601 mpz_sub_ui(erg, (mpz_ptr) a, (unsigned long)-(SR_TO_INT(b)));
602 return nrz_short((number) erg);
603 }
604 else
605 {
606 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
607 mpz_init(erg);
608 mpz_add(erg, (mpz_ptr) a, (mpz_ptr) b);
609 return nrz_short((number) erg);
610 }
611}
612
613static number nrzSub (number a, number b, const coeffs )
614{
615 if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
616 {
617 long c = SR_HDL(a)-SR_HDL(b)+1;
618 if (INT_IS_SMALL(c))
619 return number(c);
620 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
621 mpz_init_set_si(erg,SR_TO_INT(a));
622 if (SR_HDL(b)>0)
623 mpz_sub_ui(erg, erg, (unsigned long)SR_TO_INT(b));
624 else
625 mpz_add_ui(erg, erg, (unsigned long)-(SR_TO_INT(b)));
626 return nrz_short((number)erg);
627 }
628 else if (n_Z_IS_SMALL(a))
629 {
630 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
631 mpz_init_set_si(erg,SR_TO_INT(a));
632 mpz_sub(erg, erg, (mpz_ptr) b);
633 return nrz_short((number) erg);
634 }
635 else if (n_Z_IS_SMALL(b))
636 {
637 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
638 mpz_init(erg);
639 if (SR_HDL(b)>0)
640 mpz_sub_ui(erg, (mpz_ptr) a, (unsigned long)SR_TO_INT(b));
641 else
642 mpz_add_ui(erg, (mpz_ptr) a, (unsigned long)-SR_TO_INT(b));
643 return nrz_short((number) erg);
644 }
645 else
646 {
647 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
648 mpz_init(erg);
649 mpz_sub(erg, (mpz_ptr) a, (mpz_ptr) b);
650 return nrz_short((number) erg);
651 }
652}
653
654static BOOLEAN nrzGreater (number a,number b, const coeffs)
655{
656 if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
657 return ((long)a)>((long)b);
658 else if (n_Z_IS_SMALL(a))
659 return 0 > mpz_cmp_si((mpz_ptr)b,SR_TO_INT(a));
660 else if (n_Z_IS_SMALL(b))
661 return 0 < mpz_cmp_si((mpz_ptr)a,SR_TO_INT(b));
662 return 0 < mpz_cmp((mpz_ptr) a, (mpz_ptr) b);
663}
664
665static BOOLEAN nrzGreaterZero (number k, const coeffs C)
666{
667 return nrzGreater(k, INT_TO_SR(0), C);
668}
669
670static number nrzGetUnit (number n, const coeffs r)
671{
672 if (nrzGreaterZero(n, r))
673 return INT_TO_SR(1);
674 /*else*/
675 return INT_TO_SR(-1);
676}
677
678static number nrzAnn(number n, const coeffs)
679{
680 if (SR_TO_INT(n)) // in Z: the annihilator of !=0 is 0
681 return INT_TO_SR(0);
682 else
683 return INT_TO_SR(1);
684}
685
686static BOOLEAN nrzIsUnit (number a, const coeffs)
687{
688 return ABS(SR_TO_INT(a))==1;
689}
690
691static BOOLEAN nrzIsZero (number a, const coeffs)
692{
693 return (a==INT_TO_SR(0));
694}
695
696static BOOLEAN nrzIsOne (number a, const coeffs)
697{
698 return a==INT_TO_SR(1);
699}
700
701static BOOLEAN nrzIsMOne (number a, const coeffs)
702{
703 return a==INT_TO_SR(-1);
704}
705
706static BOOLEAN nrzEqual (number a,number b, const coeffs)
707{
708 if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
709 return a==b;
710 else if (n_Z_IS_SMALL(a) || n_Z_IS_SMALL(b))
711 return FALSE;
712 else
713 return 0 == mpz_cmp((mpz_ptr) a, (mpz_ptr) b);
714}
715
716static BOOLEAN nrzDivBy (number a,number b, const coeffs)
717{
718 if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
719 {
720 return SR_TO_INT(a) %SR_TO_INT(b) ==0;
721 }
722 else if (n_Z_IS_SMALL(a))
723 {
724 return a==INT_TO_SR(0);
725 }
726 else if (n_Z_IS_SMALL(b))
727 {
728 return mpz_divisible_ui_p((mpz_ptr)a, (unsigned long)ABS(SR_TO_INT(b))) != 0;
729 }
730 else
731 return mpz_divisible_p((mpz_ptr) a, (mpz_ptr) b) != 0;
732}
733
734static int nrzDivComp(number a, number b, const coeffs r)
735{
736 if (nrzDivBy(a, b, r))
737 {
738 if (nrzDivBy(b, a, r)) return 2;
739 return -1;
740 }
741 if (nrzDivBy(b, a, r)) return 1;
742 return 0;
743}
744
745static number nrzDiv (number a,number b, const coeffs cf)
746{
747 if (nrzIsZero(b,cf))
748 {
750 return INT_TO_SR(0);
751 }
752 else if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
753 {
754 long i=SR_TO_INT(a);
755 long j=SR_TO_INT(b);
756 if (j==1L) return a;
757 if ((i==-POW_2_28) && (j== -1L))
758 {
759 return nrzInit(POW_2_28,cf);
760 }
761 //if (SR_TO_INT(a) % SR_TO_INT(b))
762 //{
763 // WerrorS("1:Division by non divisible element.");
764 // WerrorS("Result is without remainder.");
765 //}
766 return INT_TO_SR(i/j);
767 }
768 else if (n_Z_IS_SMALL(a))
769 {
770 //if (SR_TO_INT(a))
771 //{
772 // WerrorS("2:Division by non divisible element.");
773 // WerrorS("Result is without remainder.");
774 //}
775 return INT_TO_SR(0);
776 }
777 else if (n_Z_IS_SMALL(b))
778 {
779 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
780 mpz_t r;
781 mpz_init(r);
782 mpz_init(erg);
783 if (mpz_divmod_ui(erg, r, (mpz_ptr) a, (unsigned long)ABS(SR_TO_INT(b)))) {
784 // WerrorS("3:Division by non divisible element.");
785 // WerrorS("Result is without remainder.");
786 }
787 mpz_clear(r);
788 if (SR_HDL(b)<0)
789 mpz_neg(erg, erg);
790 return nrz_short((number) erg);
791 }
792 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
793 mpz_init(erg);
794 mpz_t r;
795 mpz_init(r);
796 mpz_tdiv_qr(erg, r, (mpz_ptr) a, (mpz_ptr) b);
797#if CF_DEBUG
798 StringSetS("division of");
799 nrzWrite(a, R);
800 StringAppendS(" by ");
801 nrzWrite(b, R);
802 StringAppendS(" is ");
803 number du;
804 nrzWrite(du = (number)erg, R);
805 StringAppendS(" rest ");
806 nrzWrite(du = (number)r, R);
807 char * s = StringEndS();
808 Print("%s\n", s);
809 omFree(s);
810#endif
811
812 if (mpz_sgn1(r)!=0)
813 {
814 //WerrorS("4:Division by non divisible element.");
815 //WerrorS("Result is without remainder.");
816 }
817 mpz_clear(r);
818 return nrz_short((number) erg);
819}
820
821static number nrzExactDiv (number a,number b, const coeffs cf)
822{
824 mpz_t aa, bb;
825 if (nrzIsZero(b,cf))
826 {
828 return INT_TO_SR(0);
829 }
830 else if (n_Z_IS_SMALL(a))
831 mpz_init_set_si(aa, SR_TO_INT(a));
832 else
833 mpz_init_set(aa, (mpz_ptr) a);
834 if (n_Z_IS_SMALL(b))
835 mpz_init_set_si(bb, SR_TO_INT(b));
836 else
837 mpz_init_set(bb, (mpz_ptr) b);
838 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
839 mpz_init(erg);
840 mpz_tdiv_q(erg, (mpz_ptr) aa, (mpz_ptr) bb);
841 mpz_clear(aa);
842 mpz_clear(bb);
843 return nrz_short((number) erg);
844}
845
846static number nrzIntMod (number a,number b, const coeffs)
847{
848 mpz_t aa, bb;
850 if (n_Z_IS_SMALL(a))
851 mpz_init_set_si(aa, SR_TO_INT(a));
852 else
853 mpz_init_set(aa, (mpz_ptr) a);
854 if (n_Z_IS_SMALL(b))
855 mpz_init_set_si(bb, SR_TO_INT(b));
856 else
857 mpz_init_set(bb, (mpz_ptr) b);
858
859 mpz_t erg;
860 mpz_init(erg);
861 mpz_ptr r = (mpz_ptr) omAllocBin(gmp_nrz_bin);
862 mpz_init(r);
863 mpz_tdiv_qr(erg, r, (mpz_ptr) aa, (mpz_ptr) bb);
864 mpz_clear(erg);
865 mpz_clear(aa);
866 mpz_clear(bb);
867
868 return nrz_short((number) r);
869}
870
871static number nrzInvers (number c, const coeffs r)
872{
873 if (!nrzIsUnit((number) c, r))
874 {
875 WerrorS("Non invertible element.");
876 return nrzInit(0,r);
877 }
878 return c; // has to be 1 or -1....
879}
880
881static number nrzNeg (number c, const coeffs)
882{
883// nNeg inplace !!!
884 if (n_Z_IS_SMALL(c))
885 return INT_TO_SR(-SR_TO_INT(c));
886 mpz_mul_si((mpz_ptr) c, (mpz_ptr) c, -1);
887 return c;
888}
889
890static number nrzFarey(number r, number N, const coeffs R)
891{
892 number a0 = nrzCopy(N, R);
893 number b0 = nrzInit(0, R);
894 number a1 = nrzCopy(r, R);
895 number b1 = nrzInit(1, R);
896 number two = nrzInit(2, R);
897#if 0
898 PrintS("Farey start with ");
899 n_Print(r, R);
900 PrintS(" mod ");
901 n_Print(N, R);
902 PrintLn();
903#endif
904 while (1)
905 {
906 number as = nrzMult(a1, a1, R);
907 n_InpMult(as, two, R);
908 if (nrzGreater(N, as, R))
909 {
910 nrzDelete(&as, R);
911 break;
912 }
913 nrzDelete(&as, R);
914 number q = nrzDiv(a0, a1, R);
915 number t = nrzMult(a1, q, R),
916 s = nrzSub(a0, t, R);
917 nrzDelete(&a0, R);
918 a0 = a1;
919 a1 = s;
920 nrzDelete(&t, R);
921
922 t = nrzMult(b1, q, R);
923 s = nrzSub(b0, t, R);
924 nrzDelete(&b0, R);
925 b0 = b1;
926 b1 = s;
927 nrzDelete(&t, R);
928 nrzDelete(&q, R);
929 }
930 number as = nrzMult(b1, b1, R);
931 n_InpMult(as, two, R);
932 nrzDelete(&two, R);
933 if (nrzGreater(as, N, R))
934 {
935 nrzDelete(&a0, R);
936 nrzDelete(&a1, R);
937 nrzDelete(&b0, R);
938 nrzDelete(&b1, R);
939 nrzDelete(&as, R);
940 return NULL;
941 }
942 nrzDelete(&as, R);
943 nrzDelete(&a0, R);
944 nrzDelete(&b0, R);
945
946 number a, b, ab;
947 coeffs Q = nInitChar(n_Q, 0);
948 nMapFunc f = n_SetMap(R, Q);
949 a = f(a1, R, Q);
950 b = f(b1, R, Q);
951 ab = n_Div(a, b, Q);
952 n_Delete(&a, Q);
953 n_Delete(&b, Q);
954 nKillChar(Q);
955
956 nrzDelete(&a1, R);
957 nrzDelete(&b1, R);
958 nrzTest(ab);
959 return ab;
960}
961
962static number nrzMapMachineInt(number from, const coeffs /*src*/, const coeffs /*dst*/)
963{
964 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
965 mpz_init_set_ui(erg, (unsigned long) from);
966 return nrz_short((number) erg);
967}
968
969static number nrzMapZp(number from, const coeffs /*src*/, const coeffs /*dst*/)
970{
971 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
972 mpz_init_set_si(erg, (long) from);
973 return nrz_short((number) erg);
974}
975
976static number nrzModNMap(number from, const coeffs /* src */, const coeffs /*dst*/)
977{
978 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
979 mpz_init_set(erg, (mpz_ptr) from);
980 return nrz_short((number) erg);
981}
982
983static number nrzMapQ(number from, const coeffs /* src */, const coeffs dst)
984{
985 if (SR_HDL(from) & SR_INT)
986 return nrzInit(SR_TO_INT(from),dst);
987 if (from->s!=3)
988 {
989 WerrorS("rational in map to integer");
990 return NULL;
991 }
992 mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
993 mpz_init_set(erg, from->z);
994 return nrz_short((number) erg);
995}
996
997static nMapFunc nrzSetMap(const coeffs src, const coeffs /*dst*/)
998{
999 /* dst = rintegers */
1000 if (src->rep==n_rep_gmp) //nCoeff_is_Zn(src) || nCoeff_is_Ring_PtoM(src))
1001 return nrzModNMap;
1002
1003 if ((src->rep==n_rep_gap_gmp) && nCoeff_is_Z(src))
1004 {
1005 return ndCopyMap; //nrzCopyMap;
1006 }
1007 if (src->rep==n_rep_gap_rat) /*&& nCoeff_is_Z(src)) Q, bigint*/
1008 {
1009 return nrzMapQ;
1010 }
1011 if ((src->rep==n_rep_int) && nCoeff_is_Ring_2toM(src))
1012 {
1013 return nrzMapMachineInt;
1014 }
1015 if ((src->rep==n_rep_int) && nCoeff_is_Zp(src))
1016 {
1017 return nrzMapZp;
1018 }
1019 return NULL; // default
1020}
1021
1022
1023#ifdef LDEBUG
1024BOOLEAN nrzDBTest (number x, const char *f, const int l, const coeffs)
1025{
1026 if (SR_HDL(x) & SR_INT) return TRUE;
1027 if (mpz_sgn1((mpz_ptr) x)==0)
1028 {
1029 Print("gmp-0 %s:%d\n",f,l);
1030 return FALSE;
1031 }
1032 if (mpz_size1((mpz_ptr)x)<=MP_SMALL)
1033 {
1034 long ui=mpz_get_si((mpz_ptr)x);
1035 if ((((ui<<3)>>3)==ui)
1036 && (mpz_cmp_si((mpz_ptr)x,ui)==0))
1037 {
1038 Print("gmp-small %s:%d\n",f,l);
1039 return FALSE;
1040 }
1041 }
1042 return TRUE;
1043}
1044#endif
1045
1046void nrzWrite (number a, const coeffs)
1047{
1048 char *s,*z;
1049 if (a==NULL)
1050 {
1051 StringAppendS("o");
1052 }
1053 else
1054 {
1055 if (n_Z_IS_SMALL(a))
1056 {
1057 StringAppend("%d", SR_TO_INT(a));
1058 }
1059 else
1060 {
1061 int l=mpz_sizeinbase((mpz_ptr) a, 10) + 2;
1062 s=(char*)omAlloc(l);
1063 z=mpz_get_str(s,10,(mpz_ptr) a);
1064 StringAppendS(z);
1066 }
1067 }
1068}
1069
1070/*2
1071* extracts a long integer from s, returns the rest (COPY FROM longrat0.cc)
1072*/
1073static const char * nlEatLongC(char *s, mpz_ptr i)
1074{
1075 const char * start=s;
1076
1077 if (*s<'0' || *s>'9')
1078 {
1079 mpz_set_ui(i,1);
1080 return s;
1081 }
1082 while (*s >= '0' && *s <= '9') s++;
1083 if (*s=='\0')
1084 {
1085 mpz_set_str(i,start,10);
1086 }
1087 else
1088 {
1089 char c=*s;
1090 *s='\0';
1091 mpz_set_str(i,start,10);
1092 *s=c;
1093 }
1094 return s;
1095}
1096
1097static const char * nrzRead (const char *s, number *a, const coeffs)
1098{
1099 mpz_ptr z = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1100 {
1101 mpz_init(z);
1102 s = nlEatLongC((char *) s, z);
1103 }
1104 *a = nrz_short((number) z);
1105 return s;
1106}
1107
1108static CanonicalForm nrzConvSingNFactoryN( number n, BOOLEAN setChar, const coeffs /*r*/ )
1109{
1110 if (setChar) setCharacteristic( 0 );
1111
1113 if ( n_Z_IS_SMALL(n))
1114 {
1115 term = SR_TO_INT(n);
1116 }
1117 else
1118 {
1119 mpz_t dummy;
1120 mpz_init_set( dummy,n->z );
1121 term = make_cf( dummy );
1122 }
1123 return term;
1124}
1125
1126static number nrzConvFactoryNSingN( const CanonicalForm n, const coeffs r)
1127{
1128 if (n.isImm())
1129 {
1130 return nrzInit(n.intval(),r);
1131 }
1132 else
1133 {
1134 if ( !n.den().isOne() )
1135 {
1136 WerrorS("rational in conversion to integer");
1137 return NULL;
1138 }
1139 mpz_ptr z = (mpz_ptr) omAlloc0Bin(gmp_nrz_bin);
1140 gmp_numerator( n,z);
1141 return nrz_short((number)z);
1142 }
1143}
1144
1145static void nrzMPZ(mpz_t res, number &a, const coeffs)
1146{
1147 if (n_Z_IS_SMALL(a))
1148 mpz_init_set_si(res, SR_TO_INT(a));
1149 else
1150 mpz_init_set(res, (mpz_ptr) a);
1151}
1152
1153static number nrzEucNorm (number a, const coeffs )
1154{
1155 if (n_Z_IS_SMALL(a))
1156 {
1157 long aa=ABS(SR_TO_INT(a));
1158 return INT_TO_SR(aa);
1159 }
1160 else
1161 {
1162 mpz_ptr abs = (mpz_ptr) omAllocBin(gmp_nrz_bin);
1163 mpz_init(abs);
1164 mpz_abs(abs, (mpz_ptr)a);
1165 nrzTest((number)abs);
1166 return (number) abs;
1167 }
1168}
1169
1170static coeffs nrzQuot1(number c, const coeffs r)
1171{
1172 mpz_t dummy;
1173 if(n_Z_IS_SMALL(c))
1174 {
1175 long ch = r->cfInt(c, r);
1176 mpz_init_set_ui(dummy, ch);
1177 }
1178 else
1179 {
1180 mpz_init_set(dummy, (mpz_ptr)c);
1181 }
1182 ZnmInfo info;
1183 info.base = dummy;
1184 info.exp = (unsigned long) 1;
1185 coeffs rr = nInitChar(n_Zn, (void*)&info);
1186 mpz_clear(dummy);
1187 return(rr);
1188}
1189
1190number nlReadFd(const ssiInfo *d, const coeffs);
1191void nlWriteFd(number n, const ssiInfo* d, const coeffs);
1192
1193BOOLEAN nrzInitChar(coeffs r, void *)
1194{
1195 assume( getCoeffType(r) == n_Z );
1196
1197 r->is_field=FALSE;
1198 r->is_domain=TRUE;
1199 r->rep=n_rep_gap_gmp;
1200
1201 //r->nCoeffIsEqual = ndCoeffIsEqual;
1202 r->cfCoeffName = nrzCoeffName;
1203 //r->cfKillChar = ndKillChar;
1204 r->cfMult = nrzMult;
1205 r->cfSub = nrzSub;
1206 r->cfAdd = nrzAdd;
1207 r->cfDiv = nrzDiv;
1208 r->cfIntMod= nrzIntMod;
1209 r->cfExactDiv= nrzExactDiv;
1210 r->cfInit = nrzInit;
1211 r->cfInitMPZ = nrzInitMPZ;
1212 r->cfSize = nrzSize;
1213 r->cfInt = nrzInt;
1214 r->cfDivComp = nrzDivComp; // only for ring stuff
1215 r->cfIsUnit = nrzIsUnit; // only for ring stuff
1216 r->cfGetUnit = nrzGetUnit; // only for ring stuff
1217 r->cfAnn = nrzAnn;
1218 r->cfExtGcd = nrzExtGcd; // only for ring stuff
1219 r->cfXExtGcd = nrzXExtGcd; // only for ring stuff
1220 r->cfEucNorm = nrzEucNorm;
1221 r->cfQuotRem = nrzQuotRem;
1222 r->cfDivBy = nrzDivBy; // only for ring stuff
1223 r->cfInpNeg = nrzNeg;
1224 r->cfInvers= nrzInvers;
1225 r->cfCopy = nrzCopy;
1226 r->cfWriteLong = nrzWrite;
1227 r->cfRead = nrzRead;
1228 r->cfGreater = nrzGreater;
1229 r->cfEqual = nrzEqual;
1230 r->cfIsZero = nrzIsZero;
1231 r->cfIsOne = nrzIsOne;
1232 r->cfIsMOne = nrzIsMOne;
1233 r->cfGreaterZero = nrzGreaterZero;
1234 r->cfPower = nrzPower;
1235 r->cfGcd = nrzGcd;
1236 r->cfLcm = nrzLcm;
1237 r->cfDelete= nrzDelete;
1238 r->cfSetMap = nrzSetMap;
1239 r->convSingNFactoryN = nrzConvSingNFactoryN;
1240 r->convFactoryNSingN = nrzConvFactoryNSingN;
1241 r->cfMPZ = nrzMPZ;
1242 r->cfFarey = nrzFarey;
1243 r->cfWriteFd=nlWriteFd;
1244 r->cfReadFd=nlReadFd;
1245
1246 r->cfQuot1 = nrzQuot1;
1247 // requires conversion to factory:
1248 r->cfChineseRemainder=nlChineseRemainderSym;
1249 // debug stuff
1250
1251#ifdef LDEBUG
1252 r->cfDBTest=nrzDBTest;
1253#endif
1254
1255 r->ch = 0;
1256 r->has_simple_Alloc=FALSE;
1257 r->has_simple_Inverse=FALSE;
1258 return FALSE;
1259}
1260#endif
Rational abs(const Rational &a)
Definition GMPrat.cc:436
static int ABS(int v)
Definition auxiliary.h:113
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
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
Variable x
Definition cfModGcd.cc:4090
g
Definition cfModGcd.cc:4098
CanonicalForm cf
Definition cfModGcd.cc:4091
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
@ 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_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_rat
(number), see longrat.h
Definition coeffs.h:118
@ n_rep_gap_gmp
(), see rinteger.h, new impl.
Definition coeffs.h:119
@ n_rep_int
(int), see modulop.h
Definition coeffs.h:117
@ 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 Print
Definition emacs.cc:80
#define StringAppend
Definition emacs.cc:79
return result
const CanonicalForm int s
Definition facAbsFact.cc:51
const CanonicalForm int const CFList const Variable & y
Definition facAbsFact.cc:53
CanonicalForm res
Definition facAbsFact.cc:60
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
int j
Definition facHensel.cc:110
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 nlWriteFd(number n, const ssiInfo *d, const coeffs)
Definition longrat.cc:3322
#define POW_2_28
Definition longrat.cc:103
void mpz_mul_si(mpz_ptr r, mpz_srcptr s, long int si)
Definition longrat.cc:177
number nlChineseRemainderSym(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs CF)
Definition longrat.cc:3087
number nlReadFd(const ssiInfo *d, const coeffs)
Definition longrat.cc:3368
#define MP_SMALL
Definition longrat.cc:144
static int int_extgcd(int a, int b, int *u, int *x, int *v, int *y)
Definition longrat.cc:1411
#define SR_INT
Definition longrat.h:67
#define INT_TO_SR(INT)
Definition longrat.h:68
#define SR_TO_INT(SR)
Definition longrat.h:69
#define assume(x)
Definition mod2.h:389
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 omAlloc0Bin(bin)
#define omFree(addr)
#define omFreeBin(addr, bin)
#define NULL
Definition omList.c:12
void StringSetS(const char *st)
Definition reporter.cc:128
void StringAppendS(const char *st)
Definition reporter.cc:107
void PrintS(const char *s)
Definition reporter.cc:284
char * StringEndS()
Definition reporter.cc:151
void PrintLn()
Definition reporter.cc:310
static char * nrzCoeffName(const coeffs)
Definition rintegers.cc:25
VAR omBin gmp_nrz_bin
Definition rintegers.cc:23
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)
#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
#define SR_HDL(A)
Definition tgb.cc:35