Data Structures | Macros | Functions
mpr_complex.h File Reference
#include <coeffs/si_gmp.h>
#include <coeffs/mpr_global.h>

Go to the source code of this file.

Data Structures

class  gmp_float
 
class  gmp_complex
 gmp_complex numbers based on More...
 

Macros

#define ZTOF   1
 
#define QTOF   2
 
#define RTOF   3
 
#define CTOF   4
 

Functions

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 two parts: the "output" part a and the "rest" part b. More...
 
char * floatToStr (const gmp_float &r, const unsigned int oprec)
 
gmp_float abs (const gmp_float &)
 
gmp_float sqrt (const gmp_float &)
 
gmp_float hypot (const gmp_float &, const gmp_float &)
 
gmp_float sin (const gmp_float &)
 
gmp_float cos (const gmp_float &)
 
gmp_float log (const gmp_float &)
 
gmp_float exp (const gmp_float &)
 
gmp_float max (const gmp_float &, const gmp_float &)
 
gmp_float numberToFloat (number num, const coeffs src)
 
gmp_float numberFieldToFloat (number num, int src)
 
gmp_complex operator+ (const gmp_complex &a, const gmp_float b_d)
 
gmp_complex operator- (const gmp_complex &a, const gmp_float b_d)
 
gmp_complex operator* (const gmp_complex &a, const gmp_float b_d)
 
gmp_complex operator/ (const gmp_complex &a, const gmp_float b_d)
 
bool operator== (const gmp_complex &a, const gmp_complex &b)
 
bool operator> (const gmp_complex &a, const gmp_complex &b)
 
bool operator< (const gmp_complex &a, const gmp_complex &b)
 
bool operator>= (const gmp_complex &a, const gmp_complex &b)
 
bool operator<= (const gmp_complex &a, const gmp_complex &b)
 
gmp_float abs (const gmp_complex &c)
 
gmp_complex sqrt (const gmp_complex &x)
 
gmp_complex numberToComplex (number num, const coeffs r)
 
char * complexToStr (gmp_complex &c, const unsigned int oprec, const coeffs src)
 
bool complexNearZero (gmp_complex *c, int digits)
 

Macro Definition Documentation

§ CTOF

#define CTOF   4

Definition at line 21 of file mpr_complex.h.

§ QTOF

#define QTOF   2

Definition at line 19 of file mpr_complex.h.

§ RTOF

#define RTOF   3

Definition at line 20 of file mpr_complex.h.

§ ZTOF

#define ZTOF   1

Definition at line 18 of file mpr_complex.h.

Function Documentation

§ abs() [1/2]

gmp_float abs ( const gmp_float )

Definition at line 323 of file mpr_complex.cc.

324 {
325  gmp_float tmp;
326  mpf_abs( *(tmp._mpfp()), *a.mpfp() );
327  return tmp;
328 }
const poly a
Definition: syzextra.cc:212
mpf_t * _mpfp()
Definition: mpr_complex.h:134

§ abs() [2/2]

gmp_float abs ( const gmp_complex c)
inline

Definition at line 305 of file mpr_complex.h.

306 {
307  return hypot(c.real(),c.imag());
308 }
gmp_float real() const
Definition: mpr_complex.h:234
gmp_float hypot(const gmp_float &, const gmp_float &)
Definition: mpr_complex.cc:350
gmp_float imag() const
Definition: mpr_complex.h:235

§ complexNearZero()

bool complexNearZero ( gmp_complex c,
int  digits 
)

Definition at line 767 of file mpr_complex.cc.

768 {
769  gmp_float eps,epsm;
770 
771  if ( digits < 1 ) return true;
772 
773  eps=pow(10.0,(int)digits);
774  //Print("eps: %s\n",floatToStr(eps,gmp_output_digits));
775  eps=(gmp_float)1.0/eps;
776  epsm=-eps;
777 
778  //Print("eps: %s\n",floatToStr(eps,gmp_output_digits));
779 
780  if ( c->real().sign() > 0 ) // +
781  return (c->real() < eps && (c->imag() < eps && c->imag() > epsm));
782  else // -
783  return (c->real() > epsm && (c->imag() < eps && c->imag() > epsm));
784 }
gmp_float real() const
Definition: mpr_complex.h:234
int sign()
Definition: mpr_complex.h:123
Rational pow(const Rational &a, int e)
Definition: GMPrat.cc:418
gmp_float imag() const
Definition: mpr_complex.h:235

§ complexToStr()

char* complexToStr ( gmp_complex c,
const unsigned int  oprec,
const coeffs  src 
)

