My Project
Loading...
Searching...
No Matches
flintcf_Zn.cc
Go to the documentation of this file.
1/****************************************
2* Computer Algebra System SINGULAR *
3****************************************/
4/*
5* ABSTRACT: flint: nmod_poly_t
6*/
7#include <ctype.h> /* isdigit*/
8
9#include "misc/auxiliary.h"
10
11#ifdef HAVE_FLINT
12
13#include <flint/flint.h>
14#include <flint/nmod_poly.h>
15#include "factory/factory.h"
16
17#include "coeffs/coeffs.h"
18
19#include "coeffs/numbers.h"
20#include "coeffs/longrat.h"
21#include "coeffs/modulop.h"
22#include "coeffs/flintcf_Zn.h"
23
24typedef nmod_poly_struct *nmod_poly_ptr;
25
26/*2
27* extracts a long integer from s, returns the rest
28*/
29static const char* Eati(const char *s, int *i)
30{
31
32 if (((*s) >= '0') && ((*s) <= '9'))
33 {
34 unsigned long ii=0L;
35 do
36 {
37 ii *= 10;
38 ii += *s++ - '0';
39 }
40 while (((*s) >= '0') && ((*s) <= '9'));
41 *i=(int)ii;
42 }
43 else (*i) = 1;
44 return s;
45}
46
47static BOOLEAN CoeffIsEqual(const coeffs r, n_coeffType n, void * parameter)
48{
49 flintZn_struct *pp=(flintZn_struct*)parameter;
50 return (r->type==n) &&(r->ch==pp->ch)
51 &&(r->pParameterNames!=NULL)
52 &&(strcmp(r->pParameterNames[0],pp->name)==0);
53}
54static void KillChar(coeffs cf)
55{
56 omFree((ADDRESS)(cf->pParameterNames[0]));
57 omFreeSize(cf->pParameterNames,sizeof(char*));
58}
59static void SetChar(const coeffs r)
60{
61 // dummy
62}
63static number Mult(number a, number b, const coeffs c)
64{
66 nmod_poly_init(res,c->ch);
67 nmod_poly_mul(res,(nmod_poly_ptr)a,(nmod_poly_ptr)b);
68 return (number)res;
69}
70static number Sub(number a, number b, const coeffs c)
71{
72 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
73 nmod_poly_init(res,c->ch);
74 nmod_poly_sub(res,(nmod_poly_ptr)a,(nmod_poly_ptr)b);
75 return (number)res;
76}
77static number Add(number a, number b, const coeffs c)
78{
79 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
80 nmod_poly_init(res,c->ch);
81 nmod_poly_add(res,(nmod_poly_ptr)a,(nmod_poly_ptr)b);
82 return (number)res;
83}
84static number Div(number a, number b, const coeffs c)
85{
86 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
87 nmod_poly_init(res,c->ch);
88 if(nmod_poly_is_zero((nmod_poly_ptr)b))
89 {
91 }
92 else
93 {
94 nmod_poly_div(res,(nmod_poly_ptr)a,(nmod_poly_ptr)b);
95 nmod_poly_t mod;
96 nmod_poly_init(mod,c->ch);
97 nmod_poly_rem(mod,(nmod_poly_ptr)a,(nmod_poly_ptr)b);
98 if (!nmod_poly_is_zero((nmod_poly_ptr)mod))
99 {
100 WerrorS("cannot divide");
101 }
103 }
104 return (number)res;
105}
106static number ExactDiv(number a, number b, const coeffs c)
107{
108 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
109 nmod_poly_init(res,c->ch);
110 if(nmod_poly_is_zero((nmod_poly_ptr)b))
111 {
113 }
114 else
115 nmod_poly_div(res,(nmod_poly_ptr)a,(nmod_poly_ptr)b);
116 return (number)res;
117}
118static number IntMod(number a, number b, const coeffs c)
119{
120 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
121 nmod_poly_init(res,c->ch);
122 nmod_poly_rem(res,(nmod_poly_ptr)a,(nmod_poly_ptr)b);
123 return (number)res;
124}
125static number Init (long i, const coeffs r)
126{
127 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
128 nmod_poly_init(res,r->ch);
129 i= i%r->ch;
130 if (i<0) i+=r->ch;
131 nmod_poly_set_coeff_ui(res,0,i);
132 return (number)res;
133}
134static number InitMPZ (mpz_t i, const coeffs r)
135{
136 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
137 nmod_poly_init(res,r->ch);
138 mpz_t tmp;
139 mpz_init(tmp);
140 slong ii=mpz_mod_ui(tmp,i,r->ch);
141 mpz_clear(tmp);
142 nmod_poly_set_coeff_ui(res,0,ii);
143 return (number)res;
144}
145static int Size (number n, const coeffs r)
146{
147 return nmod_poly_degree((nmod_poly_ptr)n);
148}
149static long Int (number &n, const coeffs r)
150{
151 if (nmod_poly_degree((nmod_poly_ptr)n)==0)
152 {
153 slong m;
154 m=nmod_poly_get_coeff_ui((nmod_poly_ptr)n,0);
155 return (long)m;
156 }
157 return 0;
158}
159static void MPZ(mpz_t result, number &n, const coeffs r)
160{
161 mpz_init(result);
162 if (nmod_poly_degree((nmod_poly_ptr)n)==0)
163 {
164 slong m;
165 m=nmod_poly_get_coeff_ui((nmod_poly_ptr)n,0);
166 mpz_set_ui(result,m);
167 }
168}
169static number Neg(number a, const coeffs r)
170{
171 nmod_poly_neg((nmod_poly_ptr)a,(nmod_poly_ptr)a);
172 return a;
173}
174static number Invers(number a, const coeffs r)
175{
176 if(nmod_poly_is_zero((nmod_poly_ptr)a))
177 {
179 return NULL;
180 }
181 if (nmod_poly_degree((nmod_poly_ptr)a)==0)
182 {
183 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
184 nmod_poly_init(res,r->ch);
185 slong c=nmod_poly_get_coeff_ui((nmod_poly_ptr)a,0);
186 extern number nvInvers (number c, const coeffs r);
187 c=(slong)nvInvers((number)c,r);
188 nmod_poly_set_coeff_ui((nmod_poly_ptr)a,0,c);
189 return (number)res;
190 }
191 else
192 {
193 WerrorS("not invertable");
194 return NULL;
195 }
196}
197static number Copy(number a, const coeffs r)
198{
199 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
200 nmod_poly_init(res,r->ch);
201 nmod_poly_set(res,(nmod_poly_ptr)a);
202 return (number)res;
203}
204//static number RePart(number a, const coeffs r)
205//{
206//}
207//static number ImPart(number a, const coeffs r)
208//{
209//}
210static BOOLEAN IsOne (number a, const coeffs r);
211static BOOLEAN IsZero (number a, const coeffs r);
212//static void WriteLong(number &a, const coeffs r)
213//{
214//}
215static void WriteShort(number a, const coeffs r)
216{
217 //nmod_poly_print_pretty((nmod_poly_ptr)a,r->pParameterNames[0]);
218 if (IsOne(a,r)) StringAppendS("1");
219 else if (IsZero(a,r)) StringAppendS("0");
220 else
221 {
222 StringAppendS("(");
223 BOOLEAN need_plus=FALSE;
224 for(int i=nmod_poly_length((nmod_poly_ptr)a);i>=0;i--)
225 {
226 slong m=nmod_poly_get_coeff_ui((nmod_poly_ptr)a,i);
227 if (m!=0)
228 {
229 if (need_plus) StringAppendS("+");
230 need_plus=TRUE;
231 if (i>0)
232 {
233 if (m!=1) StringAppend("%d*",(int)m);
234 if (i>1)
235 StringAppend("%s^%d",r->pParameterNames[0],i);
236 else if (i==1)
237 StringAppend("%s",r->pParameterNames[0]);
238 }
239 else StringAppend("%d",(int)m);
240 }
241 }
242 StringAppendS(")");
243 }
244}
245static const char* Read(const char * st, number * a, const coeffs r)
246{
247// we only read "monomials" (i.e. [-][digits][parameter]),
248// everything else (+,*,^,()) is left to the singular interpreter
249 const char *s=st;
250 *a=(number)omAlloc(sizeof(nmod_poly_t));
251 nmod_poly_init((nmod_poly_ptr)(*a),r->ch);
252 BOOLEAN neg=FALSE;
253 if (*s=='-') { neg=TRUE; s++;}
254 if (isdigit(*s))
255 {
256 int z;
257 s=Eati((char *)s, &z);
258 nmod_poly_set_coeff_ui((nmod_poly_ptr)(*a),0,z);
259 }
260 else if(strncmp(s,r->pParameterNames[0],strlen(r->pParameterNames[0]))==0)
261 {
262 nmod_poly_set_coeff_ui((nmod_poly_ptr)(*a),1,1);
263 s+=strlen(r->pParameterNames[0]);
264 if(isdigit(*s))
265 {
266 int i=1;
267 s=Eati(s,&i);
268 if (i!=1)
269 {
270 nmod_poly_set_coeff_ui((nmod_poly_ptr)(*a),1,0);
271 nmod_poly_set_coeff_ui((nmod_poly_ptr)(*a),i,1);
272 }
273 }
274 }
275 if (neg)
276 nmod_poly_neg((nmod_poly_ptr)(*a),(nmod_poly_ptr)(*a));
277 return s;
278}
279static void Normalize(number &a, const coeffs r)
280{
281}
282static BOOLEAN Greater (number a, number b, const coeffs r)
283{
284 if (nmod_poly_length((nmod_poly_ptr)a)>nmod_poly_length((nmod_poly_ptr)b))
285 return TRUE;
286 else if (nmod_poly_length((nmod_poly_ptr)a)<nmod_poly_length((nmod_poly_ptr)b))
287 return FALSE;
288 for(int i=nmod_poly_length((nmod_poly_ptr)a);i>=0;i--)
289 {
290 slong ac=nmod_poly_get_coeff_ui((nmod_poly_ptr)a,i);
291 slong bc=nmod_poly_get_coeff_ui((nmod_poly_ptr)b,i);
292 if (ac>bc) return TRUE;
293 else if (ac<bc) return FALSE;
294 }
295 return FALSE;
296}
297static BOOLEAN Equal (number a, number b, const coeffs r)
298{
299 return (nmod_poly_equal((nmod_poly_ptr)a,(nmod_poly_ptr)b));
300}
301static BOOLEAN IsZero (number a, const coeffs r)
302{
303 return nmod_poly_is_zero((nmod_poly_ptr)a);
304}
305static BOOLEAN IsOne (number a, const coeffs r)
306{
307 return nmod_poly_is_one((nmod_poly_ptr)a);
308}
309static BOOLEAN IsMOne (number k, const coeffs r)
310{
311 if (nmod_poly_length((nmod_poly_ptr)k)>0) return FALSE;
312 slong m=nmod_poly_get_coeff_ui((nmod_poly_ptr)k,0);
313 return (m+1==r->ch);
314}
315static BOOLEAN GreaterZero (number k, const coeffs r)
316{
317 // does it have a leading sign?
318 // no: 0 and 1 do not have, everything else is in (...)
319 return TRUE;
320}
321static void Power(number a, int i, number * result, const coeffs r)
322{
323 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
324 nmod_poly_init(res,r->ch);
325 *result=(number)res;
326 nmod_poly_pow((nmod_poly_ptr)(*result),(nmod_poly_ptr)a,i);
327}
328static number Gcd(number a, number b, const coeffs r)
329{
330 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
331 nmod_poly_init(res,r->ch);
332 nmod_poly_gcd(res,(nmod_poly_ptr)a,(nmod_poly_ptr)b);
333 return (number)res;
334}
335static number ExtGcd(number a, number b, number *s, number *t,const coeffs r)
336{
337 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
338 nmod_poly_init(res,r->ch);
340 nmod_poly_init((nmod_poly_ptr)*t,r->ch);
341 nmod_poly_xgcd(res,(nmod_poly_ptr)*s,(nmod_poly_ptr)*t,(nmod_poly_ptr)a,(nmod_poly_ptr)b);
342 return (number)res;
343}
344static number Lcm(number a, number b, const coeffs r)
345{
346 WerrorS("not yet: Lcm");
347 return NULL;
348}
349static void Delete(number * a, const coeffs r)
350{
351 if ((*a)!=NULL)
352 {
354 omFree(*a);
355 *a=NULL;
356 }
357}
358static nMapFunc SetMap(const coeffs src, const coeffs dst)
359{
360 WerrorS("not yet: SetMap");
361 return NULL;
362}
363//static void InpMult(number &a, number b, const coeffs r)
364//{
365//}
366//static void InpAdd(number &a, number b, const coeffs r)
367//{
368//}
369static number Init_bigint(number i, const coeffs dummy, const coeffs dst)
370{
371 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
372 nmod_poly_init(res,dst->ch);
373 long ii;
374 if (SR_HDL(i) & SR_INT)
375 {
376 ii=SR_TO_INT(i) % dst->ch;
377 }
378 else
379 {
380 mpz_t tmp;
381 mpz_init(tmp);
382 ii=mpz_mod_ui(tmp,i->z,dst->ch);
383 mpz_clear(tmp);
384 }
385 if (ii<0) ii+=dst->ch;
386 nmod_poly_set_coeff_ui(res,0,ii);
387 return (number)res;
388}
389static number Farey(number p, number n, const coeffs)
390{
391 WerrorS("not yet: Farey");
392 return NULL;
393}
394static number ChineseRemainder(number *x, number *q,int rl, BOOLEAN sym,CFArray &inv_cache,const coeffs)
395{
396 WerrorS("not yet: ChineseRemainder");
397 return NULL;
398}
399static int ParDeg(number x,const coeffs r)
400{
401 return nmod_poly_degree((nmod_poly_ptr)x);
402}
403static number Parameter(const int i, const coeffs r)
404{
405 nmod_poly_ptr res=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
406 nmod_poly_init(res,r->ch);
407 nmod_poly_set_coeff_ui(res,1,1);
408 return (number)res;
409}
410// cfClearContent
411// cfClearDenominators
412#if 0
413static number ConvFactoryNSingN( const CanonicalForm n, const coeffs r)
414{
415 WerrorS("not yet: ConvFactoryNSingN");
416 return NULL;
417}
418#endif
419#if 0
420static CanonicalForm ConvSingNFactoryN( number n, BOOLEAN setChar, const coeffs r )
421{
422 WerrorS("not yet: ConvSingNFactoryN");
423 return CanonicalForm(0);
424}
425#endif
426static char * CoeffName(const coeffs r)
427{
428 STATIC_VAR char CoeffName_flint_Zn[20];
429 sprintf(CoeffName_flint_Zn,"flint:Z/%d[%s]",r->ch,r->pParameterNames[0]);
430 return (char*)CoeffName_flint_Zn;
431}
433{
434 const char start[]="flint:Z/";
435 const int start_len=strlen(start);
436 if (strncmp(s,start,start_len)==0)
437 {
438 s+=start_len;
439 int p;
440 char st[10];
441 int l=sscanf(s,"%d[%s",&p,st);
442 if (l==2)
443 {
445 info.ch=p;
446 while (st[strlen(st)-1]==']') st[strlen(st)-1]='\0';
447 info.name=st;
448 return nInitChar(n,(void*)&info);
449 }
450 }
451 return NULL;
452}
453static void WriteFd(number a, const ssiInfo *d, const coeffs)
454{
455 // format: len a_len .. a_0
457 int l=nmod_poly_length(aa);
458 fprintf(d->f_write,"%d ",l);
459 for(int i=l; i>=0; i--)
460 {
461 ulong ul=nmod_poly_get_coeff_ui(aa,i);
462 fprintf(d->f_write,"%lu ", ul);
463 }
464}
465
466static number ReadFd(const ssiInfo *d, const coeffs r)
467{
468 // format: len a_len .. a_0
469 nmod_poly_ptr aa=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
470 nmod_poly_init(aa,r->ch);
471 int l=s_readint(d->f_read);
472 unsigned long ul;
473 for (int i=l;i>=0;i--)
474 {
475 unsigned long ul=s_readlong(d->f_read);
476 nmod_poly_set_coeff_ui(aa,i,ul);
477 }
478 return (number)aa;
479}
480#ifdef LDEBUG
481static BOOLEAN DBTest(number a, const char *f, const int l, const coeffs r)
482{
483 return TRUE;
484}
485#endif
487{
488 flintZn_struct *pp=(flintZn_struct*)infoStruct;
489 cf->ch=pp->ch;
490
491 cf->cfCoeffName = CoeffName;
492 cf->nCoeffIsEqual = CoeffIsEqual;
493 cf->cfKillChar = KillChar;
494 cf->cfSetChar = SetChar;
495 cf->cfMult = Mult;
496 cf->cfSub = Sub;
497 cf->cfAdd = Add;
498 cf->cfDiv = Div;
499 cf->cfExactDiv = ExactDiv; // ???
500 cf->cfInit = Init;
501 cf->cfInitMPZ = InitMPZ;
502 cf->cfSize = Size;
503 cf->cfInt = Int;
504 cf->cfMPZ = MPZ;
505 cf->cfInpNeg = Neg;
506 cf->cfInvers = Invers;
507 cf->cfCopy = Copy;
508 cf->cfRePart = Copy;
509 // default: cf->cfImPart = ndReturn0;
510 cf->cfWriteLong = WriteShort; //WriteLong;
511 cf->cfWriteShort = WriteShort;
512 cf->cfRead = Read;
513 cf->cfNormalize = Normalize;
514
515 //cf->cfDivComp=
516 //cf->cfIsUnit=
517 //cf->cfGetUnit=
518 //cf->cfDivBy=
519
520 cf->cfGreater=Greater;
521 cf->cfEqual =Equal;
522 cf->cfIsZero =IsZero;
523 cf->cfIsOne =IsOne;
524 cf->cfIsMOne =IsMOne;
525 cf->cfGreaterZero=GreaterZero;
526
527 cf->cfPower = Power;
528 //default: cf->cfGetDenom = GetDenom;
529 //default: cf->cfGetNumerator = GetNumerator;
530 cf->cfGcd = Gcd;
531 cf->cfExtGcd = ExtGcd;
532 cf->cfLcm = Lcm;
533 cf->cfDelete = Delete;
534 cf->cfSetMap = SetMap;
535 // default: cf->cfInpMult
536 // default: cf->cfInpAdd
537 cf->cfFarey =Farey;
538 cf->cfChineseRemainder=ChineseRemainder;
539 cf->cfParDeg = ParDeg;
540 cf->cfParameter = Parameter;
541 // cf->cfClearContent = ClearContent;
542 // cf->cfClearDenominators = ClearDenominators;
543 //cf->convFactoryNSingN=ConvFactoryNSingN;
544 //cf->convSingNFactoryN=ConvSingNFactoryN;
545 cf->cfWriteFd = WriteFd;
546 cf->cfReadFd = ReadFd;
547#ifdef LDEBUG
548 cf->cfDBTest = DBTest;
549#endif
550
551 cf->iNumberOfParameters = 1;
552 char **pn=(char**)omAlloc0(sizeof(char*));
553 pn[0]=(char*)omStrDup(pp->name);
554 cf->pParameterNames = (const char **)pn;
555 cf->has_simple_Inverse= FALSE;
556 cf->has_simple_Alloc= FALSE;
557 cf->is_field=FALSE;
558
559 return FALSE;
560}
561#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
CF_NO_INLINE FACTORY_PUBLIC CanonicalForm mod(const CanonicalForm &, const CanonicalForm &)
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition cf_gcd.cc:676
Array< CanonicalForm > CFArray
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
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.
n_coeffType
Definition coeffs.h:27
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition numbers.cc:406
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
#define StringAppend
Definition emacs.cc:79
return result
#define slong
const CanonicalForm int s
Definition facAbsFact.cc:51
CanonicalForm res
Definition facAbsFact.cc:60
nmod_poly_init(FLINTmipo, getCharacteristic())
nmod_poly_clear(FLINTmipo)
‘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 void Normalize(number &a, const coeffs)
Definition flintcf_Q.cc:373
static void SetChar(const coeffs)
Definition flintcf_Q.cc:53
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 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
char * CoeffName(const coeffs r)
Definition flintcf_Q.cc:601
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
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 BOOLEAN GreaterZero(number, const coeffs)
Definition flintcf_Q.cc:410
static number Gcd(number a, number b, const coeffs)
Definition flintcf_Q.cc:440
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 void WriteShort(number a, const coeffs r)
static char * CoeffName(const coeffs r)
static number Lcm(number a, number b, const coeffs r)
static void MPZ(mpz_t result, number &n, const coeffs r)
static number Neg(number a, const coeffs r)
static BOOLEAN Greater(number a, number b, const coeffs r)
static const char * Read(const char *st, number *a, const coeffs r)
static number Mult(number a, number b, const coeffs c)
Definition flintcf_Zn.cc:63
static number Init_bigint(number i, const coeffs dummy, const coeffs dst)
static number Sub(number a, number b, const coeffs c)
Definition flintcf_Zn.cc:70
static long Int(number &n, const coeffs r)
static number Init(long i, const coeffs r)
static BOOLEAN CoeffIsEqual(const coeffs r, n_coeffType n, void *parameter)
Definition flintcf_Zn.cc:47
static void Normalize(number &a, const coeffs r)
static number Gcd(number a, number b, const coeffs r)
static number ExtGcd(number a, number b, number *s, number *t, const coeffs r)
static void WriteFd(number a, const ssiInfo *d, const coeffs)
static BOOLEAN GreaterZero(number k, const coeffs r)
static BOOLEAN DBTest(number a, const char *f, const int l, const coeffs r)
static void Delete(number *a, const coeffs r)
static number ReadFd(const ssiInfo *d, const coeffs r)
BOOLEAN flintZn_InitChar(coeffs cf, void *infoStruct)
static void KillChar(coeffs cf)
Definition flintcf_Zn.cc:54
nmod_poly_struct * nmod_poly_ptr
Definition flintcf_Zn.cc:24
static number Copy(number a, const coeffs r)
static number InitMPZ(mpz_t i, const coeffs r)
static number Div(number a, number b, const coeffs c)
Definition flintcf_Zn.cc:84
static void Power(number a, int i, number *result, const coeffs r)
static BOOLEAN Equal(number a, number b, const coeffs r)
static number Add(number a, number b, const coeffs c)
Definition flintcf_Zn.cc:77
static BOOLEAN IsOne(number a, const coeffs r)
static number Farey(number p, number n, const coeffs)
static BOOLEAN IsZero(number a, const coeffs r)
static int ParDeg(number x, const coeffs r)
static nMapFunc SetMap(const coeffs src, const coeffs dst)
static number ChineseRemainder(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs)
static BOOLEAN IsMOne(number k, const coeffs r)
static void SetChar(const coeffs r)
Definition flintcf_Zn.cc:59
static const char * Eati(const char *s, int *i)
Definition flintcf_Zn.cc:29
static number Parameter(const int i, const coeffs r)
static number Invers(number a, const coeffs r)
static number IntMod(number a, number b, const coeffs c)
static int Size(number n, const coeffs r)
coeffs flintZnInitCfByName(char *s, n_coeffType n)
static number ExactDiv(number a, number b, const coeffs c)
#define STATIC_VAR
Definition globaldefs.h:7
static bool Greater(mono_type m1, mono_type m2)
#define info
Definition libparse.cc:1256
#define SR_INT
Definition longrat.h:67
#define SR_TO_INT(SR)
Definition longrat.h:69
number nvInvers(number c, const coeffs r)
Definition modulop.cc:667
The main handler for Singular numbers which are suitable for Singular polynomials.
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
void StringAppendS(const char *st)
Definition reporter.cc:107
int s_readint(s_buff F)
Definition s_buff.cc:113
long s_readlong(s_buff F)
Definition s_buff.cc:141
s_buff f_read
Definition s_buff.h:22
FILE * f_write
Definition s_buff.h:23
#define SR_HDL(A)
Definition tgb.cc:35