My Project
Functions
gnumpc.cc File Reference
#include "misc/auxiliary.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 * 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 number ngcInitMPZ (mpz_t m, const coeffs)
 
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 }
CanonicalForm b
Definition: cfModGcd.cc:4103
gmp_complex numbers based on
Definition: mpr_complex.h:179
@ n_long_C
complex floating point (GMP) numbers
Definition: coeffs.h:41
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define assume(x)
Definition: mod2.h:387
#define R
Definition: sirandom.c:27

◆ 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 }
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
int p
Definition: cfModGcd.cc:4078
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:778
#define SHORT_REAL_LENGTH
Definition: numbers.h:57
#define NULL
Definition: omList.c:12

◆ ngcCoeffName()

static char* ngcCoeffName ( const coeffs  r)
static

Definition at line 413 of file gnumpc.cc.

414 {
415  STATIC_VAR char ngcCoeffName_buf[40];
416  const char *p=n_ParameterNames(r)[0];
417  sprintf(ngcCoeffName_buf,"complex,%d,%d,%s",r->float_len,r->float_len2,p);
418  return ngcCoeffName_buf;
419 }
#define STATIC_VAR
Definition: globaldefs.h:7

◆ ngcCoeffWrite()

static void ngcCoeffWrite ( const coeffs  r,
BOOLEAN   
)
static

Definition at line 421 of file gnumpc.cc.

422 {
423  Print("real[%s](complex:%d digits, additional %d digits)/(%s^2+1)",n_ParameterNames(r)[0],
424  r->float_len, r->float_len2, n_ParameterNames(r)[0]); /* long C */
425 }
#define Print
Definition: emacs.cc:80

◆ ngcCopy()

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

Definition at line 112 of file gnumpc.cc.

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

◆ ngcCopyMap()

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

Definition at line 501 of file gnumpc.cc.

502 {
503  assume( getCoeffType(r) == n_long_C );
504  assume( getCoeffType(aRing) == n_long_C );
505 
506  gmp_complex* b = NULL;
507 
508  if ( from != NULL )
509  {
510  b = new gmp_complex( *(gmp_complex*)from );
511  }
512  return (number)b;
513 }

◆ ngcDBTest()

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

Definition at line 32 of file gnumpc.cc.

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

◆ ngcDelete()

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

Definition at line 98 of file gnumpc.cc.

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

◆ 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 (number)new gmp_complex( 0 );
198  }
199  gmp_complex* res = new gmp_complex( (*(gmp_complex*)a) / (*(gmp_complex*)b) );
200  return (number)res;
201 }
CanonicalForm res
Definition: facAbsFact.cc:60
bool isZero(const CFArray &A)
checks if entries of A are zero
void WerrorS(const char *s)
Definition: feFopen.cc:24
const char *const nDivBy0
Definition: numbers.h:87

◆ 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 }
Rational abs(const Rational &a)
Definition: GMPrat.cc:436
static int sign(int x)
Definition: ring.cc:3372

◆ 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 54 of file gnumpc.cc.

55 {
56  assume( getCoeffType(r) == n_long_C );
57 
58  gmp_complex* n= new gmp_complex( (long)i, 0L );
59 
60  return (number)n;
61 }
int i
Definition: cfEzgcd.cc:132

