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 }
CanonicalForm b
Definition: cfModGcd.cc:4044
gmp_complex numbers based on
Definition: mpr_complex.h:179
@ n_long_C
complex floating point (GMP) numbers
Definition: coeffs.h:42
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:390
#define R
Definition: sirandom.c:26

◆ 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:98
#define FALSE
Definition: auxiliary.h:94
int p
Definition: cfModGcd.cc:4019
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:800
#define SHORT_REAL_LENGTH
Definition: numbers.h:58
#define NULL
Definition: omList.c:10

◆ 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 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define omAlloc(size)
Definition: omAllocDecl.h:210

◆ 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 }
#define Print
Definition: emacs.cc:80

◆ 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 }
CanonicalForm res
Definition: facAbsFact.cc:64
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:89

◆ 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:439
static int sign(int x)
Definition: ring.cc:3346

◆ 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 }
int i
Definition: cfEzgcd.cc:125

◆ 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 }
@ 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:99
static char * ngcCoeffString(const coeffs r)
Definition: gnumpc.cc:413
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:113
static number ngcInvers(number a, const coeffs R)
Definition: gnumpc.cc:137
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:55
static number ngcRePart(number a, const coeffs r)
Definition: gnumpc.cc:251
static void ngcCoeffWrite(const coeffs r, BOOLEAN)
Definition: gnumpc.cc:429
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:41
static void ngcWrite(number a, const coeffs r)
Definition: gnumpc.cc:362
static number ngcNeg(number a, const coeffs R)
Definition: gnumpc.cc:125
static BOOLEAN ngcIsZero(number a, const coeffs r)
Definition: gnumpc.cc:74
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:67
static char * ngcCoeffName(const coeffs r)
Definition: gnumpc.cc:421
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

◆ 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 }
void * ADDRESS
Definition: auxiliary.h:133
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:796
#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 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 }
@ n_long_R
real floating point (GMP) numbers
Definition: coeffs.h:34

◆ 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 }
@ n_Zp
\F{p < 2^31}
Definition: coeffs.h:30
long npInt(number &n, const coeffs r)
Definition: modulop.cc:128

◆ 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 }
@ n_rep_gap_rat
(number), see longrat.h
Definition: coeffs.h:111
gmp_float numberFieldToFloat(number num, int cf)
Definition: mpr_complex.cc:439
#define QTOF
Definition: mpr_complex.h:19

◆ 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 }
@ n_R
single prescision (6,6) real numbers
Definition: coeffs.h:32
SI_FLOAT nrFloat(number n)
Converts a n_R number into a float. Needed by Maps.
Definition: shortfl.cc:57

◆ 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 }
@ n_rep_gap_gmp
(), see rinteger.h, new impl.
Definition: coeffs.h:112
#define SR_INT
Definition: longrat.h:66
#define SR_TO_INT(SR)
Definition: longrat.h:68
#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 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 }
gmp_complex & neg()
Definition: mpr_complex.cc:661

◆ 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 }
Variable x
Definition: cfModGcd.cc:4023
#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:55
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:358

◆ 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:49
const char * ngfRead(const char *s, number *a, const coeffs r)
Definition: gnumpfl.cc:308

◆ 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:61

◆ 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:913
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:822
@ 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:858
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:916
static number ngcMapQ(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:435
static number ngcMapP(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:498
static number ngcCopyMap(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:509
static number ngcMapZ(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:449
static number ngcMapLongR(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:470
static number ngcMapR(number from, const coeffs aRing, const coeffs r)
Definition: gnumpc.cc:484

◆ 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 }
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:705
void StringAppendS(const char *st)
Definition: reporter.cc:107