My Project  UNKNOWN_GIT_VERSION
Functions
gnumpc.cc File Reference
#include "misc/auxiliary.h"
#include "omalloc/omalloc.h"
#include "misc/mylimits.h"
#include "reporter/reporter.h"
#include "coeffs/coeffs.h"
#include "coeffs/numbers.h"
#include "coeffs/mpr_complex.h"
#include "coeffs/gnumpc.h"
#include "coeffs/longrat.h"
#include "coeffs/gnumpfl.h"
#include "coeffs/modulop.h"
#include "coeffs/shortfl.h"

Go to the source code of this file.

Functions

BOOLEAN ngcDBTest (number a, const char *f, const int l, const coeffs r)
 
static number ngcParameter (int i, const coeffs r)
 
static number ngcInit (long i, const coeffs r)
 
static long ngcInt (number &i, const coeffs r)
 
static BOOLEAN ngcIsZero (number a, const coeffs r)
 
static int ngcSize (number n, const coeffs R)
 
static void ngcDelete (number *a, const coeffs r)
 
static number ngcCopy (number a, const coeffs r)
 
static number ngcNeg (number a, const coeffs R)
 
static number ngcInvers (number a, const coeffs R)
 
static number ngcAdd (number a, number b, const coeffs R)
 
static number ngcSub (number a, number b, const coeffs R)
 
static number ngcMult (number a, number b, const coeffs R)
 
static number ngcDiv (number a, number b, const coeffs r)
 
static void ngcPower (number x, int exp, number *u, const coeffs r)
 
static number ngcRePart (number a, const coeffs r)
 
static number ngcImPart (number a, const coeffs r)
 
static BOOLEAN ngcGreaterZero (number a, const coeffs r)
 
static BOOLEAN ngcGreater (number a, number b, const coeffs r)
 
static BOOLEAN ngcEqual (number a, number b, const coeffs r)
 
static BOOLEAN ngcIsOne (number a, const coeffs r)
 
static BOOLEAN ngcIsMOne (number a, const coeffs r)
 
static const char * ngcRead (const char *s, number *a, const coeffs r)
 
static void ngcWrite (number a, const coeffs r)
 
static BOOLEAN ngcCoeffIsEqual (const coeffs r, n_coeffType n, void *parameter)
 
static void ngcKillChar (coeffs r)
 
static char * ngcCoeffString (const coeffs r)
 
static char * ngcCoeffName (const coeffs r)
 
static void ngcCoeffWrite (const coeffs r, BOOLEAN)
 
static number ngcMapQ (number from, const coeffs aRing, const coeffs r)
 
static number ngcMapZ (number from, const coeffs aRing, const coeffs r)
 
static number ngcMapLongR (number from, const coeffs aRing, const coeffs r)
 
static number ngcMapR (number from, const coeffs aRing, const coeffs r)
 
static number ngcMapP (number from, const coeffs aRing, const coeffs r)
 
static number ngcCopyMap (number from, const coeffs aRing, const coeffs r)
 
static nMapFunc ngcSetMap (const coeffs src, const coeffs dst)
 
BOOLEAN ngcInitChar (coeffs n, void *parameter)
 Initialize r (n_long_C) More...
 
void ngcSetChar (const coeffs r)
 

Function Documentation

◆ ngcAdd()

static number ngcAdd ( number  a,
number  b,
const coeffs  R 
)
static

Definition at line 156 of file gnumpc.cc.

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 }

◆ ngcCoeffIsEqual()

static BOOLEAN ngcCoeffIsEqual ( const coeffs  r,
n_coeffType  n,
void *  parameter 
)
static

Definition at line 378 of file gnumpc.cc.

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 }

◆ ngcCoeffName()

static char* ngcCoeffName ( const coeffs  r)
static

Definition at line 421 of file gnumpc.cc.

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 }

◆ ngcCoeffString()

static char* ngcCoeffString ( const coeffs  r)
static

Definition at line 413 of file gnumpc.cc.

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 }

◆ ngcCoeffWrite()

static void ngcCoeffWrite ( const coeffs  r,
BOOLEAN   
)
static

Definition at line 429 of file gnumpc.cc.

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 }

◆ ngcCopy()

static number ngcCopy ( number  a,
const coeffs  r 
)
static

Definition at line 113 of file gnumpc.cc.

114 {
115  assume( getCoeffType(r) == n_long_C );
116 
117  gmp_complex* b= new gmp_complex( *(gmp_complex*)a );
118  return (number)b;
119 }

◆ ngcCopyMap()

