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// everythings 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:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
void * ADDRESS
Definition: auxiliary.h:119
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
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:4082
int p
Definition: cfModGcd.cc:4078
CanonicalForm cf
Definition: cfModGcd.cc:4083
CanonicalForm b
Definition: cfModGcd.cc:4103
FILE * f
Definition: checklibs.c:9
factory's main class
Definition: canonicalform.h:86
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:413
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
#define StringAppend
Definition: emacs.cc:79
return result
Definition: facAbsBiFact.cc:75
#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)
void WerrorS(const char *s)
Definition: feFopen.cc:24
static number ConvFactoryNSingN(const CanonicalForm, const coeffs)
Definition: flintcf_Q.cc:516
static CanonicalForm ConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: flintcf_Q.cc:521
static void WriteShort(number a, const coeffs r)
Definition: flintcf_Zn.cc:215
static char * CoeffName(const coeffs r)
Definition: flintcf_Zn.cc:426
static number Lcm(number a, number b, const coeffs r)
Definition: flintcf_Zn.cc:344
static void MPZ(mpz_t result, number &n, const coeffs r)
Definition: flintcf_Zn.cc:159
static number Neg(number a, const coeffs r)
Definition: flintcf_Zn.cc:169
static BOOLEAN Greater(number a, number b, const coeffs r)
Definition: flintcf_Zn.cc:282
static const char * Read(const char *st, number *a, const coeffs r)
Definition: flintcf_Zn.cc:245
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)
Definition: flintcf_Zn.cc:369
static number Sub(number a, number b, const coeffs c)
Definition: flintcf_Zn.cc:70
static long Int(number &n, const coeffs r)
Definition: flintcf_Zn.cc:149
static number Init(long i, const coeffs r)
Definition: flintcf_Zn.cc:125
static BOOLEAN CoeffIsEqual(const coeffs r, n_coeffType n, void *parameter)
Definition: flintcf_Zn.cc:47
static void Normalize(number &a, const coeffs r)
Definition: flintcf_Zn.cc:279
static number Gcd(number a, number b, const coeffs r)
Definition: flintcf_Zn.cc:328
static number ExtGcd(number a, number b, number *s, number *t, const coeffs r)
Definition: flintcf_Zn.cc:335
static void WriteFd(number a, const ssiInfo *d, const coeffs)
Definition: flintcf_Zn.cc:453
static BOOLEAN GreaterZero(number k, const coeffs r)
Definition: flintcf_Zn.cc:315
static BOOLEAN DBTest(number a, const char *f, const int l, const coeffs r)
Definition: flintcf_Zn.cc:481
static void Delete(number *a, const coeffs r)
Definition: flintcf_Zn.cc:349
static number ReadFd(const ssiInfo *d, const coeffs r)
Definition: flintcf_Zn.cc:466
BOOLEAN flintZn_InitChar(coeffs cf, void *infoStruct)
Definition: flintcf_Zn.cc:486
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)
Definition: flintcf_Zn.cc:197
static number InitMPZ(mpz_t i, const coeffs r)
Definition: flintcf_Zn.cc:134
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)
Definition: flintcf_Zn.cc:321
static BOOLEAN Equal(number a, number b, const coeffs r)
Definition: flintcf_Zn.cc:297
static number Add(number a, number b, const coeffs c)
Definition: flintcf_Zn.cc:77
static BOOLEAN IsOne(number a, const coeffs r)
Definition: flintcf_Zn.cc:305
static number Farey(number p, number n, const coeffs)
Definition: flintcf_Zn.cc:389
static BOOLEAN IsZero(number a, const coeffs r)
Definition: flintcf_Zn.cc:301
static int ParDeg(number x, const coeffs r)
Definition: flintcf_Zn.cc:399
static nMapFunc SetMap(const coeffs src, const coeffs dst)
Definition: flintcf_Zn.cc:358
static number ChineseRemainder(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs)
Definition: flintcf_Zn.cc:394
static BOOLEAN IsMOne(number k, const coeffs r)
Definition: flintcf_Zn.cc:309
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)
Definition: flintcf_Zn.cc:403
static number Invers(number a, const coeffs r)
Definition: flintcf_Zn.cc:174
static number IntMod(number a, number b, const coeffs c)
Definition: flintcf_Zn.cc:118
static int Size(number n, const coeffs r)
Definition: flintcf_Zn.cc:145
coeffs flintZnInitCfByName(char *s, n_coeffType n)
Definition: flintcf_Zn.cc:432
static number ExactDiv(number a, number b, const coeffs c)
Definition: flintcf_Zn.cc:106
#define STATIC_VAR
Definition: globaldefs.h:7
#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:673
The main handler for Singular numbers which are suitable for Singular polynomials.
const char *const nDivBy0
Definition: numbers.h:89
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omFree(addr)
Definition: omAllocDecl.h:261
#define omAlloc0(size)
Definition: omAllocDecl.h:211
#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:112
long s_readlong(s_buff F)
Definition: s_buff.cc:140
s_buff f_read
Definition: s_buff.h:22
FILE * f_write
Definition: s_buff.h:23
Definition: s_buff.h:21
#define SR_HDL(A)
Definition: tgb.cc:35