My Project  debian-1:4.1.1-p2+ds-4build1
gnumpfl.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT: computations with GMP floating-point numbers
6 *
7 * ngf == number gnu floats
8 */
9 
10 #include "misc/auxiliary.h"
11 #include "omalloc/omalloc.h"
12 
13 #include "reporter/reporter.h"
14 
15 #include "coeffs/coeffs.h"
16 #include "coeffs/numbers.h"
17 #include "coeffs/mpr_complex.h"
18 
19 #include "coeffs/longrat.h"
20 #include "coeffs/shortfl.h"
21 #include "coeffs/gnumpfl.h"
22 #include "coeffs/gnumpc.h"
23 #include "coeffs/modulop.h"
24 
25 const char * ngfRead (const char *s, number *a, const coeffs r);
26 
27 union nf
28 {
30  number _n;
31  nf(SI_FLOAT f) {_f = f;}
32  nf(number n) {_n = n;}
33  SI_FLOAT F() const {return _f;}
34  number N() const {return _n;}
35 };
36 
37 /*2
38 * n := i
39 */
40 static number ngfInit (long i, const coeffs r)
41 {
42  assume( getCoeffType(r) == n_long_R );
43 
44  gmp_float* n= new gmp_float( (double)i );
45  return (number)n;
46 }
47 
48 /*2
49 * convert number to int
50 */
51 static long ngfInt(number &i, const coeffs r)
52 {
53  assume( getCoeffType(r) == n_long_R );
54 
55  double d=(double)*(gmp_float*)i;
56  if (d<0.0)
57  return (long)(d-0.5);
58  else
59  return (long)(d+0.5);
60 }
61 
62 static BOOLEAN ngfIsZero (number a, const coeffs r)
63 {
64  assume( getCoeffType(r) == n_long_R );
65 
66  return ( ((gmp_float*)a)->isZero() );
67 }
68 
69 static int ngfSize(number n, const coeffs r)
70 {
71  long i = ngfInt(n, r);
72  /* basically return the largest integer in n;
73  only if this happens to be zero although n != 0,
74  return 1;
75  (this code ensures that zero has the size zero) */
76  if ((i == 0) && (ngfIsZero(n,r) == FALSE)) i = 1;
77  return ABS(i);
78 }
79 
80 /*2
81 * delete a
82 */
83 static void ngfDelete (number * a, const coeffs r)
84 {
85  assume( getCoeffType(r) == n_long_R );
86 
87  if ( *a != NULL )
88  {
89  delete *(gmp_float**)a;
90  *a=NULL;
91  }
92 }
93 
94 /*2
95 * copy a to b
96 */
97 static number ngfCopy(number a, const coeffs r)
98 {
99  assume( getCoeffType(r) == n_long_R );
100 
101  gmp_float* b= new gmp_float( *(gmp_float*)a );
102  return (number)b;
103 }
104 
105 #if 0
106 static number ngfCopyMap(number a, const coeffs r1, const coeffs r2)
107 {
108  assume( getCoeffType(r1) == n_long_R );
109  assume( getCoeffType(r2) == n_long_R );
110 
111  gmp_float* b= NULL;
112  if ( a != NULL )
113  {
114  b= new gmp_float( *(gmp_float*)a );
115  }
116  return (number)b;
117 }
118 #endif
119 
120 /*2
121 * za:= - za
122 */
123 static number ngfNeg (number a, const coeffs r)
124 {
125  assume( getCoeffType(r) == n_long_R );
126 
127  *(gmp_float*)a= -(*(gmp_float*)a);
128  return (number)a;
129 }
130 
131 /*
132 * 1/a
133 */
134 static number ngfInvers(number a, const coeffs r)
135 {
136  assume( getCoeffType(r) == n_long_R );
137 
138  gmp_float* f= NULL;
139  if (((gmp_float*)a)->isZero() )
140  {
141  WerrorS(nDivBy0);
142  }
143  else
144  {
145  f= new gmp_float( gmp_float(1) / (*(gmp_float*)a) );
146  }
147  return (number)f;
148 }
149 
150 /*2
151 * u:= a + b
152 */
153 static number ngfAdd (number a, number b, const coeffs R)
154 {
155  assume( getCoeffType(R) == n_long_R );
156 
157  gmp_float* r= new gmp_float( (*(gmp_float*)a) + (*(gmp_float*)b) );
158  return (number)r;
159 }
160 
161 /*2
162 * u:= a - b
163 */
164 static number ngfSub (number a, number b, const coeffs R)
165 {
166  assume( getCoeffType(R) == n_long_R );
167 
168  gmp_float* r= new gmp_float( (*(gmp_float*)a) - (*(gmp_float*)b) );
169  return (number)r;
170 }
171 
172 /*2
173 * u := a * b
174 */
175 static number ngfMult (number a, number b, const coeffs R)
176 {
177  assume( getCoeffType(R) == n_long_R );
178 
179  gmp_float* r= new gmp_float( (*(gmp_float*)a) * (*(gmp_float*)b) );
180  return (number)r;
181 }
182 
183 /*2
184 * u := a / b
185 */
186 static number ngfDiv (number a, number b, const coeffs r)
187 {
188  assume( getCoeffType(r) == n_long_R );
189 
190  if ( ((gmp_float*)b)->isZero() )
191  {
192  // a/0 = error
193  WerrorS(nDivBy0);
194  return NULL;
195  }
196  gmp_float* f= new gmp_float( (*(gmp_float*)a) / (*(gmp_float*)b) );
197  return (number)f;
198 }
199 
200 /*2
201 * u:= x ^ exp
202 */
203 static number ngfPower (number x, int exp, const coeffs r)
204 {
205  assume( getCoeffType(r) == n_long_R );
206 
207  if ( exp == 0 )
208  {
209  gmp_float* n = new gmp_float(1);
210  return (number)n;
211  }
212  else if ( ngfIsZero(x, r) ) // 0^e, e>0
213  {
214  return ngfInit(0, r);
215  }
216  else if ( exp == 1 )
217  {
218  return ngfCopy(x,r);
219  }
220  return (number) ( new gmp_float( (*(gmp_float*)x)^exp ) );
221 }
222 
223 /* kept for compatibility reasons, to be deleted */
224 static void ngfPower ( number x, int exp, number * u, const coeffs r )
225 {
226  *u = ngfPower(x, exp, r);
227 }
228 
229 /*2
230 * za > 0 ?
231 */
232 static BOOLEAN ngfGreaterZero (number a, const coeffs r)
233 {
234  assume( getCoeffType(r) == n_long_R );
235 
236  return (((gmp_float*)a)->sign() > 0);
237 }
238 
239 /*2
240 * a > b ?
241 */
242 static BOOLEAN ngfGreater (number a, number b, const coeffs r)
243 {
244  assume( getCoeffType(r) == n_long_R );
245 
246  return ( (*(gmp_float*)a) > (*(gmp_float*)b) );
247 }
248 
249 /*2
250 * a = b ?
251 */
252 static BOOLEAN ngfEqual (number a, number b, const coeffs r)
253 {
254  assume( getCoeffType(r) == n_long_R );
255 
256  return ( (*(gmp_float*)a) == (*(gmp_float*)b) );
257 }
258 
259 /*2
260 * a == 1 ?
261 */
262 static BOOLEAN ngfIsOne (number a, const coeffs r)
263 {
264  assume( getCoeffType(r) == n_long_R );
265 
266  return ((gmp_float*)a)->isOne();
267 }
268 
269 /*2
270 * a == -1 ?
271 */
272 static BOOLEAN ngfIsMOne (number a, const coeffs r)
273 {
274  assume( getCoeffType(r) == n_long_R );
275 
276  return ((gmp_float*)a)->isMOne();
277 }
278 
279 static char * ngfEatFloatNExp(char * s )
280 {
281  char *start= s;
282 
283  // eat floats (mantissa) like:
284  // 0.394394993, 102.203003008, .300303032, pssibly starting with -
285  if (*s == '-') s++;
286  while ((*s >= '0' && *s <= '9')||(*s == '.')) s++;
287 
288  // eat the exponent, starts with 'e' followed by '+', '-'
289  // and digits, like:
290  // e-202, e+393, accept also E7
291  if ( (s != start) && ((*s == 'e')||(*s=='E')))
292  {
293  if (*s=='E') *s='e';
294  s++; // skip 'e'/'E'
295  if ((*s == '+') || (*s == '-')) s++;
296  while ((*s >= '0' && *s <= '9')) s++;
297  }
298 
299  return s;
300 }
301 
302 /*2
303 * extracts the number a from s, returns the rest
304 *
305 * This is also called to print components of complex coefficients.
306 * Handle with care!
307 */
308 const char * ngfRead (const char * start, number * a, const coeffs r)
309 {
311 
312  char *s= (char *)start;
313 
314  //Print("%s\n",s);
315 
316  s= ngfEatFloatNExp( s );
317 
318  if (*s=='\0') // 0
319  {
320  if ( *(gmp_float**)a == NULL ) (*(gmp_float**)a)= new gmp_float();
321  (*(gmp_float**)a)->setFromStr(start);
322  }
323  else if (s==start) // 1
324  {
325  if ( *(gmp_float**)a != NULL ) delete (*(gmp_float**)a);
326  (*(gmp_float**)a)= new gmp_float(1);
327  }
328  else
329  {
330  gmp_float divisor(1.0);
331  char *start2=s;
332  if ( *s == '/' )
333  {
334  s++;
335  s= ngfEatFloatNExp( (char *)s );
336  if (s!= start2+1)
337  {
338  char tmp_c=*s;
339  *s='\0';
340  divisor.setFromStr(start2+1);
341  *s=tmp_c;
342  }
343  else
344  {
345  Werror("wrong long real format: %s",start2);
346  }
347  }
348  char c=*start2;
349  *start2='\0';
350  if ( *(gmp_float**)a == NULL ) (*(gmp_float**)a)= new gmp_float();
351  (*(gmp_float**)a)->setFromStr(start);
352  *start2=c;
353  if (divisor.isZero())
354  {
355  WerrorS(nDivBy0);
356  }
357  else
358  (**(gmp_float**)a) /= divisor;
359  }
360 
361  return s;
362 }
363 
364 /*2
365 * write a floating point number
366 */
367 static void ngfWrite (number a, const coeffs r)
368 {
369  assume( getCoeffType(r) == n_long_R );
370 
371  char *out;
372  if ( a != NULL )
373  {
374  out= floatToStr(*(gmp_float*)a, r->float_len);
375  StringAppendS(out);
376  //omFreeSize((void *)out, (strlen(out)+1)* sizeof(char) );
377  omFree( (void *)out );
378  }
379  else
380  {
381  StringAppendS("0");
382  }
383 }
384 
385 static BOOLEAN ngfCoeffIsEqual (const coeffs r, n_coeffType n, void * parameter)
386 {
387  if (n==n_long_R)
388  {
389  LongComplexInfo* p = (LongComplexInfo *)(parameter);
390  if ((p!=NULL)
391  && (p->float_len == r->float_len)
392  && (p->float_len2 == r->float_len2))
393  return TRUE;
394  }
395  return FALSE;
396 }
397 
398 static void ngfSetChar(const coeffs r)
399 {
400  setGMPFloatDigits(r->float_len, r->float_len2);
401 }
402 
403 static char* ngfCoeffString(const coeffs r)
404 {
405  char *s=(char*)omAlloc(30);
406  snprintf(s,30,"Float(%d,%d)",r->float_len,r->float_len2);
407  return s;
408 }
409 
410 static char* ngfCoeffName(const coeffs r)
411 {
412  static char ngfCoeffName_buf[30];
413  snprintf(ngfCoeffName_buf,30,"Float(%d,%d)",r->float_len,r->float_len2);
414  return ngfCoeffName_buf;
415 }
416 
417 static number ngfMapQ(number from, const coeffs src, const coeffs dst)
418 {
419  assume( getCoeffType(dst) == n_long_R );
420  assume( src->rep == n_rep_gap_rat );
421 
423  return (number)res;
424 }
425 static number ngfMapZ(number from, const coeffs aRing, const coeffs r)
426 {
427  assume( getCoeffType(r) == n_long_R );
428  assume( aRing->rep == n_rep_gap_gmp);
429 
430  if ( from != NULL )
431  {
432  if (SR_HDL(from) & SR_INT)
433  {
434  gmp_float f_i= gmp_float(SR_TO_INT(from));
435  gmp_float *res=new gmp_float(f_i);
436  return (number)res;
437  }
438  gmp_float f_i=(mpz_ptr)from;
439  gmp_float *res=new gmp_float(f_i);
440  return (number)res;
441  }
442  else
443  return NULL;
444 }
445 
446 static number ngfMapR(number from, const coeffs src, const coeffs dst)
447 {
448  assume( getCoeffType(dst) == n_long_R );
449  assume( getCoeffType(src) == n_R );
450 
451  gmp_float *res=new gmp_float((double)nf(from).F());
452  return (number)res;
453 }
454 
455 static number ngfMapP(number from, const coeffs src, const coeffs dst)
456 {
457  assume( getCoeffType(dst) == n_long_R );
458  assume( getCoeffType(src) == n_Zp );
459 
460  return ngfInit(npInt(from,src), dst); // FIXME? TODO? // extern int npInt (number &n, const coeffs r);
461 }
462 
463 static number ngfMapC(number from, const coeffs src, const coeffs dst)
464 {
465  assume( getCoeffType(dst) == n_long_R );
466  assume( getCoeffType(src) == n_long_C );
467 
468  gmp_float *res=new gmp_float(((gmp_complex*)from)->real());
469  return (number)res;
470 }
471 
472 static nMapFunc ngfSetMap(const coeffs src, const coeffs dst)
473 {
474  assume( getCoeffType(dst) == n_long_R );
475 
476  if (src->rep==n_rep_gap_rat) /*Q, Z*/
477  {
478  return ngfMapQ;
479  }
480  if (src->rep==n_rep_gap_gmp) /*Q, Z*/
481  {
482  return ngfMapZ;
483  }
484  if ((src->rep==n_rep_gmp_float) && nCoeff_is_long_R(src))
485  {
486  return ndCopyMap; //ngfCopyMap;
487  }
488  if ((src->rep==n_rep_float) && nCoeff_is_R(src))
489  {
490  return ngfMapR;
491  }
492  if ((src->rep==n_rep_gmp_complex) && nCoeff_is_long_C(src))
493  {
494  return ngfMapC;
495  }
496  if ((src->rep==n_rep_int) && nCoeff_is_Zp(src))
497  {
498  return ngfMapP;
499  }
500  return NULL;
501 }
502 
503 static void ngfCoeffWrite (const coeffs r, BOOLEAN /*details*/)
504 {
505  Print("Float(%d,%d)", r->float_len,r->float_len2); /* long R */
506 }
507 
508 BOOLEAN ngfInitChar(coeffs n, void *parameter)
509 {
510  assume( getCoeffType(n) == n_long_R );
511 
512  n->is_field=TRUE;
513  n->is_domain=TRUE;
514  n->rep=n_rep_gmp_float;
515 
516  //n->cfKillChar = ndKillChar; /* dummy */
517 
518  n->cfSetChar = ngfSetChar;
519  n->ch = 0;
520  n->cfCoeffString=ngfCoeffString;
521  n->cfCoeffName=ngfCoeffName;
522 
523  n->cfDelete = ngfDelete;
524  //n->cfNormalize=ndNormalize;
525  n->cfInit = ngfInit;
526  n->cfInt = ngfInt;
527  n->cfAdd = ngfAdd;
528  n->cfSub = ngfSub;
529  n->cfMult = ngfMult;
530  n->cfDiv = ngfDiv;
531  n->cfExactDiv= ngfDiv;
532  n->cfInpNeg = ngfNeg;
533  n->cfInvers = ngfInvers;
534  n->cfCopy = ngfCopy;
535  n->cfGreater = ngfGreater;
536  n->cfEqual = ngfEqual;
537  n->cfIsZero = ngfIsZero;
538  n->cfIsOne = ngfIsOne;
539  n->cfIsMOne = ngfIsMOne;
540  n->cfGreaterZero = ngfGreaterZero;
541  n->cfWriteLong = ngfWrite;
542  n->cfRead = ngfRead;
543  n->cfPower = ngfPower;
544  n->cfSetMap = ngfSetMap;
545  n->cfCoeffWrite = ngfCoeffWrite;
546 #ifdef LDEBUG
547  //n->cfDBTest = ndDBTest; // not yet implemented: ngfDBTest
548 #endif
549 
550  n->nCoeffIsEqual = ngfCoeffIsEqual;
551 
552  if( parameter != NULL)
553  {
554  LongComplexInfo* p = (LongComplexInfo*)parameter;
555 
556  n->float_len = p->float_len;
557  n->float_len2 = p->float_len2;
558  } else // default values, just for testing!
559  {
560  n->float_len = SHORT_REAL_LENGTH;
561  n->float_len2 = SHORT_REAL_LENGTH;
562  }
563 
564  assume( n->float_len2 >= SHORT_REAL_LENGTH );
565 
566  assume( n_NumberOfParameters(n) == 0 );
567  assume( n_ParameterNames(n) == NULL );
568 
569  return FALSE;
570 }
getCoeffType
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
n_rep_gap_rat
(number), see longrat.h
Definition: coeffs.h:111
FALSE
#define FALSE
Definition: auxiliary.h:94
floatToStr
char * floatToStr(const gmp_float &r, const unsigned int oprec)
Definition: mpr_complex.cc:578
omalloc.h
ngfSize
static int ngfSize(number n, const coeffs r)
Definition: gnumpfl.cc:68
numberFieldToFloat
gmp_float numberFieldToFloat(number num, int cf)
Definition: mpr_complex.cc:438
mpr_complex.h
ngfRead
const char * ngfRead(const char *s, number *a, const coeffs r)
Definition: gnumpfl.cc:307
nCoeff_is_Zp
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:830
StringAppendS
void StringAppendS(const char *st)
Definition: reporter.cc:106
isZero
bool isZero(const CFArray &A)
checks if entries of A are zero
Definition: facSparseHensel.h:468
f
FILE * f
Definition: checklibs.c:9
omFree
#define omFree(addr)
Definition: omAllocDecl.h:259
gmp_float::isZero
bool isZero() const
Definition: mpr_complex.cc:252
ngfMapP
static number ngfMapP(number from, const coeffs src, const coeffs dst)
Definition: gnumpfl.cc:454
nCoeff_is_R
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition: coeffs.h:849
LongComplexInfo
Definition: coeffs.h:99
x
Variable x
Definition: cfModGcd.cc:4023
ngfSub
static number ngfSub(number a, number b, const coeffs R)
Definition: gnumpfl.cc:163
ngfEatFloatNExp
static char * ngfEatFloatNExp(char *s)
Definition: gnumpfl.cc:278
SHORT_REAL_LENGTH
#define SHORT_REAL_LENGTH
Definition: numbers.h:57
n_long_C
complex floating point (GMP) numbers
Definition: coeffs.h:41
ngfCoeffWrite
static void ngfCoeffWrite(const coeffs r, BOOLEAN)
Definition: gnumpfl.cc:502
gnumpc.h
ngfDiv
static number ngfDiv(number a, number b, const coeffs r)
Definition: gnumpfl.cc:185
ngfCopy
static number ngfCopy(number a, const coeffs r)
Definition: gnumpfl.cc:96
nf::_n
number _n
Definition: gnumpfl.cc:29
n_rep_float
(float), see shortfl.h
Definition: coeffs.h:116
sign
static int sign(int x)
Definition: ring.cc:3327
ndCopyMap
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
Definition: numbers.cc:251
ngfMapQ
static number ngfMapQ(number from, const coeffs src, const coeffs dst)
Definition: gnumpfl.cc:416
auxiliary.h
ngfInvers
static number ngfInvers(number a, const coeffs r)
Definition: gnumpfl.cc:133
n_NumberOfParameters
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:804
reporter.h
n_rep_int
(int), see modulop.h
Definition: coeffs.h:110
ABS
static int ABS(int v)
Definition: auxiliary.h:110
nCoeff_is_long_C
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:907
b
CanonicalForm b
Definition: cfModGcd.cc:4044
nf
Definition: gnumpfl.cc:26
n_long_R
real floating point (GMP) numbers
Definition: coeffs.h:33
ngfAdd
static number ngfAdd(number a, number b, const coeffs R)
Definition: gnumpfl.cc:152
n_coeffType
n_coeffType
Definition: coeffs.h:26
ngfDelete
static void ngfDelete(number *a, const coeffs r)
Definition: gnumpfl.cc:82
TRUE
#define TRUE
Definition: auxiliary.h:98
i
int i
Definition: cfEzgcd.cc:125
nf::F
SI_FLOAT F() const
Definition: gnumpfl.cc:32
res
CanonicalForm res
Definition: facAbsFact.cc:64
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
nf::nf
nf(SI_FLOAT f)
Definition: gnumpfl.cc:30
setGMPFloatDigits
void setGMPFloatDigits(size_t digits, size_t rest)
Set size of mantissa digits - the number of output digits (basis 10) the size of mantissa consists of...
Definition: mpr_complex.cc:60
nDivBy0
const char *const nDivBy0
Definition: numbers.h:88
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
nf::_f
SI_FLOAT _f
Definition: gnumpfl.cc:28
ngfWrite
static void ngfWrite(number a, const coeffs r)
Definition: gnumpfl.cc:366
shortfl.h
coeffs
nCoeff_is_long_R
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:904
ngfEqual
static BOOLEAN ngfEqual(number a, number b, const coeffs r)
Definition: gnumpfl.cc:251
ngfCoeffIsEqual
static BOOLEAN ngfCoeffIsEqual(const coeffs r, n_coeffType n, void *parameter)
Definition: gnumpfl.cc:384
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
ngfMapZ
static number ngfMapZ(number from, const coeffs aRing, const coeffs r)
Definition: gnumpfl.cc:424
ngfMult
static number ngfMult(number a, number b, const coeffs R)
Definition: gnumpfl.cc:174
ngfIsZero
static BOOLEAN ngfIsZero(number a, const coeffs r)
Definition: gnumpfl.cc:61
ngfPower
static number ngfPower(number x, int exp, const coeffs r)
Definition: gnumpfl.cc:202
SR_INT
#define SR_INT
Definition: longrat.h:67
n_R
single prescision (6,6) real numbers
Definition: coeffs.h:31
n_ParameterNames
static FORCE_INLINE const char ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:808
exp
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:357
SR_TO_INT
#define SR_TO_INT(SR)
Definition: longrat.h:69
npInt
long npInt(number &n, const coeffs r)
Definition: modulop.cc:127
nf::nf
nf(number n)
Definition: gnumpfl.cc:31
gmp_float::setFromStr
void setFromStr(const char *in)
Definition: mpr_complex.cc:78
n_Zp
\F{p < 2^31}
Definition: coeffs.h:29
n_rep_gmp_float
(gmp_float), see
Definition: coeffs.h:117
Print
#define Print
Definition: emacs.cc:79
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:188
ngfIsOne
static BOOLEAN ngfIsOne(number a, const coeffs r)
Definition: gnumpfl.cc:261
ngfMapR
static number ngfMapR(number from, const coeffs src, const coeffs dst)
Definition: gnumpfl.cc:445
ngfInt
static long ngfInt(number &i, const coeffs r)
Definition: gnumpfl.cc:50
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
ngfNeg
static number ngfNeg(number a, const coeffs r)
Definition: gnumpfl.cc:122
SR_HDL
#define SR_HDL(A)
Definition: tgb.cc:35
gnumpfl.h
assume
#define assume(x)
Definition: mod2.h:384
ngfSetMap
static nMapFunc ngfSetMap(const coeffs src, const coeffs dst)
Definition: gnumpfl.cc:471
NULL
#define NULL
Definition: omList.c:9
R
#define R
Definition: sirandom.c:26
ngfGreaterZero
static BOOLEAN ngfGreaterZero(number a, const coeffs r)
Definition: gnumpfl.cc:231
ngfInit
static number ngfInit(long i, const coeffs r)
Definition: gnumpfl.cc:39
QTOF
#define QTOF
Definition: mpr_complex.h:18
p
int p
Definition: cfModGcd.cc:4019
longrat.h
ngfCoeffString
static char * ngfCoeffString(const coeffs r)
Definition: gnumpfl.cc:402
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
ngfIsMOne
static BOOLEAN ngfIsMOne(number a, const coeffs r)
Definition: gnumpfl.cc:271
ngfSetChar
static void ngfSetChar(const coeffs r)
Definition: gnumpfl.cc:397
nf::N
number N() const
Definition: gnumpfl.cc:33
SI_FLOAT
#define SI_FLOAT
Definition: shortfl.h:14
ngfMapC
static number ngfMapC(number from, const coeffs src, const coeffs dst)
Definition: gnumpfl.cc:462
ngfGreater
static BOOLEAN ngfGreater(number a, number b, const coeffs r)
Definition: gnumpfl.cc:241
numbers.h
n_rep_gmp_complex
(gmp_complex), see gnumpc.h
Definition: coeffs.h:118
gmp_float
Definition: mpr_complex.h:30
modulop.h
ngfInitChar
BOOLEAN ngfInitChar(coeffs n, void *parameter)
Initialize r.
Definition: gnumpfl.cc:507
gmp_complex
gmp_complex numbers based on
Definition: mpr_complex.h:177
ngfCoeffName
static char * ngfCoeffName(const coeffs r)
Definition: gnumpfl.cc:409
coeffs.h
n_rep_gap_gmp
(), see rinteger.h, new impl.
Definition: coeffs.h:112