Definition at line 706 of file mpr_complex.cc.

707 {
708  const char * complex_parameter = "I";
709  int N = 1; // strlen(complex_parameter);
710 
711  if (nCoeff_is_long_C(src))
712  {
713  complex_parameter = n_ParameterNames(src)[0];
714  N = strlen(complex_parameter);
715  }
716 
717  assume( complex_parameter != NULL && N > 0);
718 
719  char *out,*in_imag,*in_real;
720 
721  c.SmallToZero();
722  if ( !c.imag().isZero() )
723  {
724 
725  in_real=floatToStr( c.real(), oprec ); // get real part
726  in_imag=floatToStr( abs(c.imag()), oprec ); // get imaginary part
727 
728  if (nCoeff_is_long_C(src))
729  {
730  int len=(strlen(in_real)+strlen(in_imag)+7+N)*sizeof(char);
731  out=(char*)omAlloc(len);
732  memset(out,0,len);
733  if ( !c.real().isZero() ) // (-23-i*5.43) or (15.1+i*5.3)
734  sprintf(out,"(%s%s%s*%s)",in_real,c.imag().sign()>=0?"+":"-",complex_parameter,in_imag);
735  else // (-i*43) or (i*34)
736  {
737  if (c.imag().isOne())
738  sprintf(out,"%s", complex_parameter);
739  else if (c.imag().isMOne())
740  sprintf(out,"-%s", complex_parameter);
741  else
742  sprintf(out,"(%s%s*%s)",c.imag().sign()>=0?"":"-", complex_parameter,in_imag);
743  }
744  }
745  else
746  {
747  int len=(strlen(in_real)+strlen(in_imag)+9) * sizeof(char);
748  out=(char*)omAlloc( len );
749  memset(out,0,len);
750  if ( !c.real().isZero() )
751  sprintf(out,"(%s%s%s)",in_real,c.imag().sign()>=0?"+I*":"-I*",in_imag);
752  else
753  sprintf(out,"(%s%s)",c.imag().sign()>=0?"I*":"-I*",in_imag);
754  }
755  omFree( (void *) in_real );
756  omFree( (void *) in_imag );
757  }
758  else
759  {
760  out= floatToStr( c.real(), oprec );
761  }
762 
763  return out;
764 }
void SmallToZero()
Definition: mpr_complex.cc:786
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:812
gmp_float real() const
Definition: mpr_complex.h:234
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:911
#define omAlloc(size)
Definition: omAllocDecl.h:210
bool isZero() const
Definition: mpr_complex.cc:254
int sign()
Definition: mpr_complex.h:123
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
#define omFree(addr)
Definition: omAllocDecl.h:261
#define assume(x)
Definition: mod2.h:394
gmp_float abs(const gmp_float &a)
Definition: mpr_complex.cc:323
bool isOne() const
Definition: mpr_complex.cc:259
#define NULL
Definition: omList.c:10
char * floatToStr(const gmp_float &r, const unsigned int oprec)
Definition: mpr_complex.cc:580
bool isMOne() const
Definition: mpr_complex.cc:275
gmp_float imag() const
Definition: mpr_complex.h:235

§ cos()

gmp_float cos ( const gmp_float )

Definition at line 340 of file mpr_complex.cc.

341 {
342  gmp_float tmp( cos((double)a) );
343  return tmp;
344 }
const poly a
Definition: syzextra.cc:212
gmp_float cos(const gmp_float &a)
Definition: mpr_complex.cc:340

§ exp()

gmp_float exp ( const gmp_float )

Definition at line 359 of file mpr_complex.cc.

360 {
361  gmp_float tmp( exp((double)a) );
362  return tmp;
363 }
const poly a
Definition: syzextra.cc:212
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:359

§ floatToStr()

char* floatToStr ( const gmp_float r,
const unsigned int  oprec 
)

Definition at line 580 of file mpr_complex.cc.