◆ 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->cfCoeffName=ngcCoeffName;
564  n->cfCoeffWrite = ngcCoeffWrite;
565 
566  n->cfDelete = ngcDelete;
567  //n->cfNormalize=ndNormalize;
568  n->cfInit = ngcInit;
569  n->cfInitMPZ = ngcInitMPZ;
570  n->cfInt = ngcInt;
571  n->cfAdd = ngcAdd;
572  n->cfSub = ngcSub;
573  n->cfMult = ngcMult;
574  n->cfDiv = ngcDiv;
575  n->cfExactDiv= ngcDiv;
576  n->cfInpNeg = ngcNeg;
577  n->cfInvers = ngcInvers;
578  n->cfCopy = ngcCopy;
579  n->cfGreater = ngcGreater;
580  n->cfEqual = ngcEqual;
581  n->cfIsZero = ngcIsZero;
582  n->cfIsOne = ngcIsOne;
583  n->cfIsMOne = ngcIsMOne;
584  n->cfGreaterZero = ngcGreaterZero;
585 
586  n->cfWriteLong = ngcWrite;
587  n->cfWriteShort = ngcWrite;
588 
589  n->cfRead = ngcRead;
590  n->cfPower = ngcPower;
591  n->cfSetMap = ngcSetMap;
592  n->cfRePart = ngcRePart;
593  n->cfImPart = ngcImPart;
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 }
@ n_rep_gmp_complex
(gmp_complex), see gnumpc.h
Definition: coeffs.h:118
static void ngcKillChar(coeffs r)
Definition: gnumpc.cc:400
static number ngcImPart(number a, const coeffs r)
Definition: gnumpc.cc:259
static number ngcDiv(number a, number b, const coeffs r)
Definition: gnumpc.cc:189
static void ngcDelete(number *a, const coeffs r)
Definition: gnumpc.cc:98
static number ngcSub(number a, number b, const coeffs R)
Definition: gnumpc.cc:167
static const char * ngcRead(const char *s, number *a, const coeffs r)
Definition: gnumpc.cc:329
static number ngcCopy(number a, const coeffs r)
Definition: gnumpc.cc:112
static number ngcInvers(number a, const coeffs R)
Definition: gnumpc.cc:136
static number ngcInitMPZ(mpz_t m, const coeffs)
Definition: gnumpc.cc:515
void ngcSetChar(const coeffs r)
Definition: gnumpc.cc:693
static void ngcPower(number x, int exp, number *u, const coeffs r)
Definition: gnumpc.cc:206
static number ngcAdd(number a, number b, const coeffs R)
Definition: gnumpc.cc:156
static nMapFunc ngcSetMap(const coeffs src, const coeffs dst)
Definition: gnumpc.cc:523
static BOOLEAN ngcIsMOne(number a, const coeffs r)
Definition: gnumpc.cc:318
static BOOLEAN ngcCoeffIsEqual(const coeffs r, n_coeffType n, void *parameter)
Definition: gnumpc.cc:378
static BOOLEAN ngcGreaterZero(number a, const coeffs r)
Definition: gnumpc.cc:270
static number ngcInit(long i, const coeffs r)
Definition: gnumpc.cc:54
static number ngcRePart(number a, const coeffs r)
Definition: gnumpc.cc:251
static void ngcCoeffWrite(const coeffs r, BOOLEAN)
Definition: gnumpc.cc:421
static BOOLEAN ngcGreater(number a, number b, const coeffs r)
Definition: gnumpc.cc:283
static number ngcParameter(int i, const coeffs r)
Definition: gnumpc.cc:40
static void ngcWrite(number a, const coeffs r)
Definition: gnumpc.cc:362
static number ngcNeg(number a, const coeffs R)
Definition: gnumpc.cc:124
static BOOLEAN ngcIsZero(number a, const coeffs r)
Definition: gnumpc.cc:73
static number ngcMult(number a, number b, const coeffs R)
Definition: gnumpc.cc:178
static BOOLEAN ngcIsOne(number a, const coeffs r)
Definition: gnumpc.cc:307
static long ngcInt(number &i, const coeffs r)
Definition: gnumpc.cc:66
static char * ngcCoeffName(const coeffs r)
Definition: gnumpc.cc:413
static BOOLEAN ngcEqual(number a, number b, const coeffs r)
Definition: gnumpc.cc:295
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omAlloc0(size)
Definition: omAllocDecl.h:211

◆ ngcInitMPZ()

static number ngcInitMPZ ( mpz_t  m,
const  coeffs 
)
static

Definition at line 515 of file gnumpc.cc.

516 {
517  gmp_float mm(m);
518  gmp_complex* res = new gmp_complex(mm);
519  return (number)res;
520 }
int m
Definition: cfEzgcd.cc:128

◆ ngcInt()

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

Definition at line 66 of file gnumpc.cc.

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

◆ ngcInvers()

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

Definition at line 136 of file gnumpc.cc.

