My Project  UNKNOWN_GIT_VERSION
gnumpc.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT: computations with GMP complex floating-point numbers
6 *
7 * ngc == number gnu complex
8 */
9 #include "misc/auxiliary.h"
10 #include "omalloc/omalloc.h"
11 
12 #include "misc/mylimits.h"
13 #include "reporter/reporter.h"
14 
15 #include "coeffs/coeffs.h"
16 #include "coeffs/numbers.h"
17 
18 #include "coeffs/mpr_complex.h"
19 
20 #include "coeffs/gnumpc.h"
21 #include "coeffs/longrat.h"
22 #include "coeffs/gnumpfl.h"
23 #include "coeffs/modulop.h"
24 #include "coeffs/shortfl.h"
25 
26 #ifdef LDEBUG
27 BOOLEAN ngcDBTest(number a, const char *f, const int l, const coeffs r);
28 #endif
29 
30 
31 #ifdef LDEBUG
32 // not yet implemented
33 BOOLEAN ngcDBTest(number, const char *, const int, const coeffs r)
34 {
35  assume( getCoeffType(r) == n_long_C );
36 
37  return TRUE;
38 }
39 #endif
40 
41 static number ngcParameter(int i, const coeffs r)
42 {
43  assume( getCoeffType(r) == n_long_C );
44  assume(i==1);
45 
46  if( i == 1 )
47  return (number)(new gmp_complex( 0L, 1L ));
48 
49  return NULL; // new gmp_complex( ) // 0?
50 }
51 
52 /*2
53 * n := i
54 */
55 static number ngcInit (long i, const coeffs r)
56 {
57  assume( getCoeffType(r) == n_long_C );
58 
59  gmp_complex* n= new gmp_complex( (long)i, 0L );
60 
61  return (number)n;
62 }
63 
64 /*2
65 * convert number to int
66 */
67 static long ngcInt(number &i, const coeffs r)
68 {
69  assume( getCoeffType(r) == n_long_C );
70 
71  return ((gmp_complex*)i)->real();
72 }
73 
74 static BOOLEAN ngcIsZero (number a, const coeffs r)
75 {
76  assume( getCoeffType(r) == n_long_C );
77 
78  return ( ((gmp_complex*)a)->real().isZero() && ((gmp_complex*)a)->imag().isZero());
79 }
80 
81 static int ngcSize(number n, const coeffs R)
82 {
83  int r = (int)((gmp_complex*)n)->real();
84  if (r < 0) r = -r;
85  int i = (int)((gmp_complex*)n)->imag();
86  if (i < 0) i = -i;
87  int oneNorm = r + i;
88  /* basically return the 1-norm of n;
89  only if this happens to be zero although n != 0,
90  return 1;
91  (this code ensures that zero has the size zero) */
92  if ((oneNorm == 0.0) & (ngcIsZero(n,R) == FALSE)) oneNorm = 1;
93  return oneNorm;
94 }
95 
96 /*2
97 * delete a
98 */
99 static void ngcDelete (number * a, const coeffs r)
100 {
101  assume( getCoeffType(r) == n_long_C );
102 
103  if ( *a != NULL )
104  {
105  delete *(gmp_complex**)a;
106  *a=NULL;
107  }
108 }
109 
110 /*2
111  * copy a to b
112 */
113 static number ngcCopy(number a, const coeffs r)
114 {
115  assume( getCoeffType(r) == n_long_C );
116 
117  gmp_complex* b= new gmp_complex( *(gmp_complex*)a );
118  return (number)b;
119 }
120 
121 
122 /*2
123 * za:= - za
124 */
125 static number ngcNeg (number a, const coeffs R)
126 {
127  assume( getCoeffType(R) == n_long_C );
128 
129  gmp_complex* r=(gmp_complex*)a;
130  (*r).neg();
131  return (number)a;
132 }
133 
134 /*
135 * 1/a
136 */
137 static number ngcInvers(number a, const coeffs R)
138 {
139  assume( getCoeffType(R) == n_long_C );
140 
141  gmp_complex* r = NULL;
142  if (((gmp_complex*)a)->isZero())
143  {
144  WerrorS(nDivBy0);
145  }
146  else
147  {
148  r = new gmp_complex( (gmp_complex)1 / (*(gmp_complex*)a) );
149  }
150  return (number)r;
151 }
152 
153 /*2
154 * u:= a + b
155 */
156 static number ngcAdd (number a, number b, const coeffs R)
157 {
158  assume( getCoeffType(R) == n_long_C );
159 
160  gmp_complex* r= new gmp_complex( (*(gmp_complex*)a) + (*(gmp_complex*)b) );
161  return (number)r;
162 }
163 
164 /*2
165 * u:= a - b
166 */
167 static number ngcSub (number a, number b, const coeffs R)
168 {
169  assume( getCoeffType(R) == n_long_C );
170 
171  gmp_complex* r= new gmp_complex( (*(gmp_complex*)a) - (*(gmp_complex*)b) );
172  return (number)r;
173 }
174 
175 /*2
176 * u := a * b
177 */
178 static number ngcMult (number a, number b, const coeffs R)
179 {
180  assume( getCoeffType(R) == n_long_C );
181 
182  gmp_complex* r= new gmp_complex( (*(gmp_complex*)a) * (*(gmp_complex*)b) );
183  return (number)r;
184 }
185 
186 /*2
187 * u := a / b
188 */
189 static number ngcDiv (number a, number b, const coeffs r)
190 {
191  assume( getCoeffType(r) == n_long_C );
192 
193  if (((gmp_complex*)b)->isZero())
194  {
195  // a/0 = error
196  WerrorS(nDivBy0);
197  return NULL;
198  }
199  gmp_complex* res = new gmp_complex( (*(gmp_complex*)a) / (*(gmp_complex*)b) );
200  return (number)res;
201 }
202 
203 /*2
204 * u:= x ^ exp
205 */
206 static void ngcPower ( number x, int exp, number * u, const coeffs r)
207 {
208  assume( getCoeffType(r) == n_long_C );
209 
210  if ( exp == 0 )
211  {
212  gmp_complex* n = new gmp_complex(1);
213  *u=(number)n;
214  return;
215  }
216  else if ( exp == 1 )
217  {
218  n_New(u, r);
219  gmp_complex* n = new gmp_complex();
220  *n= *(gmp_complex*)x;
221  *u=(number)n;
222  return;
223  }
224  else if (exp == 2)
225  {
226  n_New(u, r);
227  gmp_complex* n = new gmp_complex();
228  *n= *(gmp_complex*)x;
229  *u=(number)n;
230  *(gmp_complex*)(*u) *= *(gmp_complex*)n;
231  return;
232  }
233  if ( (exp & 1) == 1 )
234  {
235  ngcPower(x,exp-1,u, r);
236  gmp_complex *n = new gmp_complex();
237  *n=*(gmp_complex*)x;
238  *(gmp_complex*)(*u) *= *(gmp_complex*)n;
239  delete n;
240  }
241  else
242  {
243  number w;
244  n_New(&w, r);
245  ngcPower(x,exp/2,&w, r);
246  ngcPower(w,2,u, r);
247  n_Delete(&w, r);
248  }
249 }
250 
251 static number ngcRePart(number a, const coeffs r)
252 {
253  assume( getCoeffType(r) == n_long_C );
254 
255  gmp_complex* n = new gmp_complex(((gmp_complex*)a)->real());
256  return (number)n;
257 }
258 
259 static number ngcImPart(number a, const coeffs r)
260 {
261  assume( getCoeffType(r) == n_long_C );
262 
263  gmp_complex* n = new gmp_complex(((gmp_complex*)a)->imag());
264  return (number)n;
265 }
266 
267 /*2
268 * za >= 0 ?
269 */
270 static BOOLEAN ngcGreaterZero (number a, const coeffs r)
271 {
272  assume( getCoeffType(r) == n_long_C );
273 
274  if ( ! ((gmp_complex*)a)->imag().isZero() )
275  return ( abs( *(gmp_complex*)a).sign() >= 0 );
276  else
277  return ( ((gmp_complex*)a)->real().sign() >= 0 );
278 }
279 
280 /*2
281 * a > b ?
282 */
283 static BOOLEAN ngcGreater (number a, number b, const coeffs r)
284 {
285  assume( getCoeffType(r) == n_long_C );
286 
287  gmp_complex *aa=(gmp_complex*)a;
288  gmp_complex *bb=(gmp_complex*)b;
289  return (*aa) > (*bb);
290 }
291 
292 /*2
293 * a = b ?
294 */
295 static BOOLEAN ngcEqual (number a, number b, const coeffs r)
296 {
297  assume( getCoeffType(r) == n_long_C );
298 
299  gmp_complex *aa=(gmp_complex*)a;
300  gmp_complex *bb=(gmp_complex*)b;
301  return (*aa) == (*bb);
302 }
303 
304 /*2
305 * a == 1 ?
306 */
307 static BOOLEAN ngcIsOne (number a, const coeffs r)
308 {
309  assume( getCoeffType(r) == n_long_C );
310 
311  return (((gmp_complex*)a)->real().isOne() && ((gmp_complex*)a)->imag().isZero());
312  //return (((gmp_complex*)a)->real().isOne());
313 }
314 
315 /*2
316 * a == -1 ?
317 */
318 static BOOLEAN ngcIsMOne (number a, const coeffs r)
319 {
320  assume( getCoeffType(r) == n_long_C );
321 
322  return (((gmp_complex*)a)->real().isMOne() && ((gmp_complex*)a)->imag().isZero());
323  //return (((gmp_complex*)a)->real().isMOne());
324 }
325 
326 /*2
327 * extracts the number a from s, returns the rest
328 */
329 static const char * ngcRead (const char * s, number * a, const coeffs r)
330 {
331  assume( getCoeffType(r) == n_long_C );
332  const char * const complex_parameter = n_ParameterNames(r)[0];
333  assume( complex_parameter != NULL );
334  const int N = strlen(complex_parameter);
335 
336  if ((*s >= '0') && (*s <= '9'))
337  {
338  gmp_float *re=NULL;
339  s=ngfRead(s,(number *)&re, r); // FIXME? TODO? // extern const char * ngfRead (const char *s, number *a, const coeffs r);
340  gmp_complex *aa=new gmp_complex(*re);
341  *a=(number)aa;
342  delete re;
343  }
344  else if (strncmp(s, complex_parameter, N)==0)
345  {
346  s += N;
347  gmp_complex *aa=new gmp_complex(0L,1L);
348  *a=(number)aa;
349  }
350  else
351  {
352  *a=(number) new gmp_complex(1L);
353  }
354  return s;
355 }
356 
357 
358 
359 /*2
360 * write a floating point number
361 */
362 static void ngcWrite (number a, const coeffs r)
363 {
364  assume( getCoeffType(r) == n_long_C );
365 
366  if (a==NULL)
367  StringAppendS("0");
368  else
369  {
370  char *out;
371  out= complexToStr(*(gmp_complex*)a, r->float_len, r);
372  StringAppendS(out);
373  // omFreeSize((void *)out, (strlen(out)+1)* sizeof(char) );
374  omFree( (void *)out );
375  }
376 }
377 
378 static BOOLEAN ngcCoeffIsEqual (const coeffs r, n_coeffType n, void * parameter)
379 {
380  if (n==n_long_C)
381  {
382  LongComplexInfo* p = (LongComplexInfo *)(parameter);
383 
384  if ((p==NULL)
385  && (SHORT_REAL_LENGTH==r->float_len)
386  && (SHORT_REAL_LENGTH==r->float_len2)
387  && (strcmp("i",n_ParameterNames(r)[0]) == 0)
388  )
389  return TRUE;
390  if ((p!=NULL) &&
391  (p->float_len == r->float_len) &&
392  (p->float_len2 == r->float_len2)
393  )
394  if (strcmp(p->par_name, n_ParameterNames(r)[0]) == 0)
395  return (TRUE);
396  }
397  return (FALSE);
398 }
399 
400 static void ngcKillChar(coeffs r)
401 {
402  char** p = (char**)n_ParameterNames(r);
403 
404  const int P = n_NumberOfParameters(r);
405 
406  for( int i = 1; i <= P; i++ )
407  if (p[i-1] != NULL)
408  omFree( (ADDRESS)p[i-1] );
409 
410  omFreeSize((ADDRESS)p, P * sizeof(char*));
411 }
412 
413 static char* ngcCoeffString(const coeffs r)
414 {
415  const char *p=n_ParameterNames(r)[0];
416  char *s=(char*)omAlloc(31+strlen(p));
417  sprintf(s,"complex,%d,%d,%s",r->float_len,r->float_len2,p);
418  return s;
419 }
420 
421 static char* ngcCoeffName(const coeffs r)
422 {
423  static char ngcCoeffName_buf[40];
424  const char *p=n_ParameterNames(r)[0];
425  sprintf(ngcCoeffName_buf,"complex,%d,%d,%s",r->float_len,r->float_len2,p);
426  return ngcCoeffName_buf;
427 }
428 
429 static void ngcCoeffWrite (const coeffs r, BOOLEAN /*details*/)
430 {
431  Print("real[%s](complex:%d digits, additional %d digits)/(%s^2+1)",n_ParameterNames(r)[0],
432  r->float_len, r->float_len2, n_ParameterNames(r)[0]); /* long C */
433 }
434 
435 static number ngcMapQ(number from, const coeffs aRing, const coeffs r)
436 {
437  assume( getCoeffType(r) == n_long_C );
438  assume( aRing->rep == n_rep_gap_rat);
439 
440  if ( from != NULL )
441  {
443  return (number)res;
444  }
445  else
446  return NULL;
447 }
448 
449 static number ngcMapZ(number from, const coeffs aRing, const coeffs r)
450 {
451  assume( getCoeffType(r) == n_long_C );
452  assume( aRing->rep == n_rep_gap_gmp);
453 
454  if ( from != NULL )
455  {
456  if (SR_HDL(from) & SR_INT)
457  {
458  gmp_float f_i= gmp_float(SR_TO_INT(from));
459  gmp_complex *res=new gmp_complex(f_i);
460  return (number)res;
461  }
462  gmp_float f_i=(mpz_ptr)from;
463  gmp_complex *res=new gmp_complex(f_i);
464  return (number)res;
465  }
466  else
467  return NULL;
468 }
469 
470 static number ngcMapLongR(number from, const coeffs aRing, const coeffs r)
471 {
472  assume( getCoeffType(r) == n_long_C );
473  assume( getCoeffType(aRing) == n_long_R );
474 
475  if ( from != NULL )
476  {
477  gmp_complex *res=new gmp_complex(*((gmp_float *)from));
478  return (number)res;
479  }
480  else
481  return NULL;
482 }
483 
484 static number ngcMapR(number from, const coeffs aRing, const coeffs r)
485 {
486  assume( getCoeffType(r) == n_long_C );
487  assume( getCoeffType(aRing) == n_R );
488 
489  if ( from != NULL )
490  {
491  gmp_complex *res=new gmp_complex((double)nrFloat(from));
492  return (number)res;
493  }
494  else
495  return NULL;
496 }
497 
498 static number ngcMapP(number from, const coeffs aRing, const coeffs r)
499 {
500  assume( getCoeffType(r) == n_long_C );
501  assume( getCoeffType(aRing) == n_Zp );
502 
503  if ( from != NULL )
504  return ngcInit(npInt(from, aRing), r); // FIXME? TODO? // extern int npInt (number &n, const coeffs r);
505  else
506  return NULL;
507 }
508 
509 static number ngcCopyMap(number from, const coeffs aRing, const coeffs r)
510 {
511  assume( getCoeffType(r) == n_long_C );
512  assume( getCoeffType(aRing) == n_long_C );
513 
514  gmp_complex* b = NULL;
515 
516  if ( from != NULL )
517  {
518  b = new gmp_complex( *(gmp_complex*)from );
519  }
520  return (number)b;
521 }
522 
523 static nMapFunc ngcSetMap(const coeffs src, const coeffs dst)
524 {
525  assume( getCoeffType(dst) == n_long_C );
526 
527  if (src->rep==n_rep_gap_rat) /* Q, Z*/
528  {
529  return ngcMapQ;
530  }
531  if (src->rep==n_rep_gap_gmp) /* Z */
532  {
533  return ngcMapZ;
534  }
535  if ((src->rep==n_rep_gmp_float) && nCoeff_is_long_R(src))
536  {
537  return ngcMapLongR;
538  }
539  if ((src->rep==n_rep_gmp_complex) && nCoeff_is_long_C(src))
540  {
541  return ngcCopyMap;
542  }
543  if ((src->rep==n_rep_float) && nCoeff_is_R(src))
544  {
545  return ngcMapR;
546  }
547  if ((src->rep==n_rep_int) && nCoeff_is_Zp(src))
548  {
549  return ngcMapP;
550  }
551  return NULL;
552 }
553 
554 BOOLEAN ngcInitChar(coeffs n, void* parameter)
555 {
556  assume( getCoeffType(n) == n_long_C );
557  n->is_field=TRUE;
558  n->is_domain=TRUE;
559  n->rep=n_rep_gmp_complex;
560 
561  n->cfKillChar = ngcKillChar;
562  n->ch = 0;
563  n->cfCoeffString=ngcCoeffString;
564  n->cfCoeffName=ngcCoeffName;
565 
566  n->cfDelete = ngcDelete;
567  //n->cfNormalize=ndNormalize;
568  n->cfInit = ngcInit;
569  n->cfInt = ngcInt;
570  n->cfAdd = ngcAdd;
571  n->cfSub = ngcSub;
572  n->cfMult = ngcMult;
573  n->cfDiv = ngcDiv;
574  n->cfExactDiv= ngcDiv;
575  n->cfInpNeg = ngcNeg;
576  n->cfInvers = ngcInvers;
577  n->cfCopy = ngcCopy;
578  n->cfGreater = ngcGreater;
579  n->cfEqual = ngcEqual;
580  n->cfIsZero = ngcIsZero;
581  n->cfIsOne = ngcIsOne;
582  n->cfIsMOne = ngcIsMOne;
583  n->cfGreaterZero = ngcGreaterZero;
584 
585  n->cfWriteLong = ngcWrite;
586  n->cfWriteShort = ngcWrite;
587 
588  n->cfRead = ngcRead;
589  n->cfPower = ngcPower;
590  n->cfSetMap = ngcSetMap;
591  n->cfRePart = ngcRePart;
592  n->cfImPart = ngcImPart;
593  n->cfCoeffWrite = ngcCoeffWrite;
594  // cfSize = ndSize;
595 #ifdef LDEBUG
596  //n->cfDBTest = ndDBTest; // not yet implemented: ngcDBTest
597 #endif
598 
599  n->nCoeffIsEqual = ngcCoeffIsEqual;
600 
601  n->cfSetChar=ngcSetChar;
602 
603 /*
604  //r->cfInitChar=nlInitChar;
605  r->cfKillChar=NULL;
606 
607  r->cfMult = nlMult;
608  r->cfSub = nlSub;
609  r->cfAdd = nlAdd;
610  r->cfDiv = nlDiv;
611  r->cfIntMod= nlIntMod;
612  r->cfExactDiv= nlExactDiv;
613  r->cfInit = nlInit;
614  r->cfSize = nlSize;
615  r->cfInt = nlInt;
616 #ifdef HAVE_RINGS
617  r->cfDivComp = NULL; // only for ring stuff
618  r->cfIsUnit = NULL; // only for ring stuff
619  r->cfGetUnit = NULL; // only for ring stuff
620  r->cfExtGcd = NULL; // only for ring stuff
621 #endif
622  r->cfInpNeg = nlNeg;
623  r->cfInvers= nlInvers;
624  r->cfCopy = nl_Copy;
625  r->cfRePart = nl_Copy;
626  r->cfImPart = ndReturn0;
627  r->cfWriteLong = nlWrite;
628  r->cfRead = nlRead;
629  r->cfNormalize=nlNormalize;
630  r->cfGreater = nlGreater;
631 #ifdef HAVE_RINGS
632  r->cfDivBy = NULL; // only for ring stuff
633 #endif
634  r->cfEqual = nlEqual;
635  r->cfIsZero = nlIsZero;
636  r->cfIsOne = nlIsOne;
637  r->cfIsMOne = nlIsMOne;
638  r->cfGreaterZero = nlGreaterZero;
639  r->cfPower = nlPower;
640  r->cfGetDenom = nlGetDenom;
641  r->cfGetNumerator = nlGetNumerator;
642  r->cfGcd = nlGcd;
643  r->cfLcm = nlLcm;
644  r->cfDelete= nlDelete;
645  r->cfSetMap = nlSetMap;
646  r->cfName = ndName;
647  r->cfInpMult=nlInpMult;
648  r->cfInit_bigint=nlCopyMap;
649 #ifdef LDEBUG
650  // debug stuff
651  r->cfDBTest=nlDBTest;
652 #endif
653 
654  // the variables:
655  r->type = n_Q;
656  r->ch = 0;
657  r->has_simple_Alloc=FALSE;
658  r->has_simple_Inverse=FALSE;
659 */
660 
661  n->iNumberOfParameters = 1;
662  n->cfParameter = ngcParameter;
663 
664  char ** pParameterNames = (char **) omAlloc0(sizeof(char *));
665 
666  if( parameter != NULL)
667  {
668  LongComplexInfo* p = (LongComplexInfo*)parameter;
669  pParameterNames[0] = omStrDup(p->par_name);
670  // fix wrong parameters:
671  if (p->float_len<SHORT_REAL_LENGTH) p->float_len=SHORT_REAL_LENGTH;
672  n->float_len = p->float_len;
673  n->float_len2 = p->float_len2;
674 
675  } else // default values, just for testing!
676  {
677  pParameterNames[0] = omStrDup("i");
678  n->float_len = SHORT_REAL_LENGTH;
679  n->float_len2 = SHORT_REAL_LENGTH;
680  }
681 
682  assume( pParameterNames != NULL );
683  assume( pParameterNames[0] != NULL );
684 
685  n->pParameterNames = (const char**)pParameterNames;
686 
687  // NOTE: n->complex_parameter was replaced by n_ParameterNames(n)[0]
688  // TODO: nfKillChar MUST destroy n->pParameterNames[0] (0-term. string) && n->pParameterNames (array of size 1)
689 
690  return FALSE;
691 }
692 
693 void ngcSetChar(const coeffs r)
694 {
695  setGMPFloatDigits(r->float_len, r->float_len2);
696 }
697 
698 
699 
#define n_New(n, r)
Definition: coeffs.h:440
static void ngcKillChar(coeffs r)
Definition: gnumpc.cc:400
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:800
const CanonicalForm int s
Definition: facAbsFact.cc:55
static void ngcCoeffWrite(const coeffs r, BOOLEAN)
Definition: gnumpc.cc:429
static number ngcInvers(number a, const coeffs R)
Definition: gnumpc.cc:137
#define Print
Definition: emacs.cc:80
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:822
#define SHORT_REAL_LENGTH
Definition: numbers.h:58
static BOOLEAN ngcGreater(number a, number b, const coeffs r)
Definition: gnumpc.cc:283
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:358
long npInt(number &n, const coeffs r)
Definition: modulop.cc:128
#define FALSE
Definition: auxiliary.h:94
static number ngcMapR(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:484
static number ngcNeg(number a, const coeffs R)
Definition: gnumpc.cc:125
static number ngcMapZ(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:449
static number ngcMapQ(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:435
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:913
static long ngcInt(number &i, const coeffs r)
Definition: gnumpc.cc:67
static number ngcSub(number a, number b, const coeffs R)
Definition: gnumpc.cc:167
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition: coeffs.h:858
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
\F{p < 2^31}
Definition: coeffs.h:30
(), see rinteger.h, new impl.
Definition: coeffs.h:112
#define TRUE
Definition: auxiliary.h:98
static BOOLEAN ngcCoeffIsEqual(const coeffs r, n_coeffType n, void *parameter)
Definition: gnumpc.cc:378
void * ADDRESS
Definition: auxiliary.h:133
static void ngcPower(number x, int exp, number *u, const coeffs r)
Definition: gnumpc.cc:206
void WerrorS(const char *s)
Definition: feFopen.cc:24
gmp_complex numbers based on
Definition: mpr_complex.h:178
static number ngcMult(number a, number b, const coeffs R)
Definition: gnumpc.cc:178
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:916
static number ngcDiv(number a, number b, const coeffs r)
Definition: gnumpc.cc:189
#define omAlloc(size)
Definition: omAllocDecl.h:210
Rational abs(const Rational &a)
Definition: GMPrat.cc:439
real floating point (GMP) numbers
Definition: coeffs.h:34
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:796
static number ngcMapP(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:498
static BOOLEAN ngcIsZero(number a, const coeffs r)
Definition: gnumpc.cc:74
static char * ngcCoeffString(const coeffs r)
Definition: gnumpc.cc:413
single prescision (6,6) real numbers
Definition: coeffs.h:32
CanonicalForm b
Definition: cfModGcd.cc:4044
void ngcSetChar(const coeffs r)
Definition: gnumpc.cc:693
BOOLEAN ngcInitChar(coeffs n, void *parameter)
Initialize r (n_long_C)
Definition: gnumpc.cc:554
static int ngcSize(number n, const coeffs R)
Definition: gnumpc.cc:81
Coefficient rings, fields and other domains suitable for Singular polynomials.
CanonicalForm res
Definition: facAbsFact.cc:64
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
#define omFree(addr)
Definition: omAllocDecl.h:261
#define assume(x)
Definition: mod2.h:390
The main handler for Singular numbers which are suitable for Singular polynomials.
void StringAppendS(const char *st)
Definition: reporter.cc:107
const char * ngfRead(const char *s, number *a, const coeffs r)
Definition: gnumpfl.cc:308
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
static BOOLEAN ngcEqual(number a, number b, const coeffs r)
Definition: gnumpc.cc:295
static char * ngcCoeffName(const coeffs r)
Definition: gnumpc.cc:421
complex floating point (GMP) numbers
Definition: coeffs.h:42
(gmp_complex), see gnumpc.h
Definition: coeffs.h:118
static number ngcParameter(int i, const coeffs r)
Definition: gnumpc.cc:41
static number ngcRePart(number a, const coeffs r)
Definition: gnumpc.cc:251
All the auxiliary stuff.
BOOLEAN ngcDBTest(number a, const char *f, const int l, const coeffs r)
Definition: gnumpc.cc:33
const char *const nDivBy0
Definition: numbers.h:89
FILE * f
Definition: checklibs.c:9
static number ngcInit(long i, const coeffs r)
Definition: gnumpc.cc:55
int i
Definition: cfEzgcd.cc:125
#define QTOF
Definition: mpr_complex.h:19
gmp_float numberFieldToFloat(number num, int cf)
Definition: mpr_complex.cc:439
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
static nMapFunc ngcSetMap(const coeffs src, const coeffs dst)
Definition: gnumpc.cc:523
gmp_complex & neg()
Definition: mpr_complex.cc:661
#define SR_TO_INT(SR)
Definition: longrat.h:68
(number), see longrat.h
Definition: coeffs.h:111
static BOOLEAN ngcGreaterZero(number a, const coeffs r)
Definition: gnumpc.cc:270
n_coeffType
Definition: coeffs.h:27
#define NULL
Definition: omList.c:10
static BOOLEAN ngcIsOne(number a, const coeffs r)
Definition: gnumpc.cc:307
(gmp_float), see
Definition: coeffs.h:117
#define R
Definition: sirandom.c:26
#define SR_INT
Definition: longrat.h:66
const CanonicalForm & w
Definition: facAbsFact.cc:55
static number ngcAdd(number a, number b, const coeffs R)
Definition: gnumpc.cc:156
Variable x
Definition: cfModGcd.cc:4023
bool isZero(const CFArray &A)
checks if entries of A are zero
static number ngcImPart(number a, const coeffs r)
Definition: gnumpc.cc:259
char * complexToStr(gmp_complex &c, const unsigned int oprec, const coeffs src)
Definition: mpr_complex.cc:705
(int), see modulop.h
Definition: coeffs.h:110
#define SR_HDL(A)
Definition: tgb.cc:35
static const char * ngcRead(const char *s, number *a, const coeffs r)
Definition: gnumpc.cc:329
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
int p
Definition: cfModGcd.cc:4019
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:61
static number ngcCopyMap(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:509
static number ngcMapLongR(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:470
SI_FLOAT nrFloat(number n)
Converts a n_R number into a float. Needed by Maps.
Definition: shortfl.cc:57
int BOOLEAN
Definition: auxiliary.h:85
static void ngcDelete(number *a, const coeffs r)
Definition: gnumpc.cc:99
static int sign(int x)
Definition: ring.cc:3346
static CanonicalForm oneNorm(const CanonicalForm &F)
static number ngcCopy(number a, const coeffs r)
Definition: gnumpc.cc:113
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int l
Definition: cfEzgcd.cc:93
static void ngcWrite(number a, const coeffs r)
Definition: gnumpc.cc:362
(float), see shortfl.h
Definition: coeffs.h:116
#define omStrDup(s)
Definition: omAllocDecl.h:263
static BOOLEAN ngcIsMOne(number a, const coeffs r)
Definition: gnumpc.cc:318