My Project
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 
24 typedef nmod_poly_struct *nmod_poly_ptr;
25 
26 /*2
27 * extracts a long integer from s, returns the rest
28 */
29 static 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 
47 static 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 }
54 static void KillChar(coeffs cf)
55 {
56  omFree((ADDRESS)(cf->pParameterNames[0]));
57  omFreeSize(cf->pParameterNames,sizeof(char*));
58 }
59 static void SetChar(const coeffs r)
60 {
61  // dummy
62 }
63 static 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 }
70 static 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 }
77 static 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 }
84 static 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 }
106 static 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  {
112  WerrorS(nDivBy0);
113  }
114  else
115  nmod_poly_div(res,(nmod_poly_ptr)a,(nmod_poly_ptr)b);
116  return (number)res;
117 }
118 static 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 }
125 static 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 }
134 static 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 }
145 static int Size (number n, const coeffs r)
146 {
147  return nmod_poly_degree((nmod_poly_ptr)n);
148 }
149 static 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 }
159 static 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 }
169 static number Neg(number a, const coeffs r)
170 {
171  nmod_poly_neg((nmod_poly_ptr)a,(nmod_poly_ptr)a);
172  return a;
173 }
174 static number Invers(number a, const coeffs r)
175 {
176  if(nmod_poly_is_zero((nmod_poly_ptr)a))
177  {
178  WerrorS(nDivBy0);
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 }
197 static 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 //}
210 static BOOLEAN IsOne (number a, const coeffs r);
211 static BOOLEAN IsZero (number a, const coeffs r);
212 //static void WriteLong(number &a, const coeffs r)
213 //{
214 //}
215 static 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 }
245 static 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 }
279 static void Normalize(number &a, const coeffs r)
280 {
281 }
282 static 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 }
297 static BOOLEAN Equal (number a, number b, const coeffs r)
298 {
299  return (nmod_poly_equal((nmod_poly_ptr)a,(nmod_poly_ptr)b));
300 }
301 static BOOLEAN IsZero (number a, const coeffs r)
302 {
303  return nmod_poly_is_zero((nmod_poly_ptr)a);
304 }
305 static BOOLEAN IsOne (number a, const coeffs r)
306 {
307  return nmod_poly_is_one((nmod_poly_ptr)a);
308 }
309 static 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 }
315 static 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 }
321 static 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 }
328 static 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 }
335 static 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);
339  nmod_poly_init((nmod_poly_ptr)*s,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 }
344 static number Lcm(number a, number b, const coeffs r)
345 {
346  WerrorS("not yet: Lcm");
347  return NULL;
348 }
349 static void Delete(number * a, const coeffs r)
350 {
351  if ((*a)!=NULL)
352  {
354  omFree(*a);
355  *a=NULL;
356  }
357 }
358 static 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 //}
369 static 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 }
389 static number Farey(number p, number n, const coeffs)
390 {
391  WerrorS("not yet: Farey");
392  return NULL;
393 }
394 static 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 }
399 static int ParDeg(number x,const coeffs r)
400 {
401  return nmod_poly_degree((nmod_poly_ptr)x);
402 }
403 static 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 static number ConvFactoryNSingN( const CanonicalForm n, const coeffs r)
413 {
414  WerrorS("not yet: ConvFactoryNSingN");
415  return NULL;
416 }
417 static CanonicalForm ConvSingNFactoryN( number n, BOOLEAN setChar, const coeffs r )
418 {
419  WerrorS("not yet: ConvSingNFactoryN");
420  return NULL;
421 }
422 static char * CoeffName(const coeffs r)
423 {
424  STATIC_VAR char CoeffName_flint_Zn[20];
425  sprintf(CoeffName_flint_Zn,"flint:Z/%d[%s]",r->ch,r->pParameterNames[0]);
426  return (char*)CoeffName_flint_Zn;
427 }
429 {
430  const char start[]="flint:Z/";
431  const int start_len=strlen(start);
432  if (strncmp(s,start,start_len)==0)
433  {
434  s+=start_len;
435  int p;
436  char st[10];
437  int l=sscanf(s,"%d[%s",&p,st);
438  if (l==2)
439  {
441  info.ch=p;
442  while (st[strlen(st)-1]==']') st[strlen(st)-1]='\0';
443  info.name=st;
444  return nInitChar(n,(void*)&info);
445  }
446  }
447  return NULL;
448 }
449 static void WriteFd(number a, const ssiInfo *d, const coeffs)
450 {
451  // format: len a_len .. a_0
453  int l=nmod_poly_length(aa);
454  fprintf(d->f_write,"%d ",l);
455  for(int i=l; i>=0; i--)
456  {
457  ulong ul=nmod_poly_get_coeff_ui(aa,i);
458  fprintf(d->f_write,"%lu ", ul);
459  }
460 }
461 
462 static number ReadFd(const ssiInfo *d, const coeffs r)
463 {
464  // format: len a_len .. a_0
465  nmod_poly_ptr aa=(nmod_poly_ptr)omAlloc(sizeof(nmod_poly_t));
466  nmod_poly_init(aa,r->ch);
467  int l=s_readint(d->f_read);
468  unsigned long ul;
469  for (int i=l;i>=0;i--)
470  {
471  unsigned long ul=s_readlong(d->f_read);
472  nmod_poly_set_coeff_ui(aa,i,ul);
473  }
474  return (number)aa;
475 }
476 #ifdef LDEBUG
477 static BOOLEAN DBTest(number a, const char *f, const int l, const coeffs r)
478 {
479  return TRUE;
480 }
481 #endif
482 BOOLEAN flintZn_InitChar(coeffs cf, void * infoStruct)
483 {
484  flintZn_struct *pp=(flintZn_struct*)infoStruct;
485  cf->ch=pp->ch;
486 
487  cf->cfCoeffName = CoeffName;
488  cf->nCoeffIsEqual = CoeffIsEqual;
489  cf->cfKillChar = KillChar;
490  cf->cfSetChar = SetChar;
491  cf->cfMult = Mult;
492  cf->cfSub = Sub;
493  cf->cfAdd = Add;
494  cf->cfDiv = Div;
495  cf->cfExactDiv = ExactDiv; // ???
496  cf->cfInit = Init;
497  cf->cfInitMPZ = InitMPZ;
498  cf->cfSize = Size;
499  cf->cfInt = Int;
500  cf->cfMPZ = MPZ;
501  cf->cfInpNeg = Neg;
502  cf->cfInvers = Invers;
503  cf->cfCopy = Copy;
504  cf->cfRePart = Copy;
505  // default: cf->cfImPart = ndReturn0;
506  cf->cfWriteLong = WriteShort; //WriteLong;
507  cf->cfWriteShort = WriteShort;
508  cf->cfRead = Read;
509  cf->cfNormalize = Normalize;
510 
511  //cf->cfDivComp=
512  //cf->cfIsUnit=
513  //cf->cfGetUnit=
514  //cf->cfDivBy=
515 
516  cf->cfGreater=Greater;
517  cf->cfEqual =Equal;
518  cf->cfIsZero =IsZero;
519  cf->cfIsOne =IsOne;
520  cf->cfIsMOne =IsMOne;
521  cf->cfGreaterZero=GreaterZero;
522 
523  cf->cfPower = Power;
524  //default: cf->cfGetDenom = GetDenom;
525  //default: cf->cfGetNumerator = GetNumerator;
526  cf->cfGcd = Gcd;
527  cf->cfExtGcd = ExtGcd;
528  cf->cfLcm = Lcm;
529  cf->cfDelete = Delete;
530  cf->cfSetMap = SetMap;
531  // default: cf->cfInpMult
532  // default: cf->cfInpAdd
533  cf->cfFarey =Farey;
534  cf->cfChineseRemainder=ChineseRemainder;
535  cf->cfParDeg = ParDeg;
536  cf->cfParameter = Parameter;
537  // cf->cfClearContent = ClearContent;
538  // cf->cfClearDenominators = ClearDenominators;
539  cf->convFactoryNSingN=ConvFactoryNSingN;
540  cf->convSingNFactoryN=ConvSingNFactoryN;
541  cf->cfWriteFd = WriteFd;
542  cf->cfReadFd = ReadFd;
543 #ifdef LDEBUG
544  cf->cfDBTest = DBTest;
545 #endif
546 
547  cf->iNumberOfParameters = 1;
548  char **pn=(char**)omAlloc0(sizeof(char*));
549  pn[0]=(char*)omStrDup(pp->name);
550  cf->pParameterNames = (const char **)pn;
551  cf->has_simple_Inverse= FALSE;
552  cf->has_simple_Alloc= FALSE;
553  cf->is_field=FALSE;
554 
555  return FALSE;
556 }
557 #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:354
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
const ExtensionInfo & info
< [in] sqrfree poly
nmod_poly_init(FLINTmipo, getCharacteristic())
nmod_poly_clear(FLINTmipo)
void WerrorS(const char *s)
Definition: feFopen.cc:24
static void WriteShort(number a, const coeffs r)
Definition: flintcf_Zn.cc:215
static number Lcm(number a, number b, const coeffs r)
Definition: flintcf_Zn.cc:344
static number ConvFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: flintcf_Zn.cc:412
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 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:449
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:477
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:462
static CanonicalForm ConvSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: flintcf_Zn.cc:417
BOOLEAN flintZn_InitChar(coeffs cf, void *infoStruct)
Definition: flintcf_Zn.cc:482
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 const char * Eati(const char *s, int *i)
Definition: flintcf_Zn.cc:29
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 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 char * CoeffName(const coeffs r)
Definition: flintcf_Zn.cc:422
static number IntMod(number a, number b, const coeffs c)
Definition: flintcf_Zn.cc:118
static const char * Read(const char *st, number *a, const coeffs r)
Definition: flintcf_Zn.cc:245
static int Size(number n, const coeffs r)
Definition: flintcf_Zn.cc:145
coeffs flintZnInitCfByName(char *s, n_coeffType n)
Definition: flintcf_Zn.cc:428
static number ExactDiv(number a, number b, const coeffs c)
Definition: flintcf_Zn.cc:106
#define STATIC_VAR
Definition: globaldefs.h:7
#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:675
The main handler for Singular numbers which are suitable for Singular polynomials.
const char *const nDivBy0
Definition: numbers.h:87
#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