My Project  debian-1:4.1.1-p2+ds-4build4
generics.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT: numbers (integers)
6 */
7 
8 #include "misc/auxiliary.h"
9 #include "omalloc/omalloc.h"
10 
11 #include "factory/factory.h"
12 
13 #include "misc/mylimits.h"
14 #include "reporter/reporter.h"
15 
16 #include "coeffs/coeffs.h"
17 #include "coeffs/longrat.h"
18 #include "coeffs/numbers.h"
19 
20 #include "coeffs/si_gmp.h"
21 
22 #include "coeffs/generics.h"
23 
24 #include "coeffs/rintegers.h"
25 
26 #include <string.h>
27 
29 {
30  number a1;
31  number a2;
32 };
33 typedef struct generic_pair *gcp;
35 
36 static void gCoeffWrite(const coeffs r, BOOLEAN b)
37 {
38  printf("debug: ");
39  coeffs1->cfCoeffWrite(coeffs1,b);
40 }
41 
42 char* gCoeffString(const coeffs r)
43 {
44  return coeffs1->cfCoeffString(coeffs1);
45 }
46 char* gCoeffName(const coeffs r)
47 {
48  return coeffs1->cfCoeffName(coeffs1);
49 }
51 {
52  coeffs1->cfKillChar(coeffs1);
53  coeffs2->cfKillChar(coeffs2);
54 }
56 {
57  coeffs1->cfSetChar(coeffs1);
58  coeffs2->cfSetChar(coeffs2);
59 }
60 
61 static number gMult (number a, number b, const coeffs cf)
62 {
63  gcp aa=(gcp)a;
64  gcp bb=(gcp)b;
65  gcp cc=(gcp)omalloc(sizeof(*cc));
66  cc->a1=coeffs1->cfMult(aa->a1,bb->a1,coeffs1);
67  cc->a2=coeffs2->cfMult(aa->a2,bb->a2,coeffs2);
68  n_Test((number)cc,cf);
69  return (number)cc;
70 }
71 static number gSub (number a, number b, const coeffs cf)
72 {
73  gcp aa=(gcp)a;
74  gcp bb=(gcp)b;
75  gcp cc=(gcp)omalloc(sizeof(*cc));
76  cc->a1=coeffs1->cfSub(aa->a1,bb->a1,coeffs1);
77  cc->a2=coeffs2->cfSub(aa->a2,bb->a2,coeffs2);
78  n_Test((number)cc,cf);
79  return (number)cc;
80 }
81 static number gAdd (number a, number b, const coeffs cf)
82 {
83  gcp aa=(gcp)a;
84  gcp bb=(gcp)b;
85  gcp cc=(gcp)omalloc(sizeof(*cc));
86  cc->a1=coeffs1->cfAdd(aa->a1,bb->a1,coeffs1);
87  cc->a2=coeffs2->cfAdd(aa->a2,bb->a2,coeffs2);
88  n_Test((number)cc,cf);
89  return (number)cc;
90 }
91 static number gDiv (number a, number b, const coeffs cf)
92 {
93  gcp aa=(gcp)a;
94  gcp bb=(gcp)b;
95  gcp cc=(gcp)omalloc(sizeof(*cc));
96  cc->a1=coeffs1->cfDiv(aa->a1,bb->a1,coeffs1);
97  cc->a2=coeffs2->cfDiv(aa->a2,bb->a2,coeffs2);
98  n_Test((number)cc,cf);
99  return (number)cc;
100 }
101 static number gIntMod (number a, number b, const coeffs cf)
102 {
103  gcp aa=(gcp)a;
104  gcp bb=(gcp)b;
105  gcp cc=(gcp)omalloc(sizeof(*cc));
106  cc->a1=coeffs1->cfIntMod(aa->a1,bb->a1,coeffs1);
107  cc->a2=coeffs2->cfIntMod(aa->a2,bb->a2,coeffs2);
108  n_Test((number)cc,cf);
109  return (number)cc;
110 }
111 static number gExactDiv (number a, number b, const coeffs cf)
112 {
113  gcp aa=(gcp)a;
114  gcp bb=(gcp)b;
115  gcp cc=(gcp)omalloc(sizeof(*cc));
116  cc->a1=coeffs1->cfExactDiv(aa->a1,bb->a1,coeffs1);
117  cc->a2=coeffs2->cfExactDiv(aa->a2,bb->a2,coeffs2);
118  n_Test((number)cc,cf);
119  return (number)cc;
120 }
121 static number gInit (long i, const coeffs cf)
122 {
123  gcp cc=(gcp)omalloc(sizeof(*cc));
124  cc->a1=coeffs1->cfInit(i,coeffs1);
125  cc->a2=coeffs2->cfInit(i,coeffs2);
126  n_Test((number)cc,cf);
127  return (number)cc;
128 }
129 static number gInitMPZ (mpz_t i, const coeffs cf)
130 {
131  gcp cc=(gcp)omalloc(sizeof(*cc));
132  cc->a1=coeffs1->cfInitMPZ(i,coeffs1);
133  cc->a2=coeffs2->cfInitMPZ(i,coeffs2);
134  n_Test((number)cc,cf);
135  return (number)cc;
136 }
137 static int gSize (number a, const coeffs)
138 {
139  gcp aa=(gcp)a;
140  int s1=coeffs1->cfSize(aa->a1,coeffs1);
141  int s2=coeffs2->cfSize(aa->a2,coeffs2);
142  if (s1!=s2)
143  {
144  printf("gSize: %d, %d\n",s1,s2);
145  }
146  return s1;
147 }
148 static long gInt (number &a, const coeffs)
149 {
150  gcp aa=(gcp)a;
151  long s1=coeffs1->cfInt(aa->a1,coeffs1);
152  long s2=coeffs2->cfInt(aa->a2,coeffs2);
153  if (s1!=s2)
154  {
155  printf("gInt: %ld, %ld\n",s1,s2);
156  }
157  return s1;
158 }
159 static void gMPZ(mpz_t result, number &n, const coeffs r)
160 {
161  coeffs1->cfMPZ(result,n,coeffs1);
162  mpz_t r2;
163  coeffs2->cfMPZ(r2,n,coeffs2);
164  if(mpz_cmp(result,r2)!=0)
165  {
166  printf("gMPZ\n");
167  }
168  mpz_clear(r2);
169 }
170 static number gInpNeg(number a, const coeffs r)
171 {
172  gcp aa=(gcp)a;
173  aa->a1=coeffs1->cfInpNeg(aa->a1,coeffs1);
174  aa->a2=coeffs2->cfInpNeg(aa->a2,coeffs2);
175  return (number)aa;
176 }
177 static number gInvers(number a, const coeffs r)
178 {
179  gcp aa=(gcp)a;
180  gcp cc=(gcp)omalloc(sizeof(*cc));
181  cc->a1=coeffs1->cfInvers(aa->a1,coeffs1);
182  cc->a2=coeffs2->cfInvers(aa->a2,coeffs2);
183  return (number)cc;
184 }
185 static number gCopy(number a, const coeffs r)
186 {
187  gcp aa=(gcp)a;
188  gcp cc=(gcp)omalloc(sizeof(*cc));
189  cc->a1=coeffs1->cfCopy(aa->a1,coeffs1);
190  cc->a2=coeffs2->cfCopy(aa->a2,coeffs2);
191  return (number)cc;
192 }
193 static number gRePart(number a, const coeffs r)
194 {
195  gcp aa=(gcp)a;
196  gcp cc=(gcp)omalloc(sizeof(*cc));
197  cc->a1=coeffs1->cfRePart(aa->a1,coeffs1);
198  cc->a2=coeffs2->cfRePart(aa->a2,coeffs2);
199  return (number)cc;
200 }
201 static number gImPart(number a, const coeffs r)
202 {
203  gcp aa=(gcp)a;
204  gcp cc=(gcp)omalloc(sizeof(*cc));
205  cc->a1=coeffs1->cfRePart(aa->a1,coeffs1);
206  cc->a2=coeffs2->cfRePart(aa->a2,coeffs2);
207  return (number)cc;
208 }
209 static void gWriteLong(number a, const coeffs r)
210 {
211  gcp aa=(gcp)a;
212  coeffs1->cfWriteLong(aa->a1,coeffs1);
213 }
214 static void gWriteShort(number a, const coeffs r)
215 {
216  gcp aa=(gcp)a;
217  coeffs1->cfWriteShort(aa->a1,coeffs1);
218 }
219 static const char *gRead(const char * s, number * a, const coeffs r)
220 {
221  gcp cc=(gcp)omalloc(sizeof(*cc));
222  const char* ss=coeffs1->cfRead(s,&(cc->a1),coeffs1);
223  number tmp=coeffs2->cfInit(1,coeffs2);
224  mpz_ptr tt=(mpz_ptr)tmp;
225  coeffs1->cfMPZ(tt,cc->a1,coeffs1);
226  cc->a2=(number)tt;
227  *a=(number)cc;
228  return ss;
229 }
230 static void gNormalize(number &a, const coeffs r)
231 {
232  gcp aa=(gcp)a;
233  coeffs1->cfNormalize(aa->a1,coeffs1);
234  coeffs2->cfNormalize(aa->a2,coeffs2);
235 }
236 static BOOLEAN gGreater(number a,number b, const coeffs r)
237 {
238  gcp aa=(gcp)a;
239  gcp bb=(gcp)b;
240  BOOLEAN b1=coeffs1->cfGreater(aa->a1,bb->a1,coeffs1);
241  BOOLEAN b2=coeffs2->cfGreater(aa->a2,bb->a2,coeffs2);
242  if (b1!=b2)
243  {
244  printf("gGreater\n");
245  }
246  return b1;
247 }
248 static BOOLEAN gEqual(number a,number b, const coeffs r)
249 {
250  gcp aa=(gcp)a;
251  gcp bb=(gcp)b;
252  BOOLEAN b1=coeffs1->cfEqual(aa->a1,bb->a1,coeffs1);
253  BOOLEAN b2=coeffs2->cfEqual(aa->a2,bb->a2,coeffs2);
254  if (b1!=b2)
255  {
256  printf("gEqual\n");
257  }
258  return b1;
259 }
260 static BOOLEAN gIsZero(number a, const coeffs r)
261 {
262  if (a==NULL) return TRUE;
263  gcp aa=(gcp)a;
264  BOOLEAN b1=coeffs1->cfIsZero(aa->a1,coeffs1);
265  BOOLEAN b2=coeffs2->cfIsZero(aa->a2,coeffs2);
266  if (b1!=b2)
267  {
268  printf("gIsZero\n");
269  }
270  return b1;
271 }
272 static BOOLEAN gIsOne(number a, const coeffs r)
273 {
274  gcp aa=(gcp)a;
275  BOOLEAN b1=coeffs1->cfIsOne(aa->a1,coeffs1);
276  BOOLEAN b2=coeffs2->cfIsOne(aa->a2,coeffs2);
277  if (b1!=b2)
278  {
279  printf("gIsOne\n");
280  }
281  return b1;
282 }
283 static BOOLEAN gIsMOne(number a, const coeffs r)
284 {
285  gcp aa=(gcp)a;
286  BOOLEAN b1=coeffs1->cfIsMOne(aa->a1,coeffs1);
287  BOOLEAN b2=coeffs2->cfIsMOne(aa->a2,coeffs2);
288  if (b1!=b2)
289  {
290  printf("gIsMOne\n");
291  }
292  return b1;
293 }
294 static BOOLEAN gGreaterZero(number a, const coeffs r)
295 {
296  gcp aa=(gcp)a;
297  BOOLEAN b1=coeffs1->cfGreaterZero(aa->a1,coeffs1);
298  BOOLEAN b2=coeffs2->cfGreaterZero(aa->a2,coeffs2);
299  if (b1!=b2)
300  {
301  printf("gGreaterZero\n");
302  }
303  return b1;
304 }
305 static void gPower(number a, int i, number * result, const coeffs r)
306 {
307  gcp aa=(gcp)a;
308  gcp cc=(gcp)omalloc(sizeof(*cc));
309  coeffs1->cfPower(aa->a1,i,&cc->a1,coeffs1);
310  coeffs2->cfPower(aa->a2,i,&cc->a2,coeffs2);
311  *result=(number)cc;
312 }
313 static number gGcd (number a, number b, const coeffs)
314 {
315  gcp aa=(gcp)a;
316  gcp bb=(gcp)b;
317  gcp cc=(gcp)omalloc(sizeof(*cc));
318  cc->a1=coeffs1->cfGcd(aa->a1,bb->a1,coeffs1);
319  cc->a2=coeffs2->cfGcd(aa->a2,bb->a2,coeffs2);
320  return (number)cc;
321 }
322 static number gSubringGcd (number a, number b, const coeffs)
323 {
324  gcp aa=(gcp)a;
325  gcp bb=(gcp)b;
326  gcp cc=(gcp)omalloc(sizeof(*cc));
327  cc->a1=coeffs1->cfSubringGcd(aa->a1,bb->a1,coeffs1);
328  cc->a2=coeffs2->cfSubringGcd(aa->a2,bb->a2,coeffs2);
329  return (number)cc;
330 }
331 static number gGetDenom (number &a, const coeffs)
332 {
333  gcp aa=(gcp)a;
334  gcp cc=(gcp)omalloc(sizeof(*cc));
335  cc->a1=coeffs1->cfGetDenom(aa->a1,coeffs1);
336  cc->a2=coeffs2->cfGetDenom(aa->a2,coeffs2);
337  return (number)cc;
338 }
339 static number gGetNumerator (number &a, const coeffs)
340 {
341  gcp aa=(gcp)a;
342  gcp cc=(gcp)omalloc(sizeof(*cc));
343  cc->a1=coeffs1->cfGetNumerator(aa->a1,coeffs1);
344  cc->a2=coeffs2->cfGetNumerator(aa->a2,coeffs2);
345  return (number)cc;
346 }
347 static number gQuotRem(number a, number b, number *rem, const coeffs r)
348 {
349  printf("gQuotRem\n");
350  return NULL;
351 }
352 static number gLcm(number a, number b, const coeffs r)
353 {
354  gcp aa=(gcp)a;
355  gcp bb=(gcp)b;
356  gcp cc=(gcp)omalloc(sizeof(*cc));
357  cc->a1=coeffs1->cfLcm(aa->a1,bb->a1,coeffs1);
358  cc->a2=coeffs2->cfLcm(aa->a2,bb->a2,coeffs2);
359  return (number)cc;
360 }
361 static number gNormalizeHelper(number a, number b, const coeffs r)
362 {
363  gcp aa=(gcp)a;
364  gcp bb=(gcp)b;
365  gcp cc=(gcp)omalloc(sizeof(*cc));
366  cc->a1=coeffs1->cfNormalizeHelper(aa->a1,bb->a1,coeffs1);
367  cc->a2=coeffs2->cfNormalizeHelper(aa->a2,bb->a2,coeffs2);
368  return (number)cc;
369 }
370 static void gDelete(number * a, const coeffs r)
371 {
372  if (*a!=NULL)
373  {
374  gcp aa=(gcp)*a;
375  coeffs1->cfDelete(&aa->a1,coeffs1);
376  coeffs2->cfDelete(&aa->a2,coeffs2);
377  omFree(aa);
378  *a=NULL;
379  }
380 }
381 static nMapFunc gSetMap(const coeffs src, const coeffs dst)
382 {
383  printf("gSetMap\n");
384  return NULL;
385 }
386 static void gWriteFd(number a, FILE *f, const coeffs r)
387 {
388  printf("gWriteFd\n");
389 }
390 static number gReadFd( s_buff f, const coeffs r)
391 {
392  printf("gReadFd\n");
393  return NULL;
394 }
395 static number gFarey(number p, number n, const coeffs)
396 {
397  gcp aa=(gcp)p;
398  gcp cc=(gcp)omalloc(sizeof(*cc));
399  cc->a1=coeffs1->cfFarey(aa->a1,n,coeffs1);
400  cc->a2=coeffs2->cfFarey(aa->a2,n,coeffs2);
401  return (number)cc;
402 }
403 static number gChineseRemainder(number *x, number *q,int rl, BOOLEAN sym,CFArray &inv_cache,const coeffs)
404 {
405  printf("gChineseREmainder\n");
406  return NULL;
407 }
408 static number gRandom(siRandProc p, number p1, number p2, const coeffs cf)
409 {
410  printf("gRandom\n");
411  return NULL;
412 }
413 static BOOLEAN gDivBy (number a,number b, const coeffs)
414 {
415  gcp aa=(gcp)a;
416  gcp bb=(gcp)b;
417  BOOLEAN b1=coeffs1->cfDivBy(aa->a1,bb->a1,coeffs1);
418  BOOLEAN b2=coeffs2->cfDivBy(aa->a2,bb->a2,coeffs2);
419  if (b1!=b2)
420  {
421  printf("gDivBy:%d,%d\n",b1,b2);
422  }
423  return b1;
424 }
425 static number gExtGcd (number a, number b, number *s, number *t, const coeffs)
426 {
427  gcp aa=(gcp)a;
428  gcp bb=(gcp)b;
429  gcp cc=(gcp)omalloc(sizeof(*cc));
430  gcp ss=(gcp)omalloc(sizeof(*ss));
431  gcp tt=(gcp)omalloc(sizeof(*ss));
432  cc->a1=coeffs1->cfExtGcd(aa->a1,bb->a1,&ss->a1,&tt->a1,coeffs1);
433  cc->a2=coeffs2->cfExtGcd(aa->a2,bb->a2,&ss->a2,&tt->a2,coeffs2);
434  return (number)cc;
435 }
436 static number gGetUnit (number n, const coeffs r)
437 {
438  gcp aa=(gcp)n;
439  gcp cc=(gcp)omalloc(sizeof(*cc));
440  cc->a1=coeffs1->cfGetUnit(aa->a1,coeffs1);
441  cc->a2=coeffs2->cfGetUnit(aa->a2,coeffs2);
442  return (number)cc;
443 }
444 static BOOLEAN gIsUnit (number a, const coeffs)
445 {
446  gcp aa=(gcp)a;
447  BOOLEAN b1=coeffs1->cfIsUnit(aa->a1,coeffs1);
448  BOOLEAN b2=coeffs2->cfIsUnit(aa->a2,coeffs2);
449  if (b1!=b2)
450  {
451  printf("gIsUnit:%d,%d\n",b1,b2);
452  }
453  return b1;
454 }
455 static int gDivComp(number a, number b, const coeffs r)
456 {
457  gcp aa=(gcp)a;
458  gcp bb=(gcp)b;
459  int i1=coeffs1->cfDivComp(aa->a1,bb->a1,coeffs1);
460  int i2=coeffs2->cfDivComp(aa->a2,bb->a2,coeffs2);
461  if (i1!=i2)
462  {
463  printf("gDivComp:%d,%d\n",i1,i2);
464  }
465  return i1;
466 }
467 static BOOLEAN gDBTest(number a, const char *f, const int l, const coeffs r)
468 {
469  if (a==NULL)
470  printf("NULL in %s:%d\n",f,l);
471  return TRUE;
472 }
474 {
475  coeffs1=nInitChar(n_Z_1,(void*)1);
476  coeffs2=nInitChar(n_Z_2,(void*)1);
477  r->is_field=FALSE;
478  r->is_domain=TRUE;
479  r->rep=n_rep_unknown;
480  r->ch = 0;
481  r->cfKillChar=gKillChar;
482  //r->nCoeffIsEqual=gCoeffsEqual;
483  r->cfCoeffString=gCoeffString;
484  r->cfCoeffName=gCoeffName;
485  r->cfCoeffWrite=gCoeffWrite;
486 
487  r->cfMult = gMult;
488  r->cfSub = gSub;
489  r->cfAdd = gAdd;
490  r->cfDiv = gDiv;
491  r->cfInit = gInit;
492  r->cfSize = gSize;
493  r->cfInt = gInt;
494  #ifdef HAVE_RINGS
495  r->cfDivComp = gDivComp;
496  r->cfIsUnit = gIsUnit;
497  r->cfGetUnit = gGetUnit;
498  r->cfExtGcd = gExtGcd;
499  r->cfDivBy = gDivBy;
500  #endif
501  r->cfInpNeg = gInpNeg;
502  r->cfInvers= gInvers;
503  r->cfCopy = gCopy;
504  r->cfRePart = gCopy;
505  //r->cfImPart = ndReturn0;
506  r->cfWriteLong = gWriteLong;
507  r->cfWriteShort = gWriteShort;
508  r->cfRead = gRead;
509  r->cfNormalize=gNormalize;
510  r->cfGreater = gGreater;
511  r->cfEqual = gEqual;
512  r->cfIsZero = gIsZero;
513  r->cfIsOne = gIsOne;
514  r->cfIsMOne = gIsMOne;
515  r->cfGreaterZero = gGreaterZero;
516  r->cfPower = gPower;
517  r->cfGetDenom = gGetDenom;
518  r->cfGetNumerator = gGetNumerator;
519  r->cfGcd = gGcd;
520  r->cfLcm = gGcd;
521  r->cfDelete= gDelete;
522  r->cfSetMap = gSetMap;
523  //r->cfInpMult=ndInpMult;
524  r->cfRandom=gRandom;
525  r->cfWriteFd=gWriteFd;
526  r->cfReadFd=gReadFd;
527  r->type=n_Z;
528  #ifdef LDEBUG
529  r->cfDBTest=gDBTest;
530  #endif
531  return FALSE;
532 }
533 
All the auxiliary stuff.
int BOOLEAN
Definition: auxiliary.h:85
#define TRUE
Definition: auxiliary.h:98
#define FALSE
Definition: auxiliary.h:94
int l
Definition: cfEzgcd.cc:93
int i
Definition: cfEzgcd.cc:125
Variable x
Definition: cfModGcd.cc:4023
int p
Definition: cfModGcd.cc:4019
CanonicalForm cf
Definition: cfModGcd.cc:4024
CanonicalForm b
Definition: cfModGcd.cc:4044
FILE * f
Definition: checklibs.c:9
Coefficient rings, fields and other domains suitable for Singular polynomials.
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:739
@ n_Z
only used if HAVE_RINGS is defined
Definition: coeffs.h:44
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:349
@ n_rep_unknown
Definition: coeffs.h:110
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:74
return result
Definition: facAbsBiFact.cc:76
const CanonicalForm int s
Definition: facAbsFact.cc:55
static int gDivComp(number a, number b, const coeffs r)
Definition: generics.cc:455
char * gCoeffName(const coeffs r)
Definition: generics.cc:46
static void gWriteFd(number a, FILE *f, const coeffs r)
Definition: generics.cc:386
void gSetChar(coeffs r)
Definition: generics.cc:55
static number gCopy(number a, const coeffs r)
Definition: generics.cc:185
static number gGcd(number a, number b, const coeffs)
Definition: generics.cc:313
static number gImPart(number a, const coeffs r)
Definition: generics.cc:201
static number gMult(number a, number b, const coeffs cf)
Definition: generics.cc:61
static BOOLEAN gIsMOne(number a, const coeffs r)
Definition: generics.cc:283
static void gWriteShort(number a, const coeffs r)
Definition: generics.cc:214
static BOOLEAN gDivBy(number a, number b, const coeffs)
Definition: generics.cc:413
static void gNormalize(number &a, const coeffs r)
Definition: generics.cc:230
static long gInt(number &a, const coeffs)
Definition: generics.cc:148
static number gExactDiv(number a, number b, const coeffs cf)
Definition: generics.cc:111
static number gAdd(number a, number b, const coeffs cf)
Definition: generics.cc:81
static number gRePart(number a, const coeffs r)
Definition: generics.cc:193
static BOOLEAN gIsUnit(number a, const coeffs)
Definition: generics.cc:444
static void gPower(number a, int i, number *result, const coeffs r)
Definition: generics.cc:305
static number gInpNeg(number a, const coeffs r)
Definition: generics.cc:170
static number gFarey(number p, number n, const coeffs)
Definition: generics.cc:395
static BOOLEAN gGreaterZero(number a, const coeffs r)
Definition: generics.cc:294
static number gGetUnit(number n, const coeffs r)
Definition: generics.cc:436
coeffs coeffs1
Definition: generics.cc:34
static number gInit(long i, const coeffs cf)
Definition: generics.cc:121
static number gNormalizeHelper(number a, number b, const coeffs r)
Definition: generics.cc:361
static void gCoeffWrite(const coeffs r, BOOLEAN b)
Definition: generics.cc:36
static number gIntMod(number a, number b, const coeffs cf)
Definition: generics.cc:101
number a2
Definition: generics.cc:31
static number gGetDenom(number &a, const coeffs)
Definition: generics.cc:331
static BOOLEAN gEqual(number a, number b, const coeffs r)
Definition: generics.cc:248
void gKillChar(coeffs r)
Definition: generics.cc:50
static number gGetNumerator(number &a, const coeffs)
Definition: generics.cc:339
char * gCoeffString(const coeffs r)
Definition: generics.cc:42
static number gRandom(siRandProc p, number p1, number p2, const coeffs cf)
Definition: generics.cc:408
static BOOLEAN gGreater(number a, number b, const coeffs r)
Definition: generics.cc:236
static number gExtGcd(number a, number b, number *s, number *t, const coeffs)
Definition: generics.cc:425
static void gWriteLong(number a, const coeffs r)
Definition: generics.cc:209
static number gChineseRemainder(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs)
Definition: generics.cc:403
static BOOLEAN gDBTest(number a, const char *f, const int l, const coeffs r)
Definition: generics.cc:467
coeffs coeffs2
Definition: generics.cc:34
static void gMPZ(mpz_t result, number &n, const coeffs r)
Definition: generics.cc:159
static number gSubringGcd(number a, number b, const coeffs)
Definition: generics.cc:322
BOOLEAN gInitChar(coeffs r, void *p)
Definition: generics.cc:473
static number gReadFd(s_buff f, const coeffs r)
Definition: generics.cc:390
static number gLcm(number a, number b, const coeffs r)
Definition: generics.cc:352
static nMapFunc gSetMap(const coeffs src, const coeffs dst)
Definition: generics.cc:381
static const char * gRead(const char *s, number *a, const coeffs r)
Definition: generics.cc:219
static BOOLEAN gIsZero(number a, const coeffs r)
Definition: generics.cc:260
number a1
Definition: generics.cc:30
static number gInvers(number a, const coeffs r)
Definition: generics.cc:177
static number gQuotRem(number a, number b, number *rem, const coeffs r)
Definition: generics.cc:347
static void gDelete(number *a, const coeffs r)
Definition: generics.cc:370
static number gInitMPZ(mpz_t i, const coeffs cf)
Definition: generics.cc:129
static int gSize(number a, const coeffs)
Definition: generics.cc:137
static number gSub(number a, number b, const coeffs cf)
Definition: generics.cc:71
static number gDiv(number a, number b, const coeffs cf)
Definition: generics.cc:91
static BOOLEAN gIsOne(number a, const coeffs r)
Definition: generics.cc:272
void rem(unsigned long *a, unsigned long *q, unsigned long p, int &dega, int degq)
Definition: minpoly.cc:572
The main handler for Singular numbers which are suitable for Singular polynomials.
#define omalloc(size)
Definition: omAllocDecl.h:228
#define omFree(addr)
Definition: omAllocDecl.h:261
#define NULL
Definition: omList.c:10
int(* siRandProc)()
Definition: sirandom.h:9