581 {
582 #if 1
583  mp_exp_t exponent;
584  int size,insize;
585  char *nout,*out,*in;
586 
587  insize= (oprec+2) * sizeof(char) + 10;
588  in= (char*)omAlloc( insize );
589 
590  mpf_get_str(in,&exponent,10,oprec,*(r.mpfp()));
591 
592  //if ( (exponent > 0)
593  //&& (exponent < (int)oprec)
594  //&& (strlen(in)-(in[0]=='-'?1:0) == oprec) )
595  //{
596  // omFree( (void *) in );
597  // insize= (exponent+oprec+2) * sizeof(char) + 10;
598  // in= (char*)omAlloc( insize );
599  // int newprec= exponent+oprec;
600  // mpf_get_str(in,&exponent,10,newprec,*(r.mpfp()));
601  //}
602  nout= nicifyFloatStr( in, exponent, oprec, &size, SIGN_EMPTY );
603  omFree( (void *) in );
604  out= (char*)omAlloc( (strlen(nout)+1) * sizeof(char) );
605  strcpy( out, nout );
606  omFree( (void *) nout );
607 
608  return out;
609 #else
610  // for testing purpose...
611  char *out= (char*)omAlloc( (1024) * sizeof(char) );
612  sprintf(out,"% .10f",(double)r);
613  return out;
614 #endif
615 }
char * nicifyFloatStr(char *in, mp_exp_t exponent, size_t oprec, int *size, int thesign)
Definition: mpr_complex.cc:487
#define SIGN_EMPTY
Definition: mpr_complex.cc:39
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omFree(addr)
Definition: omAllocDecl.h:261
const mpf_t * mpfp() const
Definition: mpr_complex.h:133
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
int exponent(const CanonicalForm &f, int q)
int exponent ( const CanonicalForm & f, int q )

§ hypot()

gmp_float hypot ( const gmp_float ,
const gmp_float  
)

Definition at line 350 of file mpr_complex.cc.

351 {
352 #if 1
353  return ( sqrt( (a*a) + (b*b) ) );
354 #else
355  gmp_float tmp( hypot( (double)a, (double)b ) );
356  return tmp;
357 #endif
358 }
const poly a
Definition: syzextra.cc:212
gmp_float hypot(const gmp_float &a, const gmp_float &b)
Definition: mpr_complex.cc:350
gmp_float sqrt(const gmp_float &a)
Definition: mpr_complex.cc:329
const poly b
Definition: syzextra.cc:213

§ log()

gmp_float log ( const gmp_float )

Definition at line 345 of file mpr_complex.cc.

346 {
347  gmp_float tmp( log((double)a) );
348  return tmp;
349 }
const poly a
Definition: syzextra.cc:212
gmp_float log(const gmp_float &a)
Definition: mpr_complex.cc:345

§ max()

gmp_float max ( const gmp_float ,
const gmp_float  
)

Definition at line 364 of file mpr_complex.cc.

365 {
366  gmp_float tmp;
367  a > b ? tmp= a : tmp= b;
368  return tmp;
369 }
const poly a
Definition: syzextra.cc:212
const poly b
Definition: syzextra.cc:213

§ numberFieldToFloat()

gmp_float numberFieldToFloat ( number  num,
int  src 
)

Definition at line 440 of file mpr_complex.cc.

441 {
442  gmp_float r;
443 
444  switch (cf)
445  {
446  case QTOF:
447  if ( num != NULL )
448  {
449  if (SR_HDL(num) & SR_INT)
450  {
451  r = gmp_float(SR_TO_INT(num));
452  }
453  else
454  {
455  if ( num->s != 3 )
456  {
457  r= gmp_float(num->z);
458  r/= gmp_float(num->n);
459  }
460  else
461  {
462  r= num->z;
463  }
464  }
465  }
466  else
467  {
468  r= 0.0;
469  }
470  break;
471  case RTOF:
472  r= *(gmp_float*)num;
473  break;
474  case CTOF:
475  WerrorS("Can not map from field C to field R!");
476  break;
477  case ZTOF:
478  default:
479  WerrorS("Ground field not implemented!");
480  } // switch
481 
482  return r;
483 }
#define ZTOF
Definition: mpr_complex.h:18
CanonicalForm num(const CanonicalForm &f)
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define CTOF
Definition: mpr_complex.h:21
const ring r
Definition: syzextra.cc:208
#define QTOF
Definition: mpr_complex.h:19
#define SR_TO_INT(SR)
Definition: mpr_complex.cc:35
CanonicalForm cf
Definition: cfModGcd.cc:4024
#define NULL
Definition: omList.c:10
#define SR_HDL(A)
Definition: mpr_complex.cc:34
#define SR_INT
Definition: longrat.h:68
#define RTOF
Definition: mpr_complex.h:20

§ numberToComplex()

gmp_complex numberToComplex ( number  num,
const coeffs  r 
)
inline

Definition at line 312 of file mpr_complex.h.

313 {
314  if (nCoeff_is_long_C(r))
315  {
316  return *(gmp_complex*)num;
317  }
318  else
319  {
320  return gmp_complex( numberToFloat(num, r) );
321  }
322 }
gmp_float numberToFloat(number num, const coeffs src)
Definition: mpr_complex.cc:374
CanonicalForm num(const CanonicalForm &f)
gmp_complex numbers based on
Definition: mpr_complex.h:178
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:911