static number ngcCopyMap ( number  from,
const coeffs  aRing,
const coeffs  r 
)
static

Definition at line 509 of file gnumpc.cc.

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 }

◆ ngcDBTest()

BOOLEAN ngcDBTest ( number  a,
const char *  f,
const int  l,
const coeffs  r 
)

Definition at line 33 of file gnumpc.cc.

34 {
35  assume( getCoeffType(r) == n_long_C );
36 
37  return TRUE;
38 }

◆ ngcDelete()

static void ngcDelete ( number *  a,
const coeffs  r 
)
static

Definition at line 99 of file gnumpc.cc.

100 {
101  assume( getCoeffType(r) == n_long_C );
102 
103  if ( *a != NULL )
104  {
105  delete *(gmp_complex**)a;
106  *a=NULL;
107  }
108 }

◆ ngcDiv()

static number ngcDiv ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 189 of file gnumpc.cc.

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 }

◆ ngcEqual()

static BOOLEAN ngcEqual ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 295 of file gnumpc.cc.

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 }

◆ ngcGreater()

static BOOLEAN ngcGreater ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 283 of file gnumpc.cc.

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 }

◆ ngcGreaterZero()

static BOOLEAN ngcGreaterZero ( number  a,
const coeffs  r 
)
static

Definition at line 270 of file gnumpc.cc.

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 }

◆ ngcImPart()

static number ngcImPart ( number  a,
const coeffs  r 
)
static

Definition at line 259 of file gnumpc.cc.

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 }

◆ ngcInit()

static number ngcInit ( long  i,
const coeffs  r 
)
static

Definition at line 55 of file gnumpc.cc.

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 }

◆ ngcInitChar()

BOOLEAN ngcInitChar ( coeffs  n,
void *  parameter 
)

Initialize r (n_long_C)

Definition at line 554 of file gnumpc.cc.

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 }

◆ ngcInt()

static long ngcInt ( number &  i,
const coeffs  r 
)
static

Definition at line 67 of file gnumpc.cc.

68 {
69  assume( getCoeffType(r) == n_long_C );
70 
71  return ((gmp_complex*)i)->real();
72 }

◆ ngcInvers()

static number ngcInvers ( number  a,
const coeffs  R 
)
static

Definition at line 137 of file gnumpc.cc.

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 }

◆ ngcIsMOne()

static BOOLEAN ngcIsMOne ( number  a,
const coeffs  r 
)
static

Definition at line 318 of file gnumpc.cc.

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 }

◆ ngcIsOne()

static BOOLEAN ngcIsOne ( number  a,
const coeffs  r 
)
static

Definition at line 307 of file gnumpc.cc.

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 }

◆ ngcIsZero()

static BOOLEAN ngcIsZero ( number  a,
const coeffs  r 
)
static

Definition at line 74 of file gnumpc.cc.

75 {
76  assume( getCoeffType(r) == n_long_C );
77 
78  return ( ((gmp_complex*)a)->real().isZero() && ((gmp_complex*)a)->imag().isZero());
79 }

◆ ngcKillChar()

static void ngcKillChar ( coeffs  r)
static

Definition at line 400 of file gnumpc.cc.

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 }

◆ ngcMapLongR()

static number ngcMapLongR ( number  from,
const coeffs  aRing,
const coeffs  r 
)
static

Definition at line 470 of file gnumpc.cc.

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 }

◆ ngcMapP()

static number ngcMapP ( number  from,
const coeffs  aRing,
const coeffs  r 
)
static

Definition at line 498 of file gnumpc.cc.

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 }

◆ ngcMapQ()

static number ngcMapQ ( number  from,
const coeffs  aRing,
const coeffs  r 
)
static

Definition at line 435 of file gnumpc.cc.

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 }

◆ ngcMapR()

static number ngcMapR ( number  from,
const coeffs  aRing,
const coeffs  r 
)
static

Definition at line 484 of file gnumpc.cc.

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 }

◆ ngcMapZ()

static number ngcMapZ ( number  from,
const coeffs  aRing,
const coeffs  r 
)
static

Definition at line 449 of file gnumpc.cc.

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 }

◆ ngcMult()

static number ngcMult ( number  a,
number  b,
const coeffs  R 
)
static

Definition at line 178 of file gnumpc.cc.

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 }

◆ ngcNeg()

static number ngcNeg ( number  a,
const coeffs  R 
)
static

Definition at line 125 of file gnumpc.cc.

