My Project
Loading...
Searching...
No Matches
flintcf_Qrat.cc
Go to the documentation of this file.
1/****************************************
2* Computer Algebra System SINGULAR *
3****************************************/
4/*
5* ABSTRACT: flint: rational functions over Q (using fmpq_mpoly)
6*/
7#include <ctype.h> /* isdigit*/
8
9#include "misc/auxiliary.h"
10
11#include "coeffs/coeffs.h"
12
13#ifdef HAVE_FLINT
14#include "flint/flint.h"
15#if __FLINT_RELEASE >= 20503
16#include "factory/factory.h"
17
18#include "coeffs/numbers.h"
19#include "coeffs/longrat.h"
20#include "coeffs/flintcf_Qrat.h"
21#include "polys/flint_mpoly.h"
22#ifdef QA_DEBUG
23#define TRANSEXT_PRIVATES
26#endif
27
28typedef fmpq_rat_struct *fmpq_rat_ptr;
29typedef fmpq_mpoly_struct *fmpq_mpoly_ptr;
30typedef fmpq_mpoly_ctx_struct *fmpq_ctx_ptr;
31typedef fmpz *fmpz_ptr;
32typedef fmpq_rat_data_struct *data_ptr;
33
34/******************************************************************************
35* Helper functions
36******************************************************************************/
37
38/*2
39* extracts a long integer from s, returns the rest
40*/
41static char * nlEatLong(char *s, fmpz_ptr i)
42{
43 const char * start = s;
44
45 while (*s >= '0' && *s <= '9') s++;
46 if (*s == '\0')
47 {
48 fmpz_set_str(i, start, 10);
49 }
50 else
51 {
52 char c = *s;
53 *s = '\0';
54 fmpz_set_str(i, start, 10);
55 *s = c;
56 }
57 return s;
58}
59
60static void fmpq_rat_init(fmpq_rat_ptr a, const coeffs r)
61{
62 fmpq_mpoly_init(a->num, ((data_ptr)r->data)->ctx);
63 fmpq_mpoly_init(a->den, ((data_ptr)r->data)->ctx);
64}
65
66static void fmpq_rat_clear(fmpq_rat_ptr a, const coeffs r)
67{
68 fmpq_mpoly_clear(a->num, ((data_ptr)r->data)->ctx);
69 fmpq_mpoly_clear(a->den, ((data_ptr)r->data)->ctx);
70}
71
72static void fmpq_rat_canonicalise(fmpq_rat_ptr a, const coeffs /*r*/)
73{
74 fmpz_t n, d;
75 fmpz_init(n);
76 fmpz_init(d);
77 fmpz_gcd(n, fmpq_numref(a->num->content), fmpq_numref(a->den->content));
78 fmpz_lcm(d, fmpq_denref(a->num->content), fmpq_denref(a->den->content));
79 if (!fmpz_is_one(d))
80 {
81 fmpq_mul_fmpz(a->num->content, a->num->content, d);
82 fmpq_mul_fmpz(a->den->content, a->den->content, d);
83 }
84 if (!fmpz_is_one(n))
85 {
86 fmpq_div_fmpz(a->num->content, a->num->content, n);
87 fmpq_div_fmpz(a->den->content, a->den->content, n);
88 }
89 fmpz_clear(n);
90 fmpz_clear(d);
91}
92
93/******************************************************************************
94* Main interface
95******************************************************************************/
96
97static BOOLEAN CoeffIsEqual(const coeffs c, n_coeffType n, void * parameter)
98{
99 if (c->type == n)
100 {
101 const QaInfo *par=(QaInfo*)parameter;
102 if (par->N != c->iNumberOfParameters) return FALSE;
103 // compare parameter names
104 for(int i=0;i<par->N;i++)
105 {
106 if (strcmp(par->names[i],c->pParameterNames[i])!=0) return FALSE;
107 }
108 return TRUE;
109 }
110 return FALSE;
111}
112
113static number Mult(number a, number b, const coeffs c)
114{
115 n_Test(a,c);
116 n_Test(b,c);
117 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
118 fmpq_rat_init(res, c);
119 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
120 const fmpq_rat_ptr y = (fmpq_rat_ptr) b;
121 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
122 if (fmpq_mpoly_equal(x->den, y->den, ctx)) /* denominators equal */
123 {
124 fmpq_mpoly_mul(res->num, x->num, y->num, ctx);
125 fmpq_mpoly_mul(res->den, x->den, y->den, ctx);
126 }
127 else if (fmpq_mpoly_is_one(x->den, ctx)) /* first denominator 1 */
128 {
129 fmpq_mpoly_t gd;
130 fmpq_mpoly_init(gd, ctx);
131 fmpq_mpoly_gcd(gd, x->num, y->den, ctx);
132 if (fmpq_mpoly_is_one(gd, ctx))
133 {
134 fmpq_mpoly_mul(res->num, x->num, y->num, ctx);
135 fmpq_mpoly_set(res->den, y->den, ctx);
136 }
137 else
138 {
139 fmpq_mpoly_div(res->num, x->num, gd, ctx);
140 fmpq_mpoly_mul(res->num, res->num, y->num, ctx);
141 fmpq_mpoly_div(res->den, y->den, gd, ctx);
142 }
143 fmpq_mpoly_clear(gd, ctx);
144 }
145 else if (fmpq_mpoly_is_one(y->den, ctx)) /* second denominator 1 */
146 {
147 fmpq_mpoly_t gd;
148 fmpq_mpoly_init(gd, ctx);
149 fmpq_mpoly_gcd(gd, y->num, x->den, ctx);
150 if (fmpq_mpoly_is_one(gd, ctx))
151 {
152 fmpq_mpoly_mul(res->num, x->num, y->num, ctx);
153 fmpq_mpoly_set(res->den, x->den, ctx);
154 }
155 else
156 {
157 fmpq_mpoly_div(res->num, y->num, gd, ctx);
158 fmpq_mpoly_mul(res->num, res->num, x->num, ctx);
159 fmpq_mpoly_div(res->den, x->den, gd, ctx);
160 }
161 fmpq_mpoly_clear(gd, ctx);
162 }
163 else /* general case */
164 {
165 fmpq_mpoly_t g1, g2;
166 fmpq_mpoly_ptr n1, n2, d1, d2;
167 fmpq_mpoly_init(g1, ctx);
168 fmpq_mpoly_init(g2, ctx);
169 fmpq_mpoly_gcd(g1, x->num, y->den, ctx);
170 fmpq_mpoly_gcd(g2, y->num, x->den, ctx);
171 n1 = x->num; d2 = y->den;
172 d1 = x->den; n2 = y->num;
173 if (!fmpq_mpoly_is_one(g1, ctx))
174 {
175 fmpq_mpoly_div(res->num, x->num, g1, ctx);
176 fmpq_mpoly_div(g1, y->den, g1, ctx);
177 n1 = res->num; d2 = g1;
178 }
179 if (!fmpq_mpoly_is_one(g2, ctx))
180 {
181 fmpq_mpoly_div(res->den, y->num, g2, ctx);
182 fmpq_mpoly_div(g2, x->den, g2, ctx);
183 n2 = res->den; d1 = g2;
184 }
185 fmpq_mpoly_mul(res->num, n1, n2, ctx);
186 fmpq_mpoly_mul(res->den, d1, d2, ctx);
187 fmpq_mpoly_clear(g1, ctx);
188 fmpq_mpoly_clear(g2, ctx);
189 }
190 fmpq_rat_canonicalise(res, c);
191 #ifdef QA_DEBUG
192 res->p=n_Mult(x->p,y->p, ((data_ptr)c->data)->C);
193 #endif
194 n_Test((number)res, c);
195 return (number) res;
196}
197
198static number Sub(number a, number b, const coeffs c)
199{
200 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
201 fmpq_rat_init(res, c);
202 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
203 const fmpq_rat_ptr y = (fmpq_rat_ptr) b;
204 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
205 if (fmpq_mpoly_equal(x->den, y->den, ctx)) /* denominators equal */
206 {
207 fmpq_mpoly_sub(res->num, x->num, y->num, ctx);
208 if (fmpq_mpoly_is_zero(res->num, ctx))
209 {
210 fmpq_mpoly_one(res->den, ctx);
211 n_Test((number)res,c);
212 return (number)res;
213 }
214 else
215 if (fmpq_mpoly_is_one(x->den, ctx))
216 {
217 fmpq_mpoly_set(res->den, x->den, ctx);
218 n_Test((number)res,c);
219 return (number)res;
220 }
221 else
222 {
223 fmpq_mpoly_t gd;
224 fmpq_mpoly_init(gd, ctx);
225 fmpq_mpoly_gcd(gd, res->num, x->den, ctx);
226 if (fmpq_mpoly_is_one(gd, ctx))
227 {
228 fmpq_mpoly_set(res->den, x->den, ctx);
229 }
230 else
231 {
232 fmpq_mpoly_div(res->den, x->den, gd, ctx);
233 fmpq_mpoly_div(res->num, res->num, gd, ctx);
234 }
235 fmpq_mpoly_clear(gd, ctx);
236 }
237 }
238 else if (fmpq_mpoly_is_one(x->den, ctx)) /* first denominator 1 */
239 {
240 fmpq_mpoly_mul(res->num, x->num, y->den, ctx);
241 fmpq_mpoly_sub(res->num, res->num, y->num, ctx);
242 if (fmpq_mpoly_is_zero(res->num, ctx))
243 {
244 fmpq_mpoly_one(res->den, ctx);
245 n_Test((number)res,c);
246 return (number)res;
247 }
248 else
249 {
250 fmpq_mpoly_set(res->den, y->den, ctx);
251 }
252 }
253 else if (fmpq_mpoly_is_one(y->den, ctx)) /* second denominator 1 */
254 {
255 fmpq_mpoly_mul(res->num, y->num, x->den, ctx);
256 fmpq_mpoly_sub(res->num, x->num, res->num, ctx);
257 if (fmpq_mpoly_is_zero(res->num,ctx))
258 {
259 fmpq_mpoly_one(res->den, ctx);
260 n_Test((number)res,c);
261 return (number)res;
262 }
263 else
264 {
265 fmpq_mpoly_set(res->den, x->den, ctx);
266 }
267 }
268 else /* general case */
269 {
270 fmpq_mpoly_t gd;
271 fmpq_mpoly_init(gd, ctx);
272 fmpq_mpoly_gcd(gd, x->den, y->den, ctx);
273 if (fmpq_mpoly_is_one(gd, ctx))
274 {
275 fmpq_mpoly_mul(res->num, x->num, y->den, ctx);
276 fmpq_mpoly_mul(gd, y->num, x->den, ctx);
277 fmpq_mpoly_sub(res->num, res->num, gd, ctx);
278 if (fmpq_mpoly_is_zero(res->num,ctx))
279 {
280 fmpq_mpoly_one(res->den, ctx);
281 n_Test((number)res,c);
282 return (number)res;
283 }
284 else
285 {
286 fmpq_mpoly_mul(res->den, x->den, y->den, ctx);
287 }
288 }
289 else
290 {
291 fmpq_mpoly_t q2;
292 fmpq_mpoly_init(q2, ctx);
293 fmpq_mpoly_div(res->den, x->den, gd, ctx);
294 fmpq_mpoly_div(q2, y->den, gd, ctx);
295 fmpq_mpoly_mul(res->num, q2, x->num, ctx);
296 fmpq_mpoly_mul(res->den, res->den, y->num, ctx);
297 fmpq_mpoly_sub(res->num, res->num, res->den, ctx);
298 fmpq_mpoly_gcd(res->den, res->num, gd, ctx);
299 if (fmpq_mpoly_is_one(res->den, ctx))
300 {
301 fmpq_mpoly_mul(res->den, q2, x->den, ctx);
302 }
303 else
304 {
305 fmpq_mpoly_div(res->num, res->num, res->den, ctx);
306 fmpq_mpoly_div(gd, x->den, res->den, ctx);
307 fmpq_mpoly_mul(res->den, gd, q2, ctx);
308 }
309 fmpq_mpoly_clear(q2, ctx);
310 }
311 fmpq_mpoly_clear(gd, ctx);
312 }
313 #ifdef QA_DEBUG
314 res->p=n_Sub(x->p,y->p, ((data_ptr)c->data)->C);
315 #endif
316 n_Test((number)res, c);
317 return (number) res;
318}
319
320static number Add(number a, number b, const coeffs c)
321{
322 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
323 fmpq_rat_init(res, c);
324 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
325 const fmpq_rat_ptr y = (fmpq_rat_ptr) b;
326 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
327 if (fmpq_mpoly_equal(x->den, y->den, ctx)) /* denominators equal */
328 {
329 fmpq_mpoly_add(res->num, x->num, y->num, ctx);
330 if (fmpq_mpoly_is_zero(res->num, ctx))
331 {
332 fmpq_mpoly_one(res->den, ctx);
333 n_Test((number)res,c);
334 return (number)res;
335 }
336 else
337 if (fmpq_mpoly_is_one(x->den, ctx))
338 {
339 fmpq_mpoly_set(res->den, x->den, ctx);
340 n_Test((number)res,c);
341 return (number)res;
342 }
343 else
344 {
345 fmpq_mpoly_t gd;
346 fmpq_mpoly_init(gd, ctx);
347 fmpq_mpoly_gcd(gd, res->num, x->den, ctx);
348 if (fmpq_mpoly_is_one(gd, ctx))
349 {
350 fmpq_mpoly_set(res->den, x->den, ctx);
351 }
352 else
353 {
354 fmpq_mpoly_div(res->den, x->den, gd, ctx);
355 fmpq_mpoly_div(res->num, res->num, gd, ctx);
356 }
357 fmpq_mpoly_clear(gd, ctx);
358 }
359 }
360 else if (fmpq_mpoly_is_one(x->den, ctx)) /* first denominator 1 */
361 {
362 fmpq_mpoly_mul(res->num, x->num, y->den, ctx);
363 fmpq_mpoly_add(res->num, res->num, y->num, ctx);
364 if (fmpq_mpoly_is_zero(res->num, ctx))
365 {
366 fmpq_mpoly_one(res->den, ctx);
367 n_Test((number)res,c);
368 return (number)res;
369 }
370 else
371 {
372 fmpq_mpoly_set(res->den, y->den, ctx);
373 }
374 }
375 else if (fmpq_mpoly_is_one(y->den, ctx)) /* second denominator 1 */
376 {
377 fmpq_mpoly_mul(res->num, y->num, x->den, ctx);
378 fmpq_mpoly_add(res->num, x->num, res->num, ctx);
379 if (fmpq_mpoly_is_zero(res->num, ctx))
380 {
381 fmpq_mpoly_one(res->den, ctx);
382 n_Test((number)res,c);
383 return (number)res;
384 }
385 else
386 {
387 fmpq_mpoly_set(res->den, x->den, ctx);
388 }
389 }
390 else /* general case */
391 {
392 fmpq_mpoly_t gd;
393 fmpq_mpoly_init(gd, ctx);
394 fmpq_mpoly_gcd(gd, x->den, y->den, ctx);
395 if (fmpq_mpoly_is_one(gd, ctx))
396 {
397 fmpq_mpoly_mul(res->num, x->num, y->den, ctx);
398 fmpq_mpoly_mul(gd, y->num, x->den, ctx);
399 fmpq_mpoly_add(res->num, res->num, gd, ctx);
400 if (fmpq_mpoly_is_zero(res->num,ctx))
401 {
402 fmpq_mpoly_one(res->den, ctx);
403 n_Test((number)res,c);
404 return (number)res;
405 }
406 else
407 {
408 fmpq_mpoly_mul(res->den, x->den, y->den, ctx);
409 }
410 }
411 else
412 {
413 fmpq_mpoly_t q2;
414 fmpq_mpoly_init(q2, ctx);
415 fmpq_mpoly_div(res->den, x->den, gd, ctx);
416 fmpq_mpoly_div(q2, y->den, gd, ctx);
417 fmpq_mpoly_mul(res->num, q2, x->num, ctx);
418 fmpq_mpoly_mul(res->den, res->den, y->num, ctx);
419 fmpq_mpoly_add(res->num, res->num, res->den, ctx);
420 fmpq_mpoly_gcd(res->den, res->num, gd, ctx);
421 if (fmpq_mpoly_is_one(res->den, ctx))
422 {
423 fmpq_mpoly_mul(res->den, q2, x->den, ctx);
424 }
425 else
426 {
427 fmpq_mpoly_div(res->num, res->num, res->den, ctx);
428 fmpq_mpoly_div(gd, x->den, res->den, ctx);
429 fmpq_mpoly_mul(res->den, gd, q2, ctx);
430 }
431 fmpq_mpoly_clear(q2, ctx);
432 }
433 fmpq_mpoly_clear(gd, ctx);
434 }
435 #ifdef QA_DEBUG
436 res->p=n_Add(x->p,y->p, ((data_ptr)c->data)->C);
437 #endif
438 n_Test((number)res, c);
439 return (number) res;
440}
441
442static number Div(number a, number b, const coeffs c)
443{
444 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
445 const fmpq_rat_ptr y = (fmpq_rat_ptr) b;
446 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
447 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
448 fmpq_rat_init(res, c);
449 if (fmpq_mpoly_is_zero(y->num, ctx))
450 {
452 return (number)res;
453 }
454 if (fmpq_mpoly_equal(x->den, y->num, ctx)) /* denominators equal */
455 {
456 fmpq_mpoly_mul(res->num, x->num, y->den, ctx);
457 fmpq_mpoly_mul(res->den, x->den, y->num, ctx);
458 }
459 else if (fmpq_mpoly_is_one(x->den, ctx)) /* first denominator 1 */
460 {
461 fmpq_mpoly_t gd;
462 fmpq_mpoly_init(gd, ctx);
463 fmpq_mpoly_gcd(gd, x->num, y->num, ctx);
464 if (fmpq_mpoly_is_one(gd, ctx))
465 {
466 fmpq_mpoly_mul(res->num, x->num, y->den, ctx);
467 fmpq_mpoly_set(res->den, y->num, ctx);
468 }
469 else
470 {
471 fmpq_mpoly_div(res->num, x->num, gd, ctx);
472 fmpq_mpoly_mul(res->num, res->num, y->den, ctx);
473 fmpq_mpoly_div(res->den, y->num, gd, ctx);
474 }
475 fmpq_mpoly_clear(gd, ctx);
476 }
477 else if (fmpq_mpoly_is_one(y->num, ctx)) /* second denominator 1 */
478 {
479 fmpq_mpoly_t gd;
480 fmpq_mpoly_init(gd, ctx);
481 fmpq_mpoly_gcd(gd, y->den, x->den, ctx);
482 if (fmpq_mpoly_is_one(gd, ctx))
483 {
484 fmpq_mpoly_mul(res->num, y->den, x->num, ctx);
485 fmpq_mpoly_set(res->den, x->den, ctx);
486 }
487 else
488 {
489 fmpq_mpoly_div(res->num, y->den, gd, ctx);
490 fmpq_mpoly_mul(res->num, res->num, x->num, ctx);
491 fmpq_mpoly_div(res->den, x->den, gd, ctx);
492 }
493 fmpq_mpoly_clear(gd, ctx);
494 }
495 else /* general case */
496 {
497 fmpq_mpoly_t g1, g2;
498 fmpq_mpoly_ptr n1, n2, d1, d2;
499 fmpq_mpoly_init(g1, ctx);
500 fmpq_mpoly_init(g2, ctx);
501 fmpq_mpoly_gcd(g1, x->num, y->num, ctx);
502 fmpq_mpoly_gcd(g2, y->den, x->den, ctx);
503 n1 = x->num; d2 = y->num;
504 d1 = x->den; n2 = y->den;
505 if (!fmpq_mpoly_is_one(g1, ctx))
506 {
507 fmpq_mpoly_div(res->num, x->num, g1, ctx);
508 fmpq_mpoly_div(g1, y->num, g1, ctx);
509 n1 = res->num; d2 = g1;
510 }
511 if (!fmpq_mpoly_is_one(g2, ctx))
512 {
513 fmpq_mpoly_div(res->den, y->den, g2, ctx);
514 fmpq_mpoly_div(g2, x->den, g2, ctx);
515 n2 = res->den; d1 = g2;
516 }
517 fmpq_mpoly_mul(res->num, n1, n2, ctx);
518 fmpq_mpoly_mul(res->den, d1, d2, ctx);
519 fmpq_mpoly_clear(g1, ctx);
520 fmpq_mpoly_clear(g2, ctx);
521 }
522 fmpq_rat_canonicalise(res, c);
523 #ifdef QA_DEBUG
524 res->p=n_Div(x->p,y->p, ((data_ptr)c->data)->C);
525 #endif
526 n_Test((number)res, c);
527 return (number) res;
528}
529
530static number ExactDiv(number a, number b, const coeffs c)
531{
532 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
533 const fmpq_rat_ptr y = (fmpq_rat_ptr) b;
534 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
535 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
536 fmpq_rat_init(res, c);
537 if (fmpq_mpoly_is_zero(y->num, ctx))
538 {
540 return (number)res;
541 }
542 fmpq_mpoly_div(res->num, x->num, y->num, ctx);
543 assume(fmpq_mpoly_is_one(x->den, ctx));
544 assume(fmpq_mpoly_is_one(y->den, ctx));
545 #ifdef QA_DEBUG
546 res->p=n_ExactDiv(x->p,y->p, ((data_ptr)c->data)->C);
547 #endif
548 n_Test((number)res,c);
549 return (number) res;
550}
551
552// static number IntMod(number a, number b, const coeffs c);
553// {
554// }
555
556static number Init(long i, const coeffs c)
557{
558 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
559 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
560 fmpq_rat_init(res, c);
561 fmpq_mpoly_set_si(res->num, (slong) i, ctx);
562 fmpq_mpoly_set_si(res->den, (slong) 1, ctx);
563 #ifdef QA_DEBUG
564 res->p=n_Init(i, ((data_ptr)c->data)->C);
565 #endif
566 n_Test((number)res,c);
567 return (number) res;
568}
569
570static number InitMPZ(mpz_t i, const coeffs c)
571{
572 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
573 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
574 fmpz_t t;
575 fmpz_init(t);
576 fmpz_set_mpz(t, i);
577 fmpq_rat_init(res, c);
578 fmpq_mpoly_set_fmpz(res->num, t, ctx);
579 fmpq_mpoly_set_si(res->den, (slong) 1, ctx);
580 fmpz_clear(t);
581 #ifdef QA_DEBUG
582 res->p=n_InitMPZ(i, ((data_ptr)c->data)->C);
583 #endif
584 n_Test((number)res,c);
585 return (number) res;
586}
587
588static int Size(number n, const coeffs c)
589{
590 const fmpq_rat_ptr x = (fmpq_rat_ptr) n;
591 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
592 if (fmpq_mpoly_is_zero(x->num, ctx))
593 return 0;
594 unsigned long len=fmpq_mpoly_length(x->num, ctx) +
595 fmpq_mpoly_length(x->den, ctx)-fmpq_mpoly_is_one(x->den, ctx);
596 unsigned long numDegree=fmpq_mpoly_total_degree_si(x->num, ctx);
597 unsigned long denDegree=fmpq_mpoly_total_degree_si(x->den, ctx);
598 unsigned long t= ((numDegree + denDegree)*(numDegree + denDegree) + 1) * len;
599 if (t>INT_MAX) return INT_MAX;
600 else return (int)t;
601}
602
603static long Int(number &n, const coeffs c)
604{
605 const fmpq_rat_ptr x = (fmpq_rat_ptr) n;
606 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
607 if (fmpq_mpoly_is_fmpq(x->den, ctx) && fmpq_mpoly_is_fmpq(x->num, ctx))
608 {
609 long nl = 0;
610 fmpq_t r;
611 fmpq_init(r);
612 fmpq_div(r, x->num->content, x->den->content);
613 if (fmpz_is_one(fmpq_denref(r)))
614 {
615 if (fmpz_fits_si(fmpq_numref(r)))
616 nl = fmpz_get_si(fmpq_numref(r));
617 }
618 fmpq_clear(r);
619 return nl;
620 }
621 return 0;
622}
623
624static void MPZ(mpz_t result, number &n, const coeffs c)
625{
626 mpz_init(result);
627 const fmpq_rat_ptr x = (fmpq_rat_ptr) n;
628 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
629 if (fmpq_mpoly_is_fmpq(x->den, ctx) && fmpq_mpoly_is_fmpq(x->num, ctx))
630 {
631 fmpq_t r;
632 fmpq_init(r);
633 fmpq_div(r, x->num->content, x->den->content);
634 if (fmpz_is_one(fmpq_denref(r)))
635 {
636 fmpz_get_mpz(result, fmpq_numref(r));
637 }
638 fmpq_clear(r);
639 }
640}
641
642static number Neg(number a, const coeffs c)
643{
644 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
645 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
646 fmpq_mpoly_neg(x->num, x->num, ctx);
647 #ifdef QA_DEBUG
648 x->p=n_InpNeg(x->p, ((data_ptr)c->data)->C);
649 #endif
650 n_Test((number)a, c);
651 return a;
652}
653
654static number Invers(number a, const coeffs c)
655{
656 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
657 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
658 if (fmpq_mpoly_is_zero(x->num, ctx))
659 {
661 return NULL;
662 }
663 else
664 {
665 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
666 fmpq_rat_init(res, c);
667 fmpq_mpoly_set(res->num, x->den, ctx);
668 fmpq_mpoly_set(res->den, x->num, ctx);
669 #ifdef QA_DEBUG
670 res->p=n_Invers(x->p, ((data_ptr)c->data)->C);
671 #endif
672 n_Test((number)res, c);
673 return (number) res;
674 }
675}
676
677static number Copy(number a, const coeffs c)
678{
679 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
680 fmpq_rat_init(res, c);
681 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
682 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
683 fmpq_mpoly_set(res->num, x->num, ctx);
684 fmpq_mpoly_set(res->den, x->den, ctx);
685 #ifdef QA_DEBUG
686 res->p=n_Copy(x->p, ((data_ptr)c->data)->C);
687 #endif
688 n_Test((number)res, c);
689 return (number) res;
690}
691
692//static number RePart(number a, const coeffs c)
693//{
694//}
695
696//static number ImPart(number a, const coeffs c)
697//{
698//}
699
700static BOOLEAN IsOne(number a, const coeffs c)
701{
702 if (a==NULL) return FALSE;
703 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
704 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
705 if (!fmpq_mpoly_is_fmpq(x->num, ctx))
706 return FALSE;
707 if (!fmpq_mpoly_is_fmpq(x->den, ctx))
708 return FALSE;
709 return fmpq_equal(x->num->content, x->den->content);
710}
711
712static BOOLEAN IsZero(number a, const coeffs c)
713{
714 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
715 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
716 return fmpq_mpoly_is_zero(x->num, ctx);
717}
718
719static void WriteLong(number a, const coeffs c)
720{
721 if (a==NULL)
722 {
723 StringAppendS("o");
724 return;
725 }
726 n_Test(a,c);
727 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
728 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
729 if (fmpq_mpoly_is_zero(x->den, ctx))
730 {
731 StringAppendS("?/o");
732 return;
733 }
734 fmpz_t t;
735 long int i, j, k, nmax_i, dmax_i, max_digits;
736 fmpq_rat_canonicalise(x, c);
737 if (fmpq_mpoly_is_zero(x->num, ctx))
738 StringAppendS("0");
739 else
740 {
741 BOOLEAN num_is_const = fmpq_mpoly_is_fmpq(x->num, ctx);
742 BOOLEAN den_is_const = fmpq_mpoly_is_fmpq(x->den, ctx);
743 BOOLEAN need_times;
744 fmpq_mpoly_struct * znum = x->num;
745 fmpq_mpoly_struct * zden = x->den;
746 slong nvars = fmpq_mpoly_ctx_nvars(ctx);
747 fmpz_init(t);
748 nmax_i = 0;
749 dmax_i = 0;
750 for (i = 1; i < fmpq_mpoly_length(znum, ctx); i++)
751 {
752 if (fmpz_cmpabs(fmpq_mpoly_zpoly_term_coeff_ref(znum, i, ctx),
753 fmpq_mpoly_zpoly_term_coeff_ref(znum, nmax_i, ctx)) > 0)
754 {
755 nmax_i = i;
756 }
757 }
758 for (i = 1; i < fmpq_mpoly_length(zden, ctx); i++)
759 {
760 if (fmpz_cmpabs(fmpq_mpoly_zpoly_term_coeff_ref(zden, i, ctx),
761 fmpq_mpoly_zpoly_term_coeff_ref(zden, dmax_i, ctx)) > 0)
762 {
763 dmax_i = i;
764 }
765 }
766 if (fmpz_cmpabs(fmpq_mpoly_zpoly_term_coeff_ref(znum, nmax_i, ctx),
767 fmpq_mpoly_zpoly_term_coeff_ref(zden, dmax_i, ctx)) > 0)
768 {
769 fmpz_mul(t, fmpq_numref(x->num->content),
770 fmpq_mpoly_zpoly_term_coeff_ref(znum, nmax_i, ctx));
771 max_digits = fmpz_sizeinbase(t, 10);
772 }
773 else
774 {
775 fmpz_mul(t, fmpq_numref(x->den->content),
776 fmpq_mpoly_zpoly_term_coeff_ref(zden, dmax_i, ctx));
777 max_digits =fmpz_sizeinbase(t, 10);
778 }
779 char *s = (char*) omAlloc(max_digits + 5);
780 if (!num_is_const)
781 StringAppendS("(");
782 if (fmpq_mpoly_is_one(x->num, ctx))
783 StringAppendS("1");
784 else
785 {
786 for (i = 0; i < fmpq_mpoly_length(x->num, ctx); i++)
787 {
788 need_times = TRUE;
789 fmpz_mul(t, fmpq_mpoly_zpoly_term_coeff_ref(znum, i, ctx),
790 fmpq_numref(x->num->content));
791 if (i != 0 && fmpz_sgn(t) > 0)
792 StringAppendS("+");
793 BOOLEAN need_1=FALSE;
794 if (!fmpz_is_one(t))
795 {
796 fmpz_get_str(s, 10, t);
797 {
798 int l=strlen(s);
799 while((l>0)&&(!isdigit(s[l]))) l--;
800 s[l+1]='\0';
801 }
802 if (strcmp(s,"-1")==0)
803 {
804 StringAppendS("-");
805 need_1 = TRUE;
806 need_times = FALSE;
807 }
808 else
810 }
811 else
812 {
813 need_1 = TRUE;
814 need_times = FALSE;
815 }
816 for (j = 0; j < c->iNumberOfParameters; j++)
817 {
818 k = fmpq_mpoly_get_term_var_exp_ui(x->num, i, j, ctx);
819 if (k != 0)
820 {
821 need_1 = FALSE;
822 if (need_times)
823 StringAppendS("*");
824 if (k != 1)
825 StringAppend("%s^%d", c->pParameterNames[j], k);
826 else
827 StringAppendS(c->pParameterNames[j]);
828 need_times = TRUE;
829 }
830 }
831 if (need_1) StringAppendS("1");
832 }
833 }
834 if (!num_is_const)
835 StringAppendS(")");
836 if (!fmpq_mpoly_is_one(x->den, ctx))
837 {
838 BOOLEAN closing_paren=FALSE;
839 StringAppendS("/");
840 if (!den_is_const)
841 {
842 StringAppendS("(");
843 closing_paren = TRUE;
844 }
845 for (i = 0; i < fmpq_mpoly_length(x->den, ctx); i++)
846 {
847 need_times = TRUE;
848 fmpz_mul(t, fmpq_mpoly_zpoly_term_coeff_ref(zden, i, ctx),
849 fmpq_numref(x->den->content));
850 if (i == 0)
851 {
852 if ((fmpz_sgn(t) < 0) && den_is_const)
853 {
854 StringAppendS("(");
855 closing_paren = TRUE;
856 }
857 }
858 else if (fmpz_sgn(t) > 0)
859 StringAppendS("+");
860 if (!fmpz_is_one(t))
861 {
862 fmpz_get_str(s, 10, t);
863 {
864 int l=strlen(s);
865 while((l>0)&&(!isdigit(s[l]))) l--;
866 s[l+1]='\0';
867 }
869 }
870 else
871 {
872 need_times = FALSE;
873 }
874 for (j = 0; j < nvars; j++)
875 {
876 k = fmpq_mpoly_get_term_var_exp_ui(x->den, i, j, ctx);
877 if (k != 0)
878 {
879 if (need_times)
880 StringAppendS("*");
881 if (k != 1)
882 StringAppend("%s^%d", c->pParameterNames[j], k);
883 else
884 StringAppendS(c->pParameterNames[j]);
885 need_times = TRUE;
886 }
887 }
888 }
889 if (closing_paren)
890 StringAppendS(")");
891 }
892 fmpz_clear(t);
893 omFree(s);
894 }
895}
896
897static void WriteShort(number a, const coeffs c)
898{
899 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
900 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
901 fmpz_t t;
902 char *s;
903 long int i, j, k, nmax_i, dmax_i, max_digits;
904 fmpq_rat_canonicalise(x, c);
905 if (fmpq_mpoly_is_zero(x->num, ctx))
906 StringAppendS("0");
907 else
908 {
909 BOOLEAN num_is_const = fmpq_mpoly_is_fmpq(x->num, ctx);
910 BOOLEAN den_is_const = fmpq_mpoly_is_fmpq(x->den, ctx);
911 fmpq_mpoly_struct * znum = x->num;
912 fmpq_mpoly_struct * zden = x->den;
913 slong nvars = fmpq_mpoly_ctx_nvars(ctx);
914 fmpz_init(t);
915 nmax_i = 0;
916 dmax_i = 0;
917 for (i = 1; i < fmpq_mpoly_length(znum, ctx); i++)
918 {
919 if (fmpz_cmpabs(fmpq_mpoly_zpoly_term_coeff_ref(znum, i, ctx),
920 fmpq_mpoly_zpoly_term_coeff_ref(znum, nmax_i, ctx)) > 0)
921 {
922 nmax_i = i;
923 }
924 }
925 for (i = 1; i < fmpq_mpoly_length(zden, ctx); i++)
926 {
927 if (fmpz_cmpabs(fmpq_mpoly_zpoly_term_coeff_ref(zden, i, ctx),
928 fmpq_mpoly_zpoly_term_coeff_ref(zden, dmax_i, ctx)) > 0)
929 {
930 dmax_i = i;
931 }
932 }
933 if (fmpz_cmpabs(fmpq_mpoly_zpoly_term_coeff_ref(znum, nmax_i, ctx),
934 fmpq_mpoly_zpoly_term_coeff_ref(zden, dmax_i, ctx)) > 0)
935 {
936 fmpz_mul(t, fmpq_numref(x->num->content),
937 fmpq_mpoly_zpoly_term_coeff_ref(znum, nmax_i, ctx));
938 max_digits = fmpz_sizeinbase(t, 10);
939 } else
940 {
941 fmpz_mul(t, fmpq_numref(x->den->content),
942 fmpq_mpoly_zpoly_term_coeff_ref(zden, dmax_i, ctx));
943 max_digits = fmpz_sizeinbase(t, 10);
944 }
945 s = (char*) omAlloc(max_digits + 2);
946 if (!num_is_const)
947 StringAppendS("(");
948 if (fmpq_mpoly_is_one(x->num, ctx))
949 StringAppendS("1");
950 else
951 {
952 for (i = 0; i < fmpq_mpoly_length(x->num, ctx); i++)
953 {
954 fmpz_mul(t, fmpq_mpoly_zpoly_term_coeff_ref(znum, i, ctx),
955 fmpq_numref(x->num->content));
956 if (i != 0 && fmpz_sgn(t) > 0)
957 StringAppendS("+");
958 if (!fmpz_is_one(t))
959 {
960 fmpz_get_str(s, 10, t);
962 }
963 for (j = 0; j < nvars; j++)
964 {
965 k = fmpq_mpoly_get_term_var_exp_ui(x->num, i, j, ctx);
966 if (k != 0)
967 {
968 if (k != 1)
969 StringAppend("%s%d", c->pParameterNames[j], k);
970 else
971 StringAppendS(c->pParameterNames[j]);
972 }
973 }
974 }
975 }
976 if (!num_is_const)
977 StringAppendS(")");
978 if (!fmpq_mpoly_is_one(x->den, ctx))
979 {
980 StringAppendS("/");
981 if (!den_is_const)
982 StringAppendS("(");
983 for (i = 0; i < fmpq_mpoly_length(x->den, ctx); i++)
984 {
985 fmpz_mul(t, fmpq_mpoly_zpoly_term_coeff_ref(zden, i, ctx),
986 fmpq_numref(x->den->content));
987 if (i != 0 && fmpz_sgn(t) > 0)
988 StringAppendS("+");
989 if (!fmpz_is_one(t))
990 {
991 fmpz_get_str(s, 10, t);
993 }
994 for (j = 0; j < nvars; j++)
995 {
996 k = fmpq_mpoly_get_term_var_exp_ui(x->num, i, j, ctx);
997 if (k != 0)
998 {
999 if (k != 1)
1000 StringAppend("%s%d", c->pParameterNames[j], k);
1001 else
1002 StringAppendS(c->pParameterNames[j]);
1003 }
1004 }
1005 }
1006 if (!den_is_const)
1007 StringAppendS(")");
1008 }
1009 fmpz_clear(t);
1010 }
1011}
1012
1013static const char* Read(const char * st, number * a, const coeffs c)
1014{
1015 // we only read "monomials" (i.e. [-][digits][parameter]),
1016 // everything else (+,*,^,()) is left to the singular interpreter
1017 long int j;
1018 char *s = (char *) st;
1019 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
1020 slong nvars = fmpq_mpoly_ctx_nvars(ctx);
1021 *a = (number) omAlloc(sizeof(fmpq_rat_struct));
1022 fmpq_rat_init((fmpq_rat_ptr)(*a), c);
1023 BOOLEAN neg = FALSE;
1024 if (*s=='-')
1025 {
1026 neg = TRUE;
1027 s++;
1028 }
1029 if (isdigit(*s))
1030 {
1031 fmpz_t z;
1032 fmpz_init(z);
1033 s = nlEatLong((char *) s, z);
1034 fmpq_mpoly_set_fmpz(((fmpq_rat_ptr)(*a))->num, z, ctx);
1035 fmpq_mpoly_one(((fmpq_rat_ptr)(*a))->den, ctx);
1036 if (*s == '/')
1037 {
1038 s++;
1039 s = nlEatLong((char *) s, z);
1040 fmpq_mpoly_scalar_div_fmpz(((fmpq_rat_ptr)(*a))->num,
1041 ((fmpq_rat_ptr)(*a))->num, z, ctx);
1042 }
1043 fmpz_clear(z);
1044 }
1045 else
1046 {
1048 for (j = 0; j < nvars; j++)
1049 {
1050 if (strncmp(s, c->pParameterNames[j],
1051 strlen(c->pParameterNames[j])) == 0)
1052 {
1053 found=TRUE;
1054 fmpq_mpoly_gen(((fmpq_rat_ptr)(*a))->num, j, ctx);
1055 s += strlen(c->pParameterNames[j]);
1056 if (isdigit(*s))
1057 {
1058 int i = 1;
1059 s = nEati(s, &i, 0);
1060 if (i != 1)
1061 {
1062 fmpq_mpoly_pow_ui(((fmpq_rat_ptr)(*a))->num,
1063 ((fmpq_rat_ptr)(*a))->num, (long int) i, ctx);
1064 }
1065 }
1066 }
1067 }
1068 if (!found) fmpq_mpoly_one(((fmpq_rat_ptr)(*a))->num, ctx);
1069 fmpq_mpoly_one(((fmpq_rat_ptr)(*a))->den, ctx);
1070 }
1071 if (neg)
1072 fmpq_mpoly_neg(((fmpq_rat_ptr)(*a))->num, ((fmpq_rat_ptr)(*a))->num, ctx);
1073 #ifdef QA_DEBUG
1074 poly pp=convFlintMPSingP(((fmpq_rat_ptr)(*a))->num,ctx,((data_ptr)c->data)->C->extRing);
1075 fraction f=(fraction)n_Init(1,((data_ptr)c->data)->C); /*leak*/
1076 NUM(f)=pp;
1077 ((fmpq_rat_ptr)(*a))->p=(number)f;
1078 #endif
1079 n_Test((*a),c);
1080 return s;
1081}
1082
1083static BOOLEAN Greater(number a, number b, const coeffs c)
1084{
1085 return Size(a, c) > Size(b, c);
1086}
1087
1088static void Delete(number * a, const coeffs c)
1089{
1090 if ((*a) != NULL)
1091 {
1092 const fmpq_rat_ptr x = (fmpq_rat_ptr) *a;
1093 fmpq_rat_clear(x, c);
1094 #ifdef QA_DEBUG
1095 n_Delete(&(x->p),((data_ptr)c->data)->C);
1096 #endif
1097 omFree(*a);
1098 *a = NULL;
1099 }
1100}
1101
1102static BOOLEAN Equal(number a, number b, const coeffs c)
1103{
1104 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
1105 const fmpq_rat_ptr y = (fmpq_rat_ptr) b;
1106 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
1107 if (!fmpz_mpoly_equal(x->num->zpoly, y->num->zpoly, ctx->zctx))
1108 {
1109 return FALSE;
1110 }
1111 if (!fmpz_mpoly_equal(x->den->zpoly, y->den->zpoly, ctx->zctx))
1112 {
1113 return FALSE;
1114 }
1115 fmpz_t t1, t2;
1116 fmpz_init(t1);
1117 fmpz_init(t2);
1118 fmpz_mul(t1, fmpq_numref(x->num->content), fmpq_denref(x->den->content));
1119 fmpz_mul(t1, t1, fmpq_denref(y->num->content));
1120 fmpz_mul(t1, t1, fmpq_numref(y->den->content));
1121 fmpz_mul(t2, fmpq_numref(y->num->content), fmpq_denref(y->den->content));
1122 fmpz_mul(t2, t2, fmpq_denref(x->num->content));
1123 fmpz_mul(t2, t2, fmpq_numref(x->den->content));
1124 int eq = fmpz_equal(t1, t2);
1125 fmpz_clear(t1);
1126 fmpz_clear(t2);
1127 return eq;
1128}
1129
1130static BOOLEAN IsMOne(number a, const coeffs c)
1131{
1132 if (a==NULL) return FALSE;
1133 fmpq_t content;
1134 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
1135 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
1136 if (!fmpq_mpoly_is_fmpq(x->num, ctx))
1137 return FALSE;
1138 if (!fmpq_mpoly_is_fmpq(x->den, ctx))
1139 return FALSE;
1140 fmpq_init(content);
1141 fmpq_neg(content, x->num->content);
1142 int eq = fmpq_equal(content, x->den->content);
1143 fmpq_clear(content);
1144 return eq;
1145}
1146
1147static BOOLEAN GreaterZero(number, const coeffs)
1148{
1149 return TRUE; /* everything in parens for now so need + sign */
1150}
1151
1152static void Power(number a, int i, number * result, const coeffs c)
1153{
1154 *result= (number) omAlloc(sizeof(fmpq_rat_struct));
1155 fmpq_rat_init((fmpq_rat_ptr) (*result), c);
1156 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
1157 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
1158 fmpq_mpoly_pow_ui(((fmpq_rat_ptr)(*result))->num, x->num, (slong) i, ctx);
1159 fmpq_mpoly_pow_ui(((fmpq_rat_ptr)(*result))->den, x->den, (slong) i, ctx);
1160}
1161
1162static number GetDenom(number &n, const coeffs c)
1163{
1164 const fmpq_rat_ptr x = (fmpq_rat_ptr) n;
1165 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
1166 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
1167 fmpq_rat_init(res, c);
1168 fmpq_mpoly_set(res->num, x->den, ctx);
1169 fmpq_mpoly_one(res->den, ctx);
1170 return (number) res;
1171}
1172
1173static number GetNumerator(number &n, const coeffs c)
1174{
1175 const fmpq_rat_ptr x = (fmpq_rat_ptr) n;
1176 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
1177 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
1178 fmpq_rat_init(res, c);
1179 fmpq_mpoly_set(res->num, x->num, ctx);
1180 fmpq_mpoly_one(res->den, ctx);
1181 return (number) res;
1182}
1183
1184static number ExtGcd(number /*a*/, number /*b*/, number* /*s*/, number* /*t*/, const coeffs /*c*/)
1185{
1186 WerrorS("not a Euclidean ring: ExtGcd");
1187 return NULL;
1188}
1189
1190static number Lcm(number /*a*/, number /*b*/, const coeffs /*c*/)
1191{
1192 WerrorS("not yet: Lcm");
1193 return NULL;
1194}
1195
1196static number Q2Frac(number a, const coeffs /*src*/, const coeffs dst)
1197{
1198 number res;
1199 if (SR_HDL(a) & SR_INT)
1200 {
1201 res=Init(SR_TO_INT(a),dst);
1202 n_Test(res,dst);
1203 }
1204 else if (a->s==3)
1205 {
1206 res=InitMPZ(a->z,dst);
1207 n_Test(res,dst);
1208 }
1209 else
1210 {
1211 number z=InitMPZ(a->z,dst);
1212 number n=InitMPZ(a->n,dst);
1213 res=Div(z,n,dst);
1214 Delete(&z,dst);
1215 Delete(&n,dst);
1216 n_Test(res,dst);
1217 return res;
1218 }
1219 return res;
1220}
1221
1222static number Z2Frac(number a, const coeffs /*src*/, const coeffs dst)
1223{
1224 return InitMPZ((mpz_ptr)a,dst);
1225}
1226
1227static number Zp2Frac(number a, const coeffs src, const coeffs dst)
1228{
1229 return Init(n_Int(a,src),dst);
1230}
1231
1232static nMapFunc SetMap(const coeffs src, const coeffs dst)
1233{
1234 if (src == dst) return ndCopyMap;
1235 if (nCoeff_is_Q_or_BI(src) && (src->rep==n_rep_gap_rat)) /*Q, coeffs_BIGINT */
1236 return Q2Frac;
1237 if(src->rep==n_rep_gap_gmp) /*Z */
1238 return Z2Frac;
1239 if(nCoeff_is_Zp(src))
1240 return Zp2Frac;
1241
1242 return NULL;
1243}
1244
1245//static void InpMult(number &a, number b, const coeffs c)
1246//{
1247//}
1248
1249//static void InpAdd(number &a, number b, const coeffs c)
1250//{
1251//}
1252
1253#if 0
1254static number Init_bigint(number i, const coeffs dummy, const coeffs dst)
1255{
1256 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)(dst->data))->ctx;
1257 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
1258 fmpz_t f;
1259 fmpq_rat_init(res, dst);
1260 if (SR_HDL(i) & SR_INT)
1261 {
1262 fmpq_mpoly_set_si(res->num, SR_TO_INT(i), ctx);
1263 }
1264 else
1265 {
1266 fmpz_init(f);
1267 fmpz_set_mpz(f, i->z);
1268 fmpq_mpoly_set_fmpz(res->num, f, ctx);
1269 fmpz_clear(f);
1270 }
1271 fmpq_mpoly_set_si(res->den, 1, ctx);
1272 return (number) res;
1273}
1274#endif
1275
1276#if 0
1277static number Farey(number p, number n, const coeffs c)
1278{
1279 WerrorS("not yet: Farey");
1280 return NULL;
1281}
1282#endif
1283
1284#if 0
1285static number ChineseRemainder(number *x, number *q, int rl,
1286 BOOLEAN sym, CFArray &inv_cache, const coeffs c)
1287{
1288 WerrorS("not yet: ChineseRemainder");
1289 return NULL;
1290}
1291#endif
1292
1293static int ParDeg(number a, const coeffs c)
1294{
1295 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
1296 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
1297 return (int) (fmpq_mpoly_total_degree_si(x->num, ctx) -
1298 fmpq_mpoly_total_degree_si(x->den, ctx));
1299}
1300
1301static number Parameter(const int i, const coeffs c)
1302{
1303 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
1304 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
1305 fmpq_rat_init(res, c);
1306 fmpq_mpoly_gen(res->num, (slong) i, ctx);
1307 fmpq_mpoly_one(res->den, ctx);
1308 return (number) res;
1309}
1310
1311static number SubringGcd(number a, number b, const coeffs c)
1312{
1313 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
1314 fmpq_rat_init(res, c);
1315 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
1316 const fmpq_rat_ptr y = (fmpq_rat_ptr) b;
1317 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
1318 fmpq_mpoly_gcd(res->num, x->num, y->num, ctx);
1319 // handle content:
1320 fmpz_t cont;
1321 fmpz_init(cont);
1322 fmpz_gcd(cont, fmpq_numref(x->num->content), fmpq_numref(y->num->content));
1323 if (!fmpz_is_one(cont))
1324 {
1325 fmpq_mul_fmpz(res->num->content, res->num->content, cont);
1326 }
1327 fmpz_gcd(cont, fmpq_denref(x->num->content), fmpq_denref(y->num->content));
1328 if (!fmpz_is_one(cont))
1329 {
1330 fmpq_div_fmpz(res->num->content, res->num->content, cont);
1331 }
1332 fmpz_clear(cont);
1333 fmpq_mpoly_one(res->den, ctx);
1334 fmpq_rat_canonicalise(res, c);
1335 #ifdef QA_DEBUG
1336 res->p=n_SubringGcd(x->p,y->p, ((data_ptr)c->data)->C);
1337 #endif
1338 n_Test((number)res, c);
1339 return (number) res;
1340}
1341
1342static number NormalizeHelper(number a, number b, const coeffs c)
1343{
1344 fmpq_rat_ptr res = (fmpq_rat_ptr) omAlloc(sizeof(fmpq_rat_struct));
1345 fmpq_rat_init(res, c);
1346 const fmpq_rat_ptr x = (fmpq_rat_ptr) a;
1347 const fmpq_rat_ptr y = (fmpq_rat_ptr) b;
1348 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
1349 fmpq_mpoly_t gd;
1350 fmpq_mpoly_init(gd,ctx);
1351 fmpq_mpoly_one(gd,ctx); // value for gd, if fmpq_mpoly_gcd fails
1352 fmpq_mpoly_gcd(gd, x->num, y->den, ctx);
1353 fmpq_mpoly_mul(res->num, x->num, y->den, ctx);
1354 if (!fmpq_mpoly_is_one(gd, ctx))// &&(!fmpq_mpoly_is_zero(gd, ctx)))
1355 fmpq_mpoly_div(res->num, res->num, gd, ctx);
1356 fmpq_mpoly_one(res->den, ctx);
1357 #ifdef QA_DEBUG
1358 res->p=n_NormalizeHelper(x->p,y->p, ((data_ptr)c->data)->C);
1359 #endif
1360 n_Test((number)res, c);
1361 return (number) res;
1362}
1363
1364#if 0
1365static void WriteFd(number a, const ssiInfo *d, const coeffs c)
1366{
1367 // format: len a_len(num den) .. a_0
1368/* Currently not implemented
1369 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)c->data)->ctx;
1370 const fmpq_rat_ptr aa = (fmpq_rat_ptr) a;
1371 int l = fmpq_mpoly_length(aa->num, ctx);
1372 fprintf(d->f_write, "%d ", l);
1373 mpq_t m;
1374 mpq_init(m);
1375 mpz_t num, den;
1376 mpz_init(num);
1377 mpz_init(den);
1378 for(int i = l; i >= 0; i--)
1379 {
1380 fmpq_mpoly_get_coeff_mpq(m, aa->num, i);
1381 mpq_get_num(num, m);
1382 mpq_get_den(den, m);
1383 mpz_out_str(d->f_write, SSI_BASE, num);
1384 fputc(' ', d->f_write);
1385 mpz_out_str(d->f_write, SSI_BASE, den);
1386 fputc(' ', d->f_write);
1387 }
1388 mpz_clear(den);
1389 mpz_clear(num);
1390 mpq_clear(m);
1391*/
1392}
1393#endif
1394
1395#if 0
1396static number ReadFd(const ssiInfo *d, const coeffs c)
1397{
1398 // format: len a_len .. a_0
1399/* Currently not implemented
1400 fmpq_mpoly_ptr aa = (fmpq_mpoly_ptr) omAlloc(sizeof(fmpq_mpoly_t));
1401 fmpq_mpoly_init(aa);
1402 int l = s_readint(d->f_read);
1403 mpz_t nm;
1404 mpz_init(nm);
1405 mpq_t m;
1406 mpq_init(m);
1407 for (int i = l; i >= 0; i--)
1408 {
1409 s_readmpz_base(d->f_read, nm, SSI_BASE);
1410 mpq_set_num(m, nm);
1411 s_readmpz_base(d->f_read, nm, SSI_BASE);
1412 mpq_set_den(m, nm);
1413 fmpq_mpoly_set_coeff_mpq(aa, i, m);
1414 }
1415 mpz_clear(nm);
1416 mpq_clear(m);
1417 return (number)aa;
1418*/
1419 return NULL;
1420}
1421#endif
1422
1423// cfClearContent
1424
1425// cfClearDenominators
1426
1427#if 0
1428static number ConvFactoryNSingN(const CanonicalForm n, const coeffs c)
1429{
1430 WerrorS("not yet: ConvFactoryNSingN");
1431 return NULL;
1432}
1433#endif
1434
1435#if 0
1436static CanonicalForm ConvSingNFactoryN(number n, BOOLEAN setChar, const coeffs c)
1437{
1438 WerrorS("not yet: ConvSingNFactoryN");
1439 return CanonicalForm(0);
1440}
1441#endif
1442
1443char * QratCoeffName(const coeffs c)
1444{
1445 STATIC_VAR char CoeffName_flint_Qrat[200];
1446 sprintf(CoeffName_flint_Qrat, "flintQQ(%s",c->pParameterNames[0]);
1447 for(int i=1; i<c->iNumberOfParameters;i++)
1448 {
1449 strcat(CoeffName_flint_Qrat,",");
1450 strcat(CoeffName_flint_Qrat,c->pParameterNames[i]);
1451 }
1452 strcat(CoeffName_flint_Qrat,")");
1453 return (char*) CoeffName_flint_Qrat;
1454
1455}
1456
1458{
1459 const char start[] = "flintQ(";
1460 const int start_len = strlen(start);
1461 if (strncmp(s, start, start_len) == 0)
1462 {
1463 s += start_len;
1464 // count ,
1465 char *p=s;
1466 int N=0;
1467 loop
1468 {
1469 while((*p!=',')&&(*p!=')')&&(*p!='\0')) p++;
1470 if (*p==',') { p++; N++;}
1471 else if (*p==')') { p++; N++; break;}
1472 else if (*p=='\0') { break;}
1473 }
1474 // get names
1475 char *names[N];
1476 int i=0;
1477 p=s;
1478 loop
1479 {
1480 while((*p!=',')&&(*p!=')')&&(*p!='\0')) p++;
1481 if ((*p==',')||(*p=')'))
1482 {
1483 char c=*p;
1484 *p='\0';
1485 names[i]=omStrDup(s);
1486 *p=c;
1487 i++;
1488 p++;
1489 s=p;
1490 if (c==')') break;
1491 }
1492 if (*p=='\0') break;
1493 }
1494 QaInfo pp;
1495 pp.N=N;
1496 pp.names=names;
1497 coeffs cf=nInitChar(n,&pp);
1498 for(i=0;i<N;i++) omFree(names[i]);
1499 return cf;
1500 }
1501 return NULL;
1502}
1503
1504#ifdef LDEBUG
1505static BOOLEAN DBTest(number c, const char *, const int, const coeffs cf)
1506{
1507 const fmpq_rat_ptr x = (fmpq_rat_ptr) c;
1508 if (x!=NULL)
1509 {
1510 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)cf->data)->ctx;
1511 fmpq_mpoly_assert_canonical(x->num,ctx);
1512 fmpq_mpoly_assert_canonical(x->den,ctx);
1513 if (fmpq_mpoly_is_zero(x->den, ctx))
1514 {
1515 dReportError("den.==0\n");
1516 return FALSE;
1517 }
1518 fmpz_t n, d;
1519 fmpz_init(n);
1520 fmpz_init(d);
1521 fmpz_gcd(n, fmpq_numref(x->num->content), fmpq_numref(x->den->content));
1522 fmpz_lcm(d, fmpq_denref(x->num->content), fmpq_denref(x->den->content));
1523 if (!fmpz_is_one(d))
1524 {
1525 dReportError("canon needed (1)");
1526 return TRUE;
1527 }
1528 if (!fmpz_is_one(n))
1529 {
1530 dReportError("canon needed (2)");
1531 return TRUE;
1532 }
1533 fmpz_clear(n);
1534 fmpz_clear(d);
1535 #ifdef QA_DEBUG
1536 poly pp=convFlintMPSingP(x->num,ctx,((data_ptr)cf->data)->C->extRing);
1537 fraction f=(fraction)x->p;
1538 if (f==NULL)
1539 {
1540 dReportError("x->p==NULL\n");
1541 return FALSE;
1542 }
1543 else
1544 {
1545 if (!p_EqualPolys(pp,NUM(f),((data_ptr)cf->data)->C->extRing))
1546 {
1547 p_Write(pp,((data_ptr)cf->data)->C->extRing);
1548 PrintS("num, p=");
1549 p_Write(NUM(f),((data_ptr)cf->data)->C->extRing);
1550 dReportError("num wrong.\n");
1551 return FALSE;
1552 }
1553 if (DEN(f)!=NULL)
1554 {
1555 pp=convFlintMPSingP(x->den,ctx,((data_ptr)cf->data)->C->extRing);
1556 if (!p_EqualPolys(pp,DEN(f),((data_ptr)cf->data)->C->extRing))
1557 {
1558 p_Write(pp,((data_ptr)cf->data)->C->extRing);
1559 PrintS("den, p=");
1560 p_Write(NUM(f),((data_ptr)cf->data)->C->extRing);
1561 dReportError("den wrong.\n");
1562 return FALSE;
1563 }
1564 }
1565 }
1566 #endif
1567 }
1568 return TRUE;
1569}
1570
1571#endif
1572static void KillChar(coeffs cf)
1573{
1574 for(int i=0;i<cf->iNumberOfParameters;i++)
1575 omFree((ADDRESS)(cf->pParameterNames[i]));
1576 omFreeSize(cf->pParameterNames,sizeof(char*));
1577 const fmpq_ctx_ptr ctx = (fmpq_ctx_ptr) ((data_ptr)cf->data)->ctx;
1578 fmpq_mpoly_ctx_clear(ctx);
1579 omFree(cf->data);
1580}
1581
1582BOOLEAN flintQrat_InitChar(coeffs cf, void * infoStruct)
1583{
1584 QaInfo *pp=(QaInfo*)infoStruct;
1585 cf->cfCoeffName = QratCoeffName;
1586 cf->nCoeffIsEqual = CoeffIsEqual;
1587 cf->cfKillChar = KillChar;
1588 cf->ch = 0; //char 0
1589 cf->cfMult = Mult;
1590 cf->cfSub = Sub;
1591 cf->cfAdd = Add;
1592 cf->cfDiv = Div;
1593 cf->cfExactDiv = Div; // ???
1594 cf->cfInit = Init;
1595 cf->cfInitMPZ = InitMPZ;
1596 cf->cfSize = Size;
1597 cf->cfInt = Int;
1598 cf->cfMPZ = MPZ;
1599 cf->cfInpNeg = Neg;
1600 cf->cfInvers = Invers;
1601 cf->cfCopy = Copy;
1602 cf->cfRePart = Copy;
1603 // default: cf->cfImPart = ndReturn0;
1604 cf->cfWriteLong = WriteLong;
1605 cf->cfWriteShort = WriteLong;
1606 cf->cfRead = Read;
1607 //cf->cfNormalize = Normalize;
1608
1609 //cf->cfDivComp=
1610 //cf->cfIsUnit=
1611 //cf->cfGetUnit=
1612 //cf->cfDivBy=
1613
1614 cf->cfGreater = Greater;
1615 cf->cfEqual = Equal;
1616 cf->cfIsZero = IsZero;
1617 cf->cfIsOne = IsOne;
1618 cf->cfIsMOne = IsMOne;
1619 cf->cfGreaterZero = GreaterZero;
1620
1621 cf->cfPower = Power;
1622 cf->cfGetDenom = GetDenom;
1623 cf->cfGetNumerator = GetNumerator;
1624 cf->cfExtGcd = ExtGcd;
1625 cf->cfSubringGcd = SubringGcd;
1626 cf->cfNormalizeHelper= NormalizeHelper;
1627 cf->cfLcm = Lcm;
1628 cf->cfDelete = Delete;
1629 cf->cfSetMap = SetMap;
1630 // default: cf->cfInpMult
1631 // default: cf->cfInpAdd
1632 //cf->cfFarey =Farey;
1633 //cf->cfChineseRemainder = ChineseRemainder;
1634 cf->cfParDeg = ParDeg;
1635 cf->cfParameter = Parameter;
1636 // cf->cfClearContent = ClearContent;
1637 // cf->cfClearDenominators = ClearDenominators;
1638 //cf->convFactoryNSingN = ConvFactoryNSingN;
1639 //cf->convSingNFactoryN = ConvSingNFactoryN;
1640 //cf->cfWriteFd = WriteFd;
1641 //cf->cfReadFd = ReadFd;
1642#ifdef LDEBUG
1643 cf->cfDBTest = DBTest;
1644#endif
1645
1646 cf->iNumberOfParameters = pp->N;
1647 char **pn = (char**) omAlloc0(pp->N*sizeof(char*));
1648 for(int i=0;i<pp->N;i++)
1649 {
1650 pn[i] = omStrDup(pp->names[i]);
1651 }
1652 cf->pParameterNames = (const char **) pn;
1653 cf->has_simple_Inverse = FALSE;
1654 cf->has_simple_Alloc = FALSE;
1655 cf->is_field = TRUE;
1656 cf->is_domain = TRUE;
1657
1658 fmpq_rat_data_struct *ps=(fmpq_rat_data_struct*)omAlloc(sizeof(fmpq_rat_data_struct));
1659 ps->ctx=(fmpq_mpoly_ctx_struct*)omAlloc(sizeof(fmpq_mpoly_ctx_struct));
1660 #ifdef QA_DEBUG
1661 ps->C=pp->C;
1662 #endif
1663 fmpq_mpoly_ctx_init(ps->ctx,pp->N,ORD_LEX);
1664 cf->data=ps;
1665 return FALSE;
1666}
1667#else
1669{ return TRUE; }
1670#endif
1671#else
1672BOOLEAN flintQrat_InitChar(coeffs cf, void * infoStruct)
1673{ return TRUE; }
1674#endif
All the auxiliary stuff.
int BOOLEAN
Definition auxiliary.h:88
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
void * ADDRESS
Definition auxiliary.h:120
CanonicalForm FACTORY_PUBLIC content(const CanonicalForm &)
CanonicalForm content ( const CanonicalForm & f )
Definition cf_gcd.cc:603
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition cf_gcd.cc:676
Array< CanonicalForm > CFArray
CanonicalForm num(const CanonicalForm &f)
CanonicalForm den(const CanonicalForm &f)
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
int l
Definition cfEzgcd.cc:100
int i
Definition cfEzgcd.cc:132
int k
Definition cfEzgcd.cc:99
Variable x
Definition cfModGcd.cc:4090
int p
Definition cfModGcd.cc:4086
CanonicalForm cf
Definition cfModGcd.cc:4091
CanonicalForm b
Definition cfModGcd.cc:4111
FILE * f
Definition checklibs.c:9
factory's main class
Coefficient rings, fields and other domains suitable for Singular polynomials.
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
Definition coeffs.h:637
static FORCE_INLINE long n_Int(number &n, const coeffs r)
conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 ....
Definition coeffs.h:548
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition coeffs.h:455
static FORCE_INLINE number n_NormalizeHelper(number a, number b, const coeffs r)
assume that r is a quotient field (otherwise, return 1) for arguments (a1/a2,b1/b2) return (lcm(a1,...
Definition coeffs.h:696
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of 'a' and 'b', i.e., a+b
Definition coeffs.h:651
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition numbers.cc:287
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition coeffs.h:713
n_coeffType
Definition coeffs.h:27
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible
Definition coeffs.h:565
static FORCE_INLINE number n_ExactDiv(number a, number b, const coeffs r)
assume that there is a canonical subring in cf and we know that division is possible for these a and ...
Definition coeffs.h:623
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition coeffs.h:558
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 number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
Definition coeffs.h:656
static FORCE_INLINE BOOLEAN nCoeff_is_Q_or_BI(const coeffs r)
Definition coeffs.h:822
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:459
static FORCE_INLINE number n_InitMPZ(mpz_t n, const coeffs r)
conversion of a GMP integer to number
Definition coeffs.h:543
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition coeffs.h:793
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition coeffs.h:539
@ 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
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition coeffs.h:667
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
static BOOLEAN gd(leftv res, leftv args)
Definition cohomo.cc:3721
#define StringAppend
Definition emacs.cc:79
return result
#define slong
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
bool found
int j
Definition facHensel.cc:110
‘factory.h’ is the user interface to Factory.
void WerrorS(const char *s)
Definition feFopen.cc:24
static number ExtGcd(number a, number b, number *s, number *t, const coeffs)
Definition flintcf_Q.cc:447
static void WriteShort(number a, const coeffs r)
Definition flintcf_Q.cc:233
static number Copy(number a, const coeffs)
Definition flintcf_Q.cc:215
static number ChineseRemainder(number *, number *, int, BOOLEAN, CFArray &, const coeffs)
Definition flintcf_Q.cc:500
static nMapFunc SetMap(const coeffs, const coeffs)
Definition flintcf_Q.cc:470
static number Farey(number, number, const coeffs)
Definition flintcf_Q.cc:495
static number GetDenom(number &n, const coeffs)
Definition flintcf_Q.cc:423
static const char * Read(const char *st, number *a, const coeffs r)
Definition flintcf_Q.cc:326
static BOOLEAN IsOne(number a, const coeffs)
Definition flintcf_Q.cc:389
static number ConvFactoryNSingN(const CanonicalForm, const coeffs)
Definition flintcf_Q.cc:591
static number InitMPZ(mpz_t i, const coeffs)
Definition flintcf_Q.cc:128
static int Size(number n, const coeffs)
Definition flintcf_Q.cc:139
static number Add(number a, number b, const coeffs)
Definition flintcf_Q.cc:71
static number Div(number a, number b, const coeffs)
Definition flintcf_Q.cc:78
static void WriteFd(number a, const ssiInfo *d, const coeffs)
Definition flintcf_Q.cc:516
fmpz * fmpz_ptr
Definition flintcf_Q.cc:26
static void Delete(number *a, const coeffs)
Definition flintcf_Q.cc:461
static number Parameter(const int, const coeffs)
Definition flintcf_Q.cc:509
static BOOLEAN DBTest(number, const char *, const int, const coeffs)
Definition flintcf_Q.cc:626
static void KillChar(coeffs cf)
Definition flintcf_Q.cc:631
static CanonicalForm ConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition flintcf_Q.cc:596
static number Init(long i, const coeffs)
Definition flintcf_Q.cc:121
static void MPZ(mpz_t result, number &n, const coeffs)
Definition flintcf_Q.cc:159
static number ReadFd(const ssiInfo *d, const coeffs)
Definition flintcf_Q.cc:561
static number ExactDiv(number a, number b, const coeffs)
Definition flintcf_Q.cc:100
static void Power(number a, int i, number *result, const coeffs)
Definition flintcf_Q.cc:416
static BOOLEAN IsMOne(number k, const coeffs)
Definition flintcf_Q.cc:393
static number Sub(number a, number b, const coeffs)
Definition flintcf_Q.cc:64
static number GetNumerator(number &n, const coeffs)
Definition flintcf_Q.cc:431
static BOOLEAN GreaterZero(number, const coeffs)
Definition flintcf_Q.cc:410
static BOOLEAN CoeffIsEqual(const coeffs r, n_coeffType n, void *)
Definition flintcf_Q.cc:49
static number Mult(number a, number b, const coeffs)
Definition flintcf_Q.cc:57
static number Invers(number a, const coeffs)
Definition flintcf_Q.cc:195
static number Lcm(number, number, const coeffs)
Definition flintcf_Q.cc:456
static int ParDeg(number x, const coeffs)
Definition flintcf_Q.cc:505
static BOOLEAN IsZero(number a, const coeffs)
Definition flintcf_Q.cc:385
static number Neg(number a, const coeffs)
Definition flintcf_Q.cc:190
static BOOLEAN Equal(number a, number b, const coeffs)
Definition flintcf_Q.cc:381
static long Int(number &n, const coeffs)
Definition flintcf_Q.cc:143
static char * nlEatLong(char *s, mpz_ptr i)
Definition flintcf_Q.cc:30
BOOLEAN flintQrat_InitChar(coeffs cf, void *infoStruct)
coeffs flintQratInitCfByName(char *s, n_coeffType n)
static number Init_bigint(number i, const coeffs dummy, const coeffs dst)
#define STATIC_VAR
Definition globaldefs.h:7
static bool Greater(mono_type m1, mono_type m2)
#define SR_INT
Definition longrat.h:67
#define SR_TO_INT(SR)
Definition longrat.h:69
#define assume(x)
Definition mod2.h:389
int dReportError(const char *fmt,...)
Definition dError.cc:44
The main handler for Singular numbers which are suitable for Singular polynomials.
char * nEati(char *s, int *i, int m)
divide by the first (leading) number and return it, i.e. make monic
Definition numbers.cc:665
const char *const nDivBy0
Definition numbers.h:89
#define omStrDup(s)
#define omFreeSize(addr, size)
#define omAlloc(size)
#define omFree(addr)
#define omAlloc0(size)
#define NULL
Definition omList.c:12
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
Definition p_polys.cc:4621
void p_Write(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:342
#define NUM
Definition readcf.cc:180
void StringAppendS(const char *st)
Definition reporter.cc:107
void PrintS(const char *s)
Definition reporter.cc:284
#define loop
Definition structs.h:71
#define SR_HDL(A)
Definition tgb.cc:35