§ numberToFloat()

gmp_float numberToFloat ( number  num,
const coeffs  src 
)

Definition at line 374 of file mpr_complex.cc.

375 {
376  gmp_float r;
377 
378  if ( nCoeff_is_Q(src) )
379  {
380  if ( num != NULL )
381  {
382  if (SR_HDL(num) & SR_INT)
383  {
384  //n_Print(num, src);printf("\n");
385  int nn = SR_TO_INT(num);
386  if((long)nn == SR_TO_INT(num))
387  r = SR_TO_INT(num);
388  else
389  r = gmp_float(SR_TO_INT(num));
390  //int dd = 20;
391  //gmp_printf("\nr = %.*Ff\n",dd,*r.mpfp());
392  //getchar();
393  }
394  else
395  {
396  if ( num->s == 0 )
397  {
398  nlNormalize( num, src ); // FIXME? TODO? // extern void nlNormalize(number &x, const coeffs r); // FIXME
399  }
400  if (SR_HDL(num) & SR_INT)
401  {
402  r= SR_TO_INT(num);
403  }
404  else
405  {
406  if ( num->s != 3 )
407  {
408  r= num->z;
409  r/= (gmp_float)num->n;
410  }
411  else
412  {
413  r= num->z;
414  }
415  }
416  }
417  }
418  else
419  {
420  r= 0.0;
421  }
422  }
423  else if (nCoeff_is_long_R(src) || nCoeff_is_long_C(src))
424  {
425  r= *(gmp_float*)num;
426  }
427  else if ( nCoeff_is_R(src) )
428  {
429  // Add some code here :-)
430  WerrorS("Ground field not implemented!");
431  }
432  else
433  {
434  WerrorS("Ground field not implemented!");
435  }
436 
437  return r;
438 }
CanonicalForm num(const CanonicalForm &f)
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:908
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition: coeffs.h:853
void WerrorS(const char *s)
Definition: feFopen.cc:24
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:840
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:911
const ring r
Definition: syzextra.cc:208
#define SR_TO_INT(SR)
Definition: mpr_complex.cc:35
void nlNormalize(number &x, const coeffs r)
Definition: longrat.cc:1334
#define NULL
Definition: omList.c:10
#define SR_HDL(A)
Definition: mpr_complex.cc:34
#define SR_INT
Definition: longrat.h:68

§ operator*()

gmp_complex operator* ( const gmp_complex a,
const gmp_float  b_d 
)
inline

Definition at line 255 of file mpr_complex.h.

256 {
257  return gmp_complex( a.r * b_d, a.i * b_d );
258 }
gmp_float i
Definition: mpr_complex.h:181
gmp_complex numbers based on
Definition: mpr_complex.h:178
gmp_float r
Definition: mpr_complex.h:181

§ operator+()

gmp_complex operator+ ( const gmp_complex a,
const gmp_float  b_d 
)
inline

Definition at line 247 of file mpr_complex.h.

248 {
249  return gmp_complex( a.r + b_d, a.i );
250 }
gmp_float i
Definition: mpr_complex.h:181
gmp_complex numbers based on
Definition: mpr_complex.h:178
gmp_float r
Definition: mpr_complex.h:181

§ operator-()

gmp_complex operator- ( const gmp_complex a,
const gmp_float  b_d 
)
inline

Definition at line 251 of file mpr_complex.h.

252 {
253  return gmp_complex( a.r - b_d, a.i );
254 }
gmp_float i
Definition: mpr_complex.h:181
gmp_complex numbers based on
Definition: mpr_complex.h:178
gmp_float r
Definition: mpr_complex.h:181

§ operator/()

gmp_complex operator/ ( const gmp_complex a,
const gmp_float  b_d 
)
inline

Definition at line 259 of file mpr_complex.h.

260 {
261  return gmp_complex( a.r / b_d, a.i / b_d );
262 }
gmp_float i
Definition: mpr_complex.h:181
gmp_complex numbers based on
Definition: mpr_complex.h:178
gmp_float r
Definition: mpr_complex.h:181

§ operator<()

bool operator< ( const gmp_complex a,
const gmp_complex b 
)
inline

Definition at line 273 of file mpr_complex.h.

274 {
275  return ( a.real() < b.real() );
276 }
gmp_float real() const
Definition: mpr_complex.h:234

§ operator<=()

bool operator<= ( const gmp_complex a,
const gmp_complex b 
)
inline

Definition at line 281 of file mpr_complex.h.