126 {
127  assume( getCoeffType(R) == n_long_C );
128 
129  gmp_complex* r=(gmp_complex*)a;
130  (*r).neg();
131  return (number)a;
132 }

◆ ngcParameter()

static number ngcParameter ( int  i,
const coeffs  r 
)
static

Definition at line 41 of file gnumpc.cc.

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 }

◆ ngcPower()

static void ngcPower ( number  x,
int  exp,
number *  u,
const coeffs  r 
)
static

Definition at line 206 of file gnumpc.cc.

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 }

◆ ngcRead()

static const char* ngcRead ( const char *  s,
number *  a,
const coeffs  r 
)
static

Definition at line 329 of file gnumpc.cc.

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 }

◆ ngcRePart()

static number ngcRePart ( number  a,
const coeffs  r 
)
static

Definition at line 251 of file gnumpc.cc.

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 }

◆ ngcSetChar()

void ngcSetChar ( const coeffs  r)

Definition at line 693 of file gnumpc.cc.

694 {
695  setGMPFloatDigits(r->float_len, r->float_len2);
696 }

◆ ngcSetMap()

static nMapFunc ngcSetMap ( const coeffs  src,
const coeffs  dst 
)
static

Definition at line 523 of file gnumpc.cc.

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 }

◆ ngcSize()

static int ngcSize ( number  n,
const coeffs  R 
)
static

Definition at line 81 of file gnumpc.cc.

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 }

◆ ngcSub()

static number ngcSub ( number  a,
number  b,
const coeffs  R 
)
static

Definition at line 167 of file gnumpc.cc.

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 }

◆ ngcWrite()

static void ngcWrite ( number  a,
const coeffs  r 
)
static

Definition at line 362 of file gnumpc.cc.

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 }
getCoeffType
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:420
n_rep_gap_rat
(number), see longrat.h
Definition: coeffs.h:110
FALSE
#define FALSE
Definition: auxiliary.h:94
ngcMapQ
static number ngcMapQ(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:435
ngcInvers
static number ngcInvers(number a, const coeffs R)
Definition: gnumpc.cc:137
numberFieldToFloat
gmp_float numberFieldToFloat(number num, int cf)
Definition: mpr_complex.cc:438
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:821
StringAppendS
void StringAppendS(const char *st)
Definition: reporter.cc:106
ngcKillChar
static void ngcKillChar(coeffs r)
Definition: gnumpc.cc:400
isZero
bool isZero(const CFArray &A)
checks if entries of A are zero
Definition: facSparseHensel.h:468
omFree
#define omFree(addr)
Definition: omAllocDecl.h:259
ngcCoeffWrite
static void ngcCoeffWrite(const coeffs r, BOOLEAN)
Definition: gnumpc.cc:429
nCoeff_is_R
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition: coeffs.h:857
ngcDelete
static void ngcDelete(number *a, const coeffs r)
Definition: gnumpc.cc:99
LongComplexInfo
Definition: coeffs.h:98
ngcCopy
static number ngcCopy(number a, const coeffs r)
Definition: gnumpc.cc:113
ngcInt
static long ngcInt(number &i, const coeffs r)
Definition: gnumpc.cc:67
x
Variable x
Definition: cfModGcd.cc:4023
ngcGreater
static BOOLEAN ngcGreater(number a, number b, const coeffs r)
Definition: gnumpc.cc:283
n_New
#define n_New(n, r)
Definition: coeffs.h:439
SHORT_REAL_LENGTH
#define SHORT_REAL_LENGTH
Definition: numbers.h:57
n_long_C
complex floating point (GMP) numbers
Definition: coeffs.h:41
ngcCoeffIsEqual
static BOOLEAN ngcCoeffIsEqual(const coeffs r, n_coeffType n, void *parameter)
Definition: gnumpc.cc:378
ngcNeg
static number ngcNeg(number a, const coeffs R)
Definition: gnumpc.cc:125
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
n_rep_float
(float), see shortfl.h
Definition: coeffs.h:115
ngcCoeffString
static char * ngcCoeffString(const coeffs r)
Definition: gnumpc.cc:413
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:261
sign
static int sign(int x)
Definition: ring.cc:3345
nrFloat
SI_FLOAT nrFloat(number n)
Converts a n_R number into a float. Needed by Maps.
Definition: shortfl.cc:56
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:454
N
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
oneNorm
static CanonicalForm oneNorm(const CanonicalForm &F)
Definition: cfModResultant.cc:242
n_NumberOfParameters
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:795
n_rep_int
(int), see modulop.h
Definition: coeffs.h:109
ngcSub
static number ngcSub(number a, number b, const coeffs R)
Definition: gnumpc.cc:167
ngcIsZero
static BOOLEAN ngcIsZero(number a, const coeffs r)
Definition: gnumpc.cc:74
w
const CanonicalForm & w
Definition: facAbsFact.cc:55
nCoeff_is_long_C
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:915
b
CanonicalForm b
Definition: cfModGcd.cc:4044
ngcMult
static number ngcMult(number a, number b, const coeffs R)
Definition: gnumpc.cc:178
ngcMapZ
static number ngcMapZ(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:449
ngcMapR
static number ngcMapR(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:484
n_long_R
real floating point (GMP) numbers
Definition: coeffs.h:33
gmp_complex::neg
gmp_complex & neg()
Definition: mpr_complex.cc:660
ngcPower
static void ngcPower(number x, int exp, number *u, const coeffs r)
Definition: gnumpc.cc:206
TRUE
#define TRUE
Definition: auxiliary.h:98
i
int i
Definition: cfEzgcd.cc:125
res
CanonicalForm res
Definition: facAbsFact.cc:64
abs
Rational abs(const Rational &a)
Definition: GMPrat.cc:439
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
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:258
ngcDiv
static number ngcDiv(number a, number b, const coeffs r)
Definition: gnumpc.cc:189
ngcRePart
static number ngcRePart(number a, const coeffs r)
Definition: gnumpc.cc:251
ngcParameter
static number ngcParameter(int i, const coeffs r)
Definition: gnumpc.cc:41
ngcEqual
static BOOLEAN ngcEqual(number a, number b, const coeffs r)
Definition: gnumpc.cc:295
ngcMapP
static number ngcMapP(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:498
nCoeff_is_long_R
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:912
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
ngcSetChar
void ngcSetChar(const coeffs r)
Definition: gnumpc.cc:693
ngcCoeffName
static char * ngcCoeffName(const coeffs r)
Definition: gnumpc.cc:421
ngcIsOne
static BOOLEAN ngcIsOne(number a, const coeffs r)
Definition: gnumpc.cc:307
complexToStr
char * complexToStr(gmp_complex &c, const unsigned int oprec, const coeffs src)
Definition: mpr_complex.cc:704
SR_INT
#define SR_INT
Definition: longrat.h:65
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:799
exp
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:357
SR_TO_INT
#define SR_TO_INT(SR)
Definition: longrat.h:67
npInt
long npInt(number &n, const coeffs r)
Definition: modulop.cc:127
ngcGreaterZero
static BOOLEAN ngcGreaterZero(number a, const coeffs r)
Definition: gnumpc.cc:270
ngcAdd
static number ngcAdd(number a, number b, const coeffs R)
Definition: gnumpc.cc:156
n_Zp
\F{p < 2^31}
Definition: coeffs.h:29
ngcImPart
static number ngcImPart(number a, const coeffs r)
Definition: gnumpc.cc:259
ngcSetMap
static nMapFunc ngcSetMap(const coeffs src, const coeffs dst)
Definition: gnumpc.cc:523
n_rep_gmp_float
(gmp_float), see
Definition: coeffs.h:116
Print
#define Print
Definition: emacs.cc:79
ngcCopyMap
static number ngcCopyMap(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:509
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
ngcInit
static number ngcInit(long i, const coeffs r)
Definition: gnumpc.cc:55
SR_HDL
#define SR_HDL(A)
Definition: tgb.cc:35
assume
#define assume(x)
Definition: mod2.h:384
NULL
#define NULL
Definition: omList.c:9
R
#define R
Definition: sirandom.c:26
QTOF
#define QTOF
Definition: mpr_complex.h:18
p
int p
Definition: cfModGcd.cc:4019
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
ngcRead
static const char * ngcRead(const char *s, number *a, const coeffs r)
Definition: gnumpc.cc:329
ngcWrite
static void ngcWrite(number a, const coeffs r)
Definition: gnumpc.cc:362
ngcIsMOne
static BOOLEAN ngcIsMOne(number a, const coeffs r)
Definition: gnumpc.cc:318
n_rep_gmp_complex
(gmp_complex), see gnumpc.h
Definition: coeffs.h:117
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:209
gmp_float
Definition: mpr_complex.h:30
ngcMapLongR
static number ngcMapLongR(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:470
gmp_complex
gmp_complex numbers based on
Definition: mpr_complex.h:177
n_rep_gap_gmp
(), see rinteger.h, new impl.
Definition: coeffs.h:111