shortfl.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 
5 /*
6 * ABSTRACT:
7 */
8 
9 
10 
11 #include <misc/auxiliary.h>
12 #include <misc/mylimits.h>
13 
14 #include <reporter/reporter.h>
15 
16 #include "numbers.h"
17 #include "coeffs.h"
18 #include "mpr_complex.h"
19 
20 #include "shortfl.h"
21 #include "longrat.h"
22 
23 #include <string.h>
24 #include <math.h>
25 
26 // Private interface should be hidden!!!
27 
28 BOOLEAN nrGreaterZero (number k, const coeffs r);
29 number nrMult (number a, number b, const coeffs r);
30 number nrInit (long i, const coeffs r);
31 long nrInt (number &n, const coeffs r);
32 number nrAdd (number a, number b, const coeffs r);
33 number nrSub (number a, number b, const coeffs r);
34 void nrPower (number a, int i, number * result, const coeffs r);
35 BOOLEAN nrIsZero (number a, const coeffs r);
36 BOOLEAN nrIsOne (number a, const coeffs r);
37 BOOLEAN nrIsMOne (number a, const coeffs r);
38 number nrDiv (number a, number b, const coeffs r);
39 number nrNeg (number c, const coeffs r);
40 number nrInvers (number c, const coeffs r);
41 BOOLEAN nrGreater (number a, number b, const coeffs r);
42 BOOLEAN nrEqual (number a, number b, const coeffs r);
43 void nrWrite (number a, const coeffs r);
44 const char * nrRead (const char *s, number *a, const coeffs r);
45 
46 #ifdef LDEBUG
47 BOOLEAN nrDBTest(number a, const coeffs r, const char *f, const int l);
48 #endif
49 
50 /// Get a mapping function from src into the domain of this type: n_R
51 nMapFunc nrSetMap(const coeffs src, const coeffs dst);
52 
53 // Where are the following used?
54 // int nrGetChar();
55 number nrMapQ(number from, const coeffs r, const coeffs aRing);
56 
57 static const float nrEps = 1.0e-3;
58 
59 union nf
60 {
61  float _f;
62  number _n;
63 
64  nf(float f): _f(f){};
65 
66  nf(number n): _n(n){};
67 
68  inline float F() const {return _f;}
69  inline number N() const {return _n;}
70 };
71 
72 
73 
74 
75 float nrFloat(number n)
76 {
77  return nf(n).F();
78 }
79 
80 
81 void nrCoeffWrite (const coeffs r, BOOLEAN /*details*/)
82 {
83  assume( getCoeffType(r) == n_R );
84  PrintS("// characteristic : 0 (real)\n"); /* R */
85 }
86 
87 
88 BOOLEAN nrGreaterZero (number k, const coeffs r)
89 {
90  assume( getCoeffType(r) == n_R );
91 
92  return nf(k).F() >= 0.0;
93 }
94 
95 number nrMult (number a,number b, const coeffs r)
96 {
97  assume( getCoeffType(r) == n_R );
98 
99  return nf(nf(a).F() * nf(b).F()).N();
100 }
101 
102 /*2
103 * create a number from int
104 */
105 number nrInit (long i, const coeffs r)
106 {
107  assume( getCoeffType(r) == n_R );
108 
109  float f = (float)i;
110  return nf(nf(f).F()).N();
111 }
112 
113 /*2
114 * convert a number to int
115 */
116 long nrInt(number &n, const coeffs r)
117 {
118  assume( getCoeffType(r) == n_R );
119 
120  long i;
121  float f = nf(n).F();
122  if (((float)(-MAX_INT_VAL-1) <= f) || ((float)MAX_INT_VAL >= f))
123  i = (long)f;
124  else
125  i = 0;
126  return i;
127 }
128 
129 int nrSize(number n, const coeffs)
130 {
131  float f = nf(n).F();
132  int i = (int)f;
133  /* basically return the largest integer in n;
134  only if this happens to be zero although n != 0,
135  return 1;
136  (this code ensures that zero has the size zero) */
137  if ((f != 0.0) & (i == 0)) i = 1;
138  return i;
139 }
140 
141 number nrAdd (number a, number b, const coeffs r)
142 {
143  assume( getCoeffType(r) == n_R );
144 
145  float x = nf(a).F();
146  float y = nf(b).F();
147  float f = x + y;
148  if (x > 0.0)
149  {
150  if (y < 0.0)
151  {
152  x = f / (x - y);
153  if (x < 0.0)
154  x = -x;
155  if (x < nrEps)
156  f = 0.0;
157  }
158  }
159  else
160  {
161  if (y > 0.0)
162  {
163  x = f / (y - x);
164  if (x < 0.0)
165  x = -x;
166  if (x < nrEps)
167  f = 0.0;
168  }
169  }
170  return nf(f).N();
171 }
172 
173 number nrSub (number a, number b, const coeffs r)
174 {
175  assume( getCoeffType(r) == n_R );
176 
177  float x = nf(a).F();
178  float y = nf(b).F();
179  float f = x - y;
180  if (x > 0.0)
181  {
182  if (y > 0.0)
183  {
184  x = f / (x + y);
185  if (x < 0.0)
186  x = -x;
187  if (x < nrEps)
188  f = 0.0;
189  }
190  }
191  else
192  {
193  if (y < 0.0)
194  {
195  x = f / (x + y);
196  if (x < 0.0)
197  x = -x;
198  if (x < nrEps)
199  f = 0.0;
200  }
201  }
202  return nf(f).N();
203 }
204 
205 BOOLEAN nrIsZero (number a, const coeffs r)
206 {
207  assume( getCoeffType(r) == n_R );
208 
209  return (0.0 == nf(a).F());
210 }
211 
212 BOOLEAN nrIsOne (number a, const coeffs r)
213 {
214  assume( getCoeffType(r) == n_R );
215 
216  float aa=nf(a).F()-1.0;
217  if (aa<0.0) aa=-aa;
218  return (aa<nrEps);
219 }
220 
221 BOOLEAN nrIsMOne (number a, const coeffs r)
222 {
223  assume( getCoeffType(r) == n_R );
224 
225  float aa=nf(a).F()+1.0;
226  if (aa<0.0) aa=-aa;
227  return (aa<nrEps);
228 }
229 
230 number nrDiv (number a,number b, const coeffs r)
231 {
232  assume( getCoeffType(r) == n_R );
233 
234  float n = nf(b).F();
235  if (n == 0.0)
236  {
237  WerrorS(nDivBy0);
238  return nf((float)0.0).N();
239  }
240  else
241  return nf(nf(a).F() / n).N();
242 }
243 
244 number nrInvers (number c, const coeffs r)
245 {
246  assume( getCoeffType(r) == n_R );
247 
248  float n = nf(c).F();
249  if (n == 0.0)
250  {
251  WerrorS(nDivBy0);
252  return nf((float)0.0).N();
253  }
254  return nf(1.0 / n).N();
255 }
256 
257 number nrNeg (number c, const coeffs r)
258 {
259  assume( getCoeffType(r) == n_R );
260 
261  return nf(-nf(c).F()).N();
262 }
263 
264 BOOLEAN nrGreater (number a,number b, const coeffs r)
265 {
266  assume( getCoeffType(r) == n_R );
267 
268  return nf(a).F() > nf(b).F();
269 }
270 
271 BOOLEAN nrEqual (number a,number b, const coeffs r)
272 {
273  assume( getCoeffType(r) == n_R );
274 
275  number x = nrSub(a,b,r);
276  return nf(x).F() == nf((float)0.0).F();
277 }
278 
279 void nrWrite (number a, const coeffs r)
280 {
281  assume( getCoeffType(r) == n_R );
282 
283  char ch[11];
284  int n = sprintf(ch,"%9.3e", nf(a).F());
285  if (ch[0] == '-')
286  {
287  char* chbr = new char[n+3];
288  memcpy(&chbr[2],&ch[1],n-1);
289  chbr[0] = '-';
290  chbr[1] = '(';
291  chbr[n+1] = ')';
292  chbr[n+2] = '\0';
293  StringAppendS(chbr);
294  delete chbr;
295  }
296  else
297  StringAppend("(%s)",ch);
298 }
299 
300 #if 0
301 void nrPower (number a, int i, number * result, const coeffs r)
302 {
303  assume( getCoeffType(r) == n_R );
304 
305  if (i==0)
306  {
307  *result = nf(nf(1.0).F()).N();
308  return;
309  }
310  if (i==1)
311  {
312  *result = nf(nf(a).F()).N();
313  return;
314  }
315  nrPower(a,i-1,result,r);
316  *result = nf(nf(a).F() * nf(*result).F()).N();
317 }
318 #endif
319 
320 namespace {
321  static const char* nrEatr(const char *s, float *r)
322  {
323  int i;
324 
325  if (*s >= '0' && *s <= '9')
326  {
327  *r = 0.0;
328  do
329  {
330  *r *= 10.0;
331  i = *s++ - '0';
332  *r += (float)i;
333  }
334  while (*s >= '0' && *s <= '9');
335  }
336  else *r = 1.0;
337  return s;
338  }
339 }
340 
341 const char * nrRead (const char *s, number *a, const coeffs r)
342 {
343 
344  assume( getCoeffType(r) == n_R );
345 
346  static const char *nIllegalChar="illegal character in number";
347 
348  const char *t;
349  const char *start=s;
350  float z1,z2;
351  float n=1.0;
352 
353  s = nrEatr(s, &z1);
354  if (*s == '/')
355  {
356  if (s==start) { WerrorS(nIllegalChar);return s; }
357  s++;
358  s = nrEatr(s, &z2);
359  if (z2==0.0)
360  WerrorS(nDivBy0);
361  else
362  z1 /= z2;
363  }
364  else if (*s =='.')
365  {
366  if (s==start) { WerrorS(nIllegalChar);return s; }
367  s++;
368  t = s;
369  while (*t >= '0' && *t <= '9')
370  {
371  t++;
372  n *= 10.0;
373  }
374  s = nrEatr(s, &z2);
375  z1 = (z1*n + z2) / n;
376  if (*s=='e')
377  {
378  int e=0; /* exponent */
379  int si=1;/* sign of exponent */
380  s++;
381  if (*s=='+') s++;
382  else if (*s=='-') {s++; si=-1; }
383  while (*s >= '0' && *s <= '9')
384  {
385  e=e*10+(*s)-'0';
386  s++;
387  }
388  if (si==1)
389  {
390  while (e>0) {z1*=10.0; e--; }
391  }
392  else
393  {
394  while (e>0) {z1/=10.0; e--; }
395  }
396  }
397  }
398  *a = nf(z1).N();
399  return s;
400 }
401 
402 
403 // the last used charcteristic
404 // int nrGetChar(){ return 0; }
405 
406 
407 #ifdef LDEBUG
408 /*2
409 * test valid numbers: not implemented yet
410 */
411 #pragma GCC diagnostic ignored "-Wunused-parameter"
412 BOOLEAN nrDBTest(number a, const char *f, const int l, const coeffs r)
413 {
414  assume( getCoeffType(r) == n_R );
415 
416  return TRUE;
417 }
418 #endif
419 
420 static number nrMapP(number from, const coeffs aRing, const coeffs r)
421 {
422  assume( getCoeffType(r) == n_R );
423  assume( getCoeffType(aRing) == n_Zp );
424 
425  int i = (int)((long)from);
426  float f = (float)i;
427  return nf(f).N();
428 }
429 
430 static number nrMapLongR(number from, const coeffs aRing, const coeffs r)
431 {
432  assume( getCoeffType(r) == n_R );
433  assume( getCoeffType(aRing) == n_long_R );
434 
435  float t =(float)mpf_get_d((mpf_srcptr)from);
436  return nf(t).N();
437 }
438 
439 static number nrMapC(number from, const coeffs aRing, const coeffs r)
440 {
441  assume( getCoeffType(r) == n_R );
442  assume( getCoeffType(aRing) == n_long_C );
443 
444  gmp_float h = ((gmp_complex*)from)->real();
445  float t =(float)mpf_get_d((mpf_srcptr)&h);
446  return nf(t).N();
447 }
448 
449 
450 number nrMapQ(number from, const coeffs aRing, const coeffs r)
451 {
452 /* in longrat.h
453 #define SR_INT 1
454 #define mpz_size1(A) (ABS((A)->_mp_size))
455 */
456 #define SR_HDL(A) ((long)(A))
457 #define IS_INT(A) ((A)->s==3)
458 #define IS_IMM(A) (SR_HDL(A) & SR_INT)
459 #define GET_NOM(A) ((A)->z)
460 #define GET_DENOM(A) ((A)->n)
461 
462  assume( getCoeffType(r) == n_R );
463  assume( aRing->rep == n_rep_gap_rat );
464 
465  mpz_ptr z;
466  mpz_ptr zz=NULL;
467  if (IS_IMM(from))
468  {
469  zz=(mpz_ptr)omAlloc(sizeof(mpz_t));
470  mpz_init_set_si(zz,SR_TO_INT(from));
471  z=zz;
472  }
473  else
474  {
475  /* read out the enumerator */
476  z=GET_NOM(from);
477  }
478 
479  int i = mpz_size1(z);
480  mpf_t e;
481  mpf_init(e);
482  mpf_set_z(e,z);
483  int sign= mpf_sgn(e);
484  mpf_abs (e, e);
485 
486  if (zz!=NULL)
487  {
488  mpz_clear(zz);
489  omFreeSize(zz,sizeof(mpz_t));
490  }
491  /* if number was an integer, we are done*/
492  if(IS_IMM(from)|| IS_INT(from))
493  {
494  if(i>4)
495  {
496  WerrorS("float overflow");
497  return nf(0.0).N();
498  }
499  double basis;
500  signed long int exp;
501  basis = mpf_get_d_2exp(&exp, e);
502  float f= sign*ldexp(basis,exp);
503  mpf_clear(e);
504  return nf(f).N();
505  }
506 
507  /* else read out the denominator */
508  mpz_ptr n = GET_DENOM(from);
509  int j = mpz_size1(n);
510  if(j-i>4)
511  {
512  WerrorS("float overflow");
513  mpf_clear(e);
514  return nf(0.0).N();
515  }
516  mpf_t d;
517  mpf_init(d);
518  mpf_set_z(d,n);
519 
520  /* and compute the quotient */
521  mpf_t q;
522  mpf_init(q);
523  mpf_div(q,e,d);
524 
525  double basis;
526  signed long int exp;
527  basis = mpf_get_d_2exp(&exp, q);
528  float f = sign*ldexp(basis,exp);
529  mpf_clear(e);
530  mpf_clear(d);
531  mpf_clear(q);
532  return nf(f).N();
533 }
534 
535 number nrMapZ(number from, const coeffs aRing, const coeffs r)
536 {
537  assume( getCoeffType(r) == n_R );
538  assume( aRing->rep == n_rep_gap_gmp );
539 
540  mpz_ptr z;
541  mpz_ptr zz=NULL;
542  if (IS_IMM(from))
543  {
544  zz=(mpz_ptr)omAlloc(sizeof(mpz_t));
545  mpz_init_set_si(zz,SR_TO_INT(from));
546  z=zz;
547  }
548  else
549  {
550  /* read out the enumerator */
551  z=(mpz_ptr)from;
552  }
553 
554  int i = mpz_size1(z);
555  mpf_t e;
556  mpf_init(e);
557  mpf_set_z(e,z);
558  int sign= mpf_sgn(e);
559  mpf_abs (e, e);
560 
561  if (zz!=NULL)
562  {
563  mpz_clear(zz);
564  omFreeSize(zz,sizeof(mpz_t));
565  }
566  if(i>4)
567  {
568  WerrorS("float overflow");
569  return nf(0.0).N();
570  }
571  double basis;
572  signed long int exp;
573  basis = mpf_get_d_2exp(&exp, e);
574  float f= sign*ldexp(basis,exp);
575  mpf_clear(e);
576  return nf(f).N();
577 }
578 
579 // old version:
580 // number nrMapQ(number from, const coeffs aRing, const coeffs r)
581 // {
582 // /* in longrat.h
583 // #define SR_INT 1
584 // #define mpz_size1(A) (ABS((A)->_mp_size))
585 // */
586 // #define SR_HDL(A) ((long)(A))
587 // #define mpz_isNeg(A) ((A)->_mp_size<0)
588 // #define mpz_limb_size(A) ((A)->_mp_size)
589 // #define mpz_limb_d(A) ((A)->_mp_d)
590 // #define MPZ_DIV(A,B,C) mpz_tdiv_q((A),(B),(C))
591 // #define IS_INT(A) ((A)->s==3)
592 // #define IS_IMM(A) (SR_HDL(A)&SR_INT)
593 // #define GET_NOM(A) ((A)->z)
594 // #define GET_DENOM(A) ((A)->n)
595 // #define MPZ_INIT mpz_init
596 // #define MPZ_CLEAR mpz_clear
597 
598 // assume( getCoeffType(r) == n_R );
599 // assume( getCoeffType(aRing) == n_Q );
600 
601 // mpz_t h;
602 // mpz_ptr g,z,n;
603 // int i,j,t,s;
604 // float ba,rr,rn,y;
605 
606 // if (IS_IMM(from))
607 // return nf((float)nlInt(from,NULL /* dummy for nlInt*/)).N();
608 // z=GET_NOM(from);
609 // s=0X10000;
610 // ba=(float)s;
611 // ba*=ba;
612 // rr=0.0;
613 // i=mpz_size1(z);
614 // if(IS_INT(from))
615 // {
616 // if(i>4)
617 // {
618 // WerrorS("float overflow");
619 // return nf(rr).N();
620 // }
621 // i--;
622 // rr=(float)mpz_limb_d(z)[i];
623 // while(i>0)
624 // {
625 // i--;
626 // y=(float)mpz_limb_d(z)[i];
627 // rr=rr*ba+y;
628 // }
629 // if(mpz_isNeg(z))
630 // rr=-rr;
631 // return nf(rr).N();
632 // }
633 // n=GET_DENOM(from);
634 // j=s=mpz_limb_size(n);
635 // if(j>i)
636 // {
637 // g=n; n=z; z=g;
638 // t=j; j=i; i=t;
639 // }
640 // t=i-j;
641 // if(t>4)
642 // {
643 // if(j==s)
644 // WerrorS("float overflow");
645 // return nf(rr).N();
646 // }
647 // if(t>1)
648 // {
649 // g=h;
650 // MPZ_INIT(g);
651 // MPZ_DIV(g,z,n);
652 // t=mpz_size1(g);
653 // if(t>4)
654 // {
655 // MPZ_CLEAR(g);
656 // if(j==s)
657 // WerrorS("float overflow");
658 // return nf(rr).N();
659 // }
660 // t--;
661 // rr=(float)mpz_limb_d(g)[t];
662 // while(t)
663 // {
664 // t--;
665 // y=(float)mpz_limb_d(g)[t];
666 // rr=rr*ba+y;
667 // }
668 // MPZ_CLEAR(g);
669 // if(j!=s)
670 // rr=1.0/rr;
671 // if(mpz_isNeg(z))
672 // rr=-rr;
673 // return nf(rr).N();
674 // }
675 // rn=(float)mpz_limb_d(n)[j-1];
676 // rr=(float)mpz_limb_d(z)[i-1];
677 // if(j>1)
678 // {
679 // rn=rn*ba+(float)mpz_limb_d(n)[j-2];
680 // rr=rr*ba+(float)mpz_limb_d(z)[i-2];
681 // i--;
682 // }
683 // if(t!=0)
684 // rr=rr*ba+(float)mpz_limb_d(z)[i-2];
685 // if(j==s)
686 // rr=rr/rn;
687 // else
688 // rr=rn/rr;
689 // if(mpz_isNeg(z))
690 // rr=-rr;
691 // return nf(rr).N();
692 // }
693 
694 nMapFunc nrSetMap(const coeffs src, const coeffs dst)
695 {
696  assume( getCoeffType(dst) == n_R );
697 
698  if (src->rep==n_rep_gap_rat) /*Q, Z */
699  {
700  return nrMapQ;
701  }
702  if (src->rep==n_rep_gap_gmp) /*Q, Z */
703  {
704  return nrMapZ;
705  }
706  if ((src->rep==n_rep_gmp_float) && nCoeff_is_long_R(src))
707  {
708  return nrMapLongR;
709  }
710  if ((src->rep==n_rep_float) && nCoeff_is_R(src))
711  {
712  return ndCopyMap;
713  }
714  if ((src->rep==n_rep_int) && nCoeff_is_Zp(src))
715  {
716  return nrMapP;
717  }
718  if ((src->rep==n_rep_gmp_complex) && nCoeff_is_long_C(src))
719  {
720  return nrMapC;
721  }
722  return NULL;
723 }
724 
725 static char* nrCoeffString(const coeffs r)
726 {
727  return omStrDup("real");
728 }
729 
731 {
732  assume( getCoeffType(n) == n_R );
733 
734  assume( p == NULL );
735 
736  n->is_field=TRUE;
737  n->is_domain=TRUE;
738  n->rep=n_rep_float;
739 
740  //n->cfKillChar = ndKillChar; /* dummy */
741  n->ch = 0;
742  n->cfCoeffString = nrCoeffString;
743 
744  n->cfInit = nrInit;
745  n->cfInt = nrInt;
746  n->cfAdd = nrAdd;
747  n->cfSub = nrSub;
748  n->cfMult = nrMult;
749  n->cfDiv = nrDiv;
750  n->cfExactDiv= nrDiv;
751  n->cfInpNeg = nrNeg;
752  n->cfInvers= nrInvers;
753  //n->cfCopy = ndCopy;
754  n->cfGreater = nrGreater;
755  n->cfEqual = nrEqual;
756  n->cfIsZero = nrIsZero;
757  n->cfIsOne = nrIsOne;
758  n->cfIsMOne = nrIsMOne;
759  n->cfGreaterZero = nrGreaterZero;
760  n->cfWriteLong = nrWrite;
761  n->cfRead = nrRead;
762  //n->cfPower = nrPower;
763  n->cfSetMap = nrSetMap;
764  n->cfCoeffWrite = nrCoeffWrite;
765 
766  /* nName= ndName; */
767  /*nSize = ndSize;*/
768 #ifdef LDEBUG
769  //n->cfDBTest=ndDBTest; // not yet implemented: nrDBTest;
770 #endif
771 
772  //n->nCoeffIsEqual = ndCoeffIsEqual;
773 
774  n->float_len = SHORT_REAL_LENGTH;
775  n->float_len2 = SHORT_REAL_LENGTH;
776 
777  // TODO: Any variables?
778  return FALSE;
779 }
static number nrMapP(number from, const coeffs aRing, const coeffs r)
Definition: shortfl.cc:420
number nrMapZ(number from, const coeffs aRing, const coeffs r)
Definition: shortfl.cc:535
BOOLEAN nrInitChar(coeffs n, void *p)
Initialize r.
Definition: shortfl.cc:730
const CanonicalForm int s
Definition: facAbsFact.cc:55
BOOLEAN nrGreaterZero(number k, const coeffs r)
Definition: shortfl.cc:88
number nrMult(number a, number b, const coeffs r)
Definition: shortfl.cc:95
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
static number nrMapLongR(number from, const coeffs aRing, const coeffs r)
Definition: shortfl.cc:430
BOOLEAN nrEqual(number a, number b, const coeffs r)
Definition: shortfl.cc:271
const poly a
Definition: syzextra.cc:212
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:834
#define SHORT_REAL_LENGTH
Definition: numbers.h:54
#define FALSE
Definition: auxiliary.h:95
number nrSub(number a, number b, const coeffs r)
Definition: shortfl.cc:173
#define GET_NOM(A)
return P p
Definition: myNF.cc:203
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
Definition: numbers.cc:244
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:905
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition: coeffs.h:850
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
{p < 2^31}
Definition: coeffs.h:30
(), see rinteger.h, new impl.
Definition: coeffs.h:112
nf(float f)
Definition: shortfl.cc:64
int nrSize(number n, const coeffs)
Definition: shortfl.cc:129
#define TRUE
Definition: auxiliary.h:99
void WerrorS(const char *s)
Definition: feFopen.cc:24
int k
Definition: cfEzgcd.cc:93
gmp_complex numbers based on
Definition: mpr_complex.h:178
nf(number n)
Definition: shortfl.cc:66
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:908
#define omAlloc(size)
Definition: omAllocDecl.h:210
void nrPower(number a, int i, number *result, const coeffs r)
number nrDiv(number a, number b, const coeffs r)
Definition: shortfl.cc:230
real floating point (GMP) numbers
Definition: coeffs.h:34
number _n
Definition: gnumpfl.cc:60
Definition: gnumpfl.cc:57
single prescision (6,6) real numbers
Definition: coeffs.h:32
const char * nrRead(const char *s, number *a, const coeffs r)
Definition: shortfl.cc:341
number nrAdd(number a, number b, const coeffs r)
Definition: shortfl.cc:141
const ring r
Definition: syzextra.cc:208
float nrFloat(number n)
Converts a n_R number into a float. Needed by Maps.
Definition: shortfl.cc:75
Coefficient rings, fields and other domains suitable for Singular polynomials.
static number nrMapC(number from, const coeffs aRing, const coeffs r)
Definition: shortfl.cc:439
int j
Definition: myNF.cc:70
void nrWrite(number a, const coeffs r)
Definition: shortfl.cc:279
#define assume(x)
Definition: mod2.h:403
The main handler for Singular numbers which are suitable for Singular polynomials.
void StringAppendS(const char *st)
Definition: reporter.cc:107
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
complex floating point (GMP) numbers
Definition: coeffs.h:42
(gmp_complex), see gnumpc.h
Definition: coeffs.h:118
const int MAX_INT_VAL
Definition: mylimits.h:12
BOOLEAN nrIsMOne(number a, const coeffs r)
Definition: shortfl.cc:221
number nrInvers(number c, const coeffs r)
Definition: shortfl.cc:244
All the auxiliary stuff.
BOOLEAN nrDBTest(number a, const coeffs r, const char *f, const int l)
const char *const nDivBy0
Definition: numbers.h:83
static const float nrEps
Definition: shortfl.cc:57
#define StringAppend
Definition: emacs.cc:82
FILE * f
Definition: checklibs.c:7
int i
Definition: cfEzgcd.cc:123
void PrintS(const char *s)
Definition: reporter.cc:284
nMapFunc nrSetMap(const coeffs src, const coeffs dst)
Get a mapping function from src into the domain of this type: n_R.
Definition: shortfl.cc:694
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:425
number nrInit(long i, const coeffs r)
Definition: shortfl.cc:105
number nrMapQ(number from, const coeffs r, const coeffs aRing)
Definition: shortfl.cc:450
#define SR_TO_INT(SR)
Definition: longrat.h:70
(number), see longrat.h
Definition: coeffs.h:111
void nrCoeffWrite(const coeffs r, BOOLEAN)
Definition: shortfl.cc:81
#define mpz_size1(A)
Definition: si_gmp.h:12
#define NULL
Definition: omList.c:10
#define IS_INT(A)
float F() const
Definition: shortfl.cc:68
(gmp_float), see
Definition: coeffs.h:117
BOOLEAN nrIsOne(number a, const coeffs r)
Definition: shortfl.cc:212
Variable x
Definition: cfModGcd.cc:4023
static char * nrCoeffString(const coeffs r)
Definition: shortfl.cc:725
number nrNeg(number c, const coeffs r)
Definition: shortfl.cc:257
p exp[i]
Definition: DebugPrint.cc:39
long nrInt(number &n, const coeffs r)
Definition: shortfl.cc:116
(int), see modulop.h
Definition: coeffs.h:110
BOOLEAN nrIsZero(number a, const coeffs r)
Definition: shortfl.cc:205
static Poly * h
Definition: janet.cc:978
int BOOLEAN
Definition: auxiliary.h:86
BOOLEAN nrGreater(number a, number b, const coeffs r)
Definition: shortfl.cc:264
#define GET_DENOM(A)
const poly b
Definition: syzextra.cc:213
number N() const
Definition: shortfl.cc:69
static int sign(int x)
Definition: ring.cc:3328
#define IS_IMM(A)
int l
Definition: cfEzgcd.cc:94
return result
Definition: facAbsBiFact.cc:76
(float), see shortfl.h
Definition: coeffs.h:116
float _f
Definition: gnumpfl.cc:59
#define omStrDup(s)
Definition: omAllocDecl.h:263