282 {
283  return ( a.real() <= b.real() );
284 }
gmp_float real() const
Definition: mpr_complex.h:234

§ operator==()

bool operator== ( const gmp_complex a,
const gmp_complex b 
)
inline

Definition at line 265 of file mpr_complex.h.

266 {
267  return ( b.real() == a.real() ) && ( b.imag() == a.imag() );
268 }
gmp_float real() const
Definition: mpr_complex.h:234
gmp_float imag() const
Definition: mpr_complex.h:235

§ operator>()

bool operator> ( const gmp_complex a,
const gmp_complex b 
)
inline

Definition at line 269 of file mpr_complex.h.

270 {
271  return ( a.real() > b.real() );
272 }
gmp_float real() const
Definition: mpr_complex.h:234

§ operator>=()

bool operator>= ( const gmp_complex a,
const gmp_complex b 
)
inline

Definition at line 277 of file mpr_complex.h.

278 {
279  return ( a.real() >= b.real() );
280 }
gmp_float real() const
Definition: mpr_complex.h:234

§ 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 two parts: the "output" part a and the "rest" part b.

According to the GMP-precision digits is recomputed to bits (basis 2). Two numbers a, b are equal if | a - b | < | a | * 0.1^digits . In this case we have a - b = 0 . The epsilon e is e=0.1^(digits+rest) with 1+e != 1, but 1+0.1*e = 1.

Definition at line 62 of file mpr_complex.cc.

63 {
64  size_t bits = 1 + (size_t) ((float)digits * 3.5);
65  size_t rb = 1 + (size_t) ((float)rest * 3.5);
66  size_t db = bits+rb;
67  gmp_output_digits= digits;
68  mpf_set_default_prec( db );
69  if (diff!=NULL) delete diff;
70  diff=new gmp_float(0.0);
71  mpf_set_prec(*diff->_mpfp(),32);
72  if (gmpRel!=NULL) delete gmpRel;
73  gmpRel=new gmp_float(0.0);
74  mpf_set_prec(*gmpRel->_mpfp(),32);
75  mpf_set_d(*gmpRel->_mpfp(),0.1);
76  mpf_pow_ui(*gmpRel->_mpfp(),*gmpRel->_mpfp(),digits);
77 }
static gmp_float * diff
Definition: mpr_complex.cc:47
mpf_t * _mpfp()
Definition: mpr_complex.h:134
#define NULL
Definition: omList.c:10
static gmp_float * gmpRel
Definition: mpr_complex.cc:46
size_t gmp_output_digits
Definition: mpr_complex.cc:44

§ sin()

gmp_float sin ( const gmp_float )

Definition at line 335 of file mpr_complex.cc.

336 {
337  gmp_float tmp( sin((double)a) );
338  return tmp;
339 }
const poly a
Definition: syzextra.cc:212
gmp_float sin(const gmp_float &a)
Definition: mpr_complex.cc:335

§ sqrt() [1/2]

gmp_float sqrt ( const gmp_float )

Definition at line 329 of file mpr_complex.cc.

330 {
331  gmp_float tmp;
332  mpf_sqrt( *(tmp._mpfp()), *a.mpfp() );
333  return tmp;
334 }
const poly a
Definition: syzextra.cc:212
mpf_t * _mpfp()
Definition: mpr_complex.h:134

§ sqrt() [2/2]

gmp_complex sqrt ( const gmp_complex x)

Definition at line 678 of file mpr_complex.cc.

679 {
680  gmp_float r = abs(x);
681  gmp_float nr, ni;
682  if (r == (gmp_float) 0.0)
683  {
684  nr = ni = r;
685  }
686  else if ( x.real() > (gmp_float)0)
687  {
688  nr = sqrt((gmp_float)0.5 * (r + x.real()));
689  ni = x.imag() / nr / (gmp_float)2;
690  }
691  else
692  {
693  ni = sqrt((gmp_float)0.5 * (r - x.real()));
694  if (x.imag() < (gmp_float)0)
695  {
696  ni = - ni;
697  }
698  nr = x.imag() / ni / (gmp_float)2;
699  }
700  gmp_complex tmp(nr, ni);
701  return tmp;
702 }
gmp_float real() const
Definition: mpr_complex.h:234
gmp_complex numbers based on
Definition: mpr_complex.h:178
const ring r
Definition: syzextra.cc:208
gmp_float sqrt(const gmp_float &a)
Definition: mpr_complex.cc:329
gmp_float abs(const gmp_float &a)
Definition: mpr_complex.cc:323
gmp_float imag() const
Definition: mpr_complex.h:235