137 {
138  assume( getCoeffType(R) == n_long_C );
139 
140  gmp_complex* r = NULL;
141  if (((gmp_complex*)a)->isZero())
142  {
143  WerrorS(nDivBy0);
144  r = new gmp_complex( 0 );
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 73 of file gnumpc.cc.

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

◆ 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 }
void * ADDRESS
Definition: auxiliary.h:119
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:774
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omFree(addr)
Definition: omAllocDecl.h:261

◆ ngcMapLongR()

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

Definition at line 462 of file gnumpc.cc.

463 {
464  assume( getCoeffType(r) == n_long_C );
465  assume( getCoeffType(aRing) == n_long_R );
466 
467  if ( from != NULL )
468  {
469  gmp_complex *res=new gmp_complex(*((gmp_float *)from));
470  return (number)res;
471  }
472  else
473  return NULL;
474 }
@ n_long_R
real floating point (GMP) numbers
Definition: coeffs.h:33

◆ ngcMapP()

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

Definition at line 490 of file gnumpc.cc.

491 {
492  assume( getCoeffType(r) == n_long_C );
493  assume( getCoeffType(aRing) == n_Zp );
494 
495  if ( from != NULL )
496  return ngcInit(npInt(from, aRing), r); // FIXME? TODO? // extern int npInt (number &n, const coeffs r);
497  else
498  return NULL;
499 }
@ n_Zp
\F{p < 2^31}
Definition: coeffs.h:29
long npInt(number &n, const coeffs r)
Definition: modulop.cc:85

◆ ngcMapQ()

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

Definition at line 427 of file gnumpc.cc.

428 {
429  assume( getCoeffType(r) == n_long_C );
430  assume( aRing->rep == n_rep_gap_rat);
431 
432  if ( from != NULL )
433  {
435  return (number)res;
436  }
437  else
438  return NULL;
439 }
@ n_rep_gap_rat
(number), see longrat.h
Definition: coeffs.h:111
gmp_float numberFieldToFloat(number num, int cf)
Definition: mpr_complex.cc:438
#define QTOF
Definition: mpr_complex.h:19

◆ ngcMapR()

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

Definition at line 476 of file gnumpc.cc.

477 {
478  assume( getCoeffType(r) == n_long_C );
479  assume( getCoeffType(aRing) == n_R );
480 
481  if ( from != NULL )
482  {
483  gmp_complex *res=new gmp_complex((double)nrFloat(from));
484  return (number)res;
485  }
486  else
487  return NULL;
488 }
@ n_R
single prescision (6,6) real numbers
Definition: coeffs.h:31
SI_FLOAT nrFloat(number n)
Converts a n_R number into a float. Needed by Maps.
Definition: shortfl.cc:48

◆ ngcMapZ()

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

Definition at line 441 of file gnumpc.cc.

442 {
443  assume( getCoeffType(r) == n_long_C );
444  assume( aRing->rep == n_rep_gap_gmp);
445 
446  if ( from != NULL )
447  {
448  if (SR_HDL(from) & SR_INT)
449  {
450  gmp_float f_i= gmp_float(SR_TO_INT(from));
451  gmp_complex *res=new gmp_complex(f_i);
452  return (number)res;
453  }
454  gmp_float f_i=(mpz_ptr)from;
455  gmp_complex *res=new gmp_complex(f_i);
456  return (number)res;
457  }
458  else
459  return NULL;
460 }
@ n_rep_gap_gmp
(), see rinteger.h, new impl.
Definition: coeffs.h:112
#define SR_INT
Definition: longrat.h:67
#define SR_TO_INT(SR)
Definition: longrat.h:69
#define SR_HDL(A)
Definition: tgb.cc:35

◆ 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 124 of file gnumpc.cc.

125 {
126  assume( getCoeffType(R) == n_long_C );
127 
128  gmp_complex* r=(gmp_complex*)a;
129  (*r).neg();
130  return (number)a;
131 }
gmp_complex & neg()
Definition: mpr_complex.cc:660

◆ ngcParameter()

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

Definition at line 40 of file gnumpc.cc.

41 {
42  assume( getCoeffType(r) == n_long_C );
43  assume(i==1);
44 
45  if( i == 1 )
46  return (number)(new gmp_complex( 0L, 1L ));
47 
48  return NULL; // new gmp_complex( ) // 0?
49 }

◆ 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 }
Variable x
Definition: cfModGcd.cc:4082
#define n_New(n, r)
Definition: coeffs.h:440
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
const CanonicalForm & w
Definition: facAbsFact.cc:51
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:357

◆ 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 }
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
const CanonicalForm int s
Definition: facAbsFact.cc:51
const char * ngfRead(const char *s, number *a, const coeffs r)
Definition: gnumpfl.cc:312

◆ 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 }
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

◆ 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 }
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:891
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:800
@ n_rep_float
(float), see shortfl.h
Definition: coeffs.h:116
@ n_rep_int
(int), see modulop.h
Definition: coeffs.h:110
@ n_rep_gmp_float
(gmp_float), see
Definition: coeffs.h:117
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition: coeffs.h:836
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:894
static number ngcMapQ(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:427
static number ngcMapP(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:490
static number ngcCopyMap(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:501
static number ngcMapZ(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:441
static number ngcMapLongR(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:462
static number ngcMapR(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:476

◆ ngcSize()

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

Definition at line 80 of file gnumpc.cc.

81 {
82  int r = (int)((gmp_complex*)n)->real();
83  if (r < 0) r = -r;
84  int i = (int)((gmp_complex*)n)->imag();
85  if (i < 0) i = -i;
86  int oneNorm = r + i;
87  /* basically return the 1-norm of n;
88  only if this happens to be zero although n != 0,
89  return 1;
90  (this code ensures that zero has the size zero) */
91  if ((oneNorm == 0.0) & (ngcIsZero(n,R) == FALSE)) oneNorm = 1;
92  return oneNorm;
93 }
static CanonicalForm oneNorm(const CanonicalForm &F)

◆ 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 }
char * complexToStr(gmp_complex &c, const unsigned int oprec, const coeffs src)
Definition: mpr_complex.cc:704
void StringAppendS(const char *st)
Definition: reporter.cc:107