My Project  debian-1:4.1.2-p1+ds-2
Data Structures | Typedefs | Functions
amp Namespace Reference

Data Structures

class  ampf
 
class  campf
 
class  divisionByZero
 
class  domainError
 
class  exception
 
class  incorrectPrecision
 
class  internalError
 
class  invalidConversion
 
class  invalidString
 
struct  mpfr_record
 
class  mpfr_reference
 
class  mpfr_storage
 
class  overflow
 
class  sqrtOfNegativeNumber
 

Typedefs

typedef unsigned long unsigned32
 
typedef signed long signed32
 
typedef mpfr_recordmpfr_record_ptr
 

Functions

template<unsigned int Precision>
const bool operator== (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
const bool operator!= (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
const bool operator< (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
const bool operator> (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
const bool operator<= (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
const bool operator>= (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
const ampf< Precision > operator+ (const ampf< Precision > &op1)
 
template<unsigned int Precision>
const ampf< Precision > operator- (const ampf< Precision > &op1)
 
template<unsigned int Precision>
const ampf< Precision > operator+ (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
const ampf< Precision > operator- (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
const ampf< Precision > operator* (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
const ampf< Precision > operator/ (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
const ampf< Precision > sqr (const ampf< Precision > &x)
 
template<unsigned int Precision>
const int sign (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > abs (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > maximum (const ampf< Precision > &x, const ampf< Precision > &y)
 
template<unsigned int Precision>
const ampf< Precision > minimum (const ampf< Precision > &x, const ampf< Precision > &y)
 
template<unsigned int Precision>
const ampf< Precision > sqrt (const ampf< Precision > &x)
 
template<unsigned int Precision>
const signed long trunc (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > frac (const ampf< Precision > &x)
 
template<unsigned int Precision>
const signed long floor (const ampf< Precision > &x)
 
template<unsigned int Precision>
const signed long ceil (const ampf< Precision > &x)
 
template<unsigned int Precision>
const signed long round (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > frexp2 (const ampf< Precision > &x, mp_exp_t *exponent)
 
template<unsigned int Precision>
const ampf< Precision > ldexp2 (const ampf< Precision > &x, mp_exp_t exponent)
 
 __AMP_BINARY_OPI (char) __AMP_BINARY_OPI(short) __AMP_BINARY_OPI(long) __AMP_BINARY_OPI(int) __AMP_BINARY_OPF(float) __AMP_BINARY_OPF(double) __AMP_BINARY_OPF(long double) template< unsigned int Precision > const ampf< Precision > pi()
 
template<unsigned int Precision>
const ampf< Precision > halfpi ()
 
template<unsigned int Precision>
const ampf< Precision > twopi ()
 
template<unsigned int Precision>
const ampf< Precision > sin (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > cos (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > tan (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > asin (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > acos (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > atan (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > atan2 (const ampf< Precision > &y, const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > log (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > log2 (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > log10 (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > exp (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > sinh (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > cosh (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > tanh (const ampf< Precision > &x)
 
template<unsigned int Precision>
const ampf< Precision > pow (const ampf< Precision > &x, const ampf< Precision > &y)
 
template<unsigned int Precision>
const bool operator== (const campf< Precision > &lhs, const campf< Precision > &rhs)
 
template<unsigned int Precision>
const bool operator!= (const campf< Precision > &lhs, const campf< Precision > &rhs)
 
template<unsigned int Precision>
const campf< Precision > operator+ (const campf< Precision > &lhs)
 
template<unsigned int Precision>
campf< Precision > & operator+= (campf< Precision > &lhs, const campf< Precision > &rhs)
 
template<unsigned int Precision>
const campf< Precision > operator+ (const campf< Precision > &lhs, const campf< Precision > &rhs)
 
template<unsigned int Precision>
const campf< Precision > operator- (const campf< Precision > &lhs)
 
template<unsigned int Precision>
campf< Precision > & operator-= (campf< Precision > &lhs, const campf< Precision > &rhs)
 
template<unsigned int Precision>
const campf< Precision > operator- (const campf< Precision > &lhs, const campf< Precision > &rhs)
 
template<unsigned int Precision>
campf< Precision > & operator*= (campf< Precision > &lhs, const campf< Precision > &rhs)
 
template<unsigned int Precision>
const campf< Precision > operator* (const campf< Precision > &lhs, const campf< Precision > &rhs)
 
template<unsigned int Precision>
const campf< Precision > operator/ (const campf< Precision > &lhs, const campf< Precision > &rhs)
 
template<unsigned int Precision>
campf< Precision > & operator/= (campf< Precision > &lhs, const campf< Precision > &rhs)
 
template<unsigned int Precision>
const ampf< Precision > abscomplex (const campf< Precision > &z)
 
template<unsigned int Precision>
const campf< Precision > conj (const campf< Precision > &z)
 
template<unsigned int Precision>
const campf< Precision > csqr (const campf< Precision > &z)
 
template<unsigned int Precision>
void vMove (ap::raw_vector< ampf< Precision > > vDst, ap::const_raw_vector< ampf< Precision > > vSrc)
 
template<unsigned int Precision>
void vMoveNeg (ap::raw_vector< ampf< Precision > > vDst, ap::const_raw_vector< ampf< Precision > > vSrc)
 
template<unsigned int Precision, class T2 >
void vMove (ap::raw_vector< ampf< Precision > > vDst, ap::const_raw_vector< ampf< Precision > > vSrc, T2 alpha)
 
template<unsigned int Precision>
void vAdd (ap::raw_vector< ampf< Precision > > vDst, ap::const_raw_vector< ampf< Precision > > vSrc)
 
template<unsigned int Precision, class T2 >
void vAdd (ap::raw_vector< ampf< Precision > > vDst, ap::const_raw_vector< ampf< Precision > > vSrc, T2 alpha)
 
template<unsigned int Precision>
void vSub (ap::raw_vector< ampf< Precision > > vDst, ap::const_raw_vector< ampf< Precision > > vSrc)
 
template<unsigned int Precision, class T2 >
void vSub (ap::raw_vector< ampf< Precision > > vDst, ap::const_raw_vector< ampf< Precision > > vSrc, T2 alpha)
 
template<unsigned int Precision, class T2 >
void vMul (ap::raw_vector< ampf< Precision > > vDst, T2 alpha)
 
template<unsigned int Precision>
bool operator== (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
bool operator!= (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
bool operator< (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
bool operator> (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
bool operator<= (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
bool operator>= (const ampf< Precision > &op1, const ampf< Precision > &op2)
 
template<unsigned int Precision>
int sign (const ampf< Precision > &x)
 
template<unsigned int Precision>
signed long trunc (const ampf< Precision > &x)
 
template<unsigned int Precision>
signed long floor (const ampf< Precision > &x)
 
template<unsigned int Precision>
signed long ceil (const ampf< Precision > &x)
 
template<unsigned int Precision>
signed long round (const ampf< Precision > &x)
 
template<unsigned int Precision>
bool operator== (const campf< Precision > &lhs, const campf< Precision > &rhs)
 
template<unsigned int Precision>
bool operator!= (const campf< Precision > &lhs, const campf< Precision > &rhs)
 

Data Structure Documentation

◆ amp::mpfr_record

struct amp::mpfr_record

Definition at line 33 of file amp.h.

Data Fields
mpfr_record * next
unsigned int Precision
unsigned int refCount
mpfr_t value

Typedef Documentation

◆ mpfr_record_ptr

Definition at line 41 of file amp.h.

◆ signed32

typedef signed long amp::signed32

Definition at line 31 of file amp.h.

◆ unsigned32

typedef unsigned long amp::unsigned32

Definition at line 30 of file amp.h.

Function Documentation

◆ __AMP_BINARY_OPI()

amp::__AMP_BINARY_OPI ( char  ) const

Definition at line 889 of file amp.h.

895  { return ampf<Precision>(op1)+op2; } \
896  template<unsigned int Precision> const ampf<Precision> operator+(const ampf<Precision>& op1, const type& op2) { return op1+ampf<Precision>(op2); } \
897  template<unsigned int Precision> const ampf<Precision> operator-(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)-op2; } \
898  template<unsigned int Precision> const ampf<Precision> operator-(const ampf<Precision>& op1, const type& op2) { return op1-ampf<Precision>(op2); } \
899  template<unsigned int Precision> const ampf<Precision> operator*(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)*op2; } \
900  template<unsigned int Precision> const ampf<Precision> operator*(const ampf<Precision>& op1, const type& op2) { return op1*ampf<Precision>(op2); } \
901  template<unsigned int Precision> const ampf<Precision> operator/(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)/op2; } \
902  template<unsigned int Precision> const ampf<Precision> operator/(const ampf<Precision>& op1, const type& op2) { return op1/ampf<Precision>(op2); } \
903  template<unsigned int Precision> bool operator==(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)==op2; } \
904  template<unsigned int Precision> bool operator==(const ampf<Precision>& op1, const type& op2) { return op1==ampf<Precision>(op2); } \
905  template<unsigned int Precision> bool operator!=(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)!=op2; } \
906  template<unsigned int Precision> bool operator!=(const ampf<Precision>& op1, const type& op2) { return op1!=ampf<Precision>(op2); } \
907  template<unsigned int Precision> bool operator<=(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)<=op2; } \
908  template<unsigned int Precision> bool operator<=(const ampf<Precision>& op1, const type& op2) { return op1<=ampf<Precision>(op2); } \
909  template<unsigned int Precision> bool operator>=(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)>=op2; } \
910  template<unsigned int Precision> bool operator>=(const ampf<Precision>& op1, const type& op2) { return op1>=ampf<Precision>(op2); } \
911  template<unsigned int Precision> bool operator<(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)<op2; } \
912  template<unsigned int Precision> bool operator<(const ampf<Precision>& op1, const type& op2) { return op1<ampf<Precision>(op2); } \
913  template<unsigned int Precision> bool operator>(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)>op2; } \
914  template<unsigned int Precision> bool operator>(const ampf<Precision>& op1, const type& op2) { return op1>ampf<Precision>(op2); }
915  __AMP_BINARY_OPF(float)
916  __AMP_BINARY_OPF(double)
917  __AMP_BINARY_OPF(long double)
918  #undef __AMP_BINARY_OPF
919 
920  //
921  // transcendent functions
922  //
923  template<unsigned int Precision>
924  const ampf<Precision> pi()
925  {
926  mpfr_record *v = mpfr_storage::newMpfr(Precision);
927  mpfr_const_pi(v->value, GMP_RNDN);
928  return v;
929  }

◆ abs()

template<unsigned int Precision>
const ampf< Precision > amp::abs ( const ampf< Precision > &  x)

Definition at line 713 of file amp.h.

714  {
715  // TODO: optimize temporary for return value
716  ampf<Precision> res;
717  mpfr_abs(res.getWritePtr(), x.getReadPtr(), GMP_RNDN);
718  return res;
719  }

◆ abscomplex()

template<unsigned int Precision>
const ampf< Precision > amp::abscomplex ( const campf< Precision > &  z)

Definition at line 1207 of file amp.h.

1208  {
1209  ampf<Precision> w, xabs, yabs, v;
1210 
1211  xabs = abs(z.x);
1212  yabs = abs(z.y);
1213  w = xabs>yabs ? xabs : yabs;
1214  v = xabs<yabs ? xabs : yabs;
1215  if( v==0 )
1216  return w;
1217  else
1218  {
1219  ampf<Precision> t = v/w;
1220  return w*sqrt(1+sqr(t));
1221  }
1222  }

◆ acos()

template<unsigned int Precision>
const ampf< Precision > amp::acos ( const ampf< Precision > &  x)

Definition at line 982 of file amp.h.

983  {
984  mpfr_record *v = mpfr_storage::newMpfr(Precision);
985  mpfr_acos(v->value, x.getReadPtr(), GMP_RNDN);
986  return v;
987  }

◆ asin()

template<unsigned int Precision>
const ampf< Precision > amp::asin ( const ampf< Precision > &  x)

Definition at line 974 of file amp.h.

975  {
976  mpfr_record *v = mpfr_storage::newMpfr(Precision);
977  mpfr_asin(v->value, x.getReadPtr(), GMP_RNDN);
978  return v;
979  }

◆ atan()

template<unsigned int Precision>
const ampf< Precision > amp::atan ( const ampf< Precision > &  x)

Definition at line 990 of file amp.h.

991  {
992  mpfr_record *v = mpfr_storage::newMpfr(Precision);
993  mpfr_atan(v->value, x.getReadPtr(), GMP_RNDN);
994  return v;
995  }

◆ atan2()

template<unsigned int Precision>
const ampf< Precision > amp::atan2 ( const ampf< Precision > &  y,
const ampf< Precision > &  x 
)

Definition at line 998 of file amp.h.

999  {
1000  mpfr_record *v = mpfr_storage::newMpfr(Precision);
1001  mpfr_atan2(v->value, y.getReadPtr(), x.getReadPtr(), GMP_RNDN);
1002  return v;
1003  }

◆ ceil() [1/2]

template<unsigned int Precision>
const signed long amp::ceil ( const ampf< Precision > &  x)

Definition at line 788 of file amp.h.

789  {
790  ampf<Precision> tmp;
791  signed long r;
792  mpfr_ceil(tmp.getWritePtr(), x.getReadPtr());
793  if( mpfr_integer_p(tmp.getReadPtr())==0 )
794  throw invalidConversion();
795  mpfr_clear_erangeflag();
796  r = mpfr_get_si(tmp.getReadPtr(), GMP_RNDN);
797  if( mpfr_erangeflag_p()!=0 )
798  throw invalidConversion();
799  return r;
800  }

◆ ceil() [2/2]

template<unsigned int Precision>
signed long amp::ceil ( const ampf< Precision > &  x)

Definition at line 1802 of file svd_si.h.

1807  {
1808  ampf<Precision> tmp;
1809  signed long r;
1810  mpfr_ceil(tmp.getWritePtr(), x.getReadPtr());
1811  if( mpfr_integer_p(tmp.getReadPtr())==0 )
1812  //throw invalidConversion();
1813  WerrorS("internalError");
1814  mpfr_clear_erangeflag();
1815  r = mpfr_get_si(tmp.getReadPtr(), GMP_RNDN);
1816  if( mpfr_erangeflag_p()!=0 )

◆ conj()

template<unsigned int Precision>
const campf< Precision > amp::conj ( const campf< Precision > &  z)

Definition at line 1225 of file amp.h.

1226  {
1227  return campf<Precision>(z.x, -z.y);
1228  }

◆ cos()

template<unsigned int Precision>
const ampf< Precision > amp::cos ( const ampf< Precision > &  x)

Definition at line 958 of file amp.h.

959  {
960  mpfr_record *v = mpfr_storage::newMpfr(Precision);
961  mpfr_cos(v->value, x.getReadPtr(), GMP_RNDN);
962  return v;
963  }

◆ cosh()

template<unsigned int Precision>
const ampf< Precision > amp::cosh ( const ampf< Precision > &  x)

Definition at line 1046 of file amp.h.

1047  {
1048  mpfr_record *v = mpfr_storage::newMpfr(Precision);
1049  mpfr_cosh(v->value, x.getReadPtr(), GMP_RNDN);
1050  return v;
1051  }

◆ csqr()

template<unsigned int Precision>
const campf< Precision > amp::csqr ( const campf< Precision > &  z)

Definition at line 1231 of file amp.h.

1232  {
1233  ampf<Precision> t = z.x*z.y;
1234  return campf<Precision>(sqr(z.x)-sqr(z.y), t+t);
1235  }

◆ exp()

template<unsigned int Precision>
const ampf< Precision > amp::exp ( const ampf< Precision > &  x)

Definition at line 1030 of file amp.h.

1031  {
1032  mpfr_record *v = mpfr_storage::newMpfr(Precision);
1033  mpfr_exp(v->value, x.getReadPtr(), GMP_RNDN);
1034  return v;
1035  }

◆ floor() [1/2]

template<unsigned int Precision>
const signed long amp::floor ( const ampf< Precision > &  x)

Definition at line 773 of file amp.h.

774  {
775  ampf<Precision> tmp;
776  signed long r;
777  mpfr_floor(tmp.getWritePtr(), x.getReadPtr());
778  if( mpfr_integer_p(tmp.getReadPtr())==0 )
779  throw invalidConversion();
780  mpfr_clear_erangeflag();
781  r = mpfr_get_si(tmp.getReadPtr(), GMP_RNDN);
782  if( mpfr_erangeflag_p()!=0 )
783  throw invalidConversion();
784  return r;
785  }

◆ floor() [2/2]

template<unsigned int Precision>
signed long amp::floor ( const ampf< Precision > &  x)

Definition at line 1785 of file svd_si.h.

1790  {
1791  ampf<Precision> tmp;
1792  signed long r;
1793  mpfr_floor(tmp.getWritePtr(), x.getReadPtr());
1794  if( mpfr_integer_p(tmp.getReadPtr())==0 )
1795  //throw invalidConversion();
1796  WerrorS("internalError");
1797  mpfr_clear_erangeflag();
1798  r = mpfr_get_si(tmp.getReadPtr(), GMP_RNDN);
1799  if( mpfr_erangeflag_p()!=0 )

◆ frac()

template<unsigned int Precision>
const ampf< Precision > amp::frac ( const ampf< Precision > &  x)

Definition at line 764 of file amp.h.

765  {
766  // TODO: optimize temporary for return value
767  ampf<Precision> r;
768  mpfr_frac(r.getWritePtr(), x.getReadPtr(), GMP_RNDN);
769  return r;
770  }

◆ frexp2()

template<unsigned int Precision>
const ampf< Precision > amp::frexp2 ( const ampf< Precision > &  x,
mp_exp_t *  exponent 
)

Definition at line 818 of file amp.h.

819  {
820  // TODO: optimize temporary for return value
821  ampf<Precision> r;
822  if( !x.isFiniteNumber() )
823  throw invalidConversion();
824  if( x.isZero() )
825  {
826  *exponent = 0;
827  r = 0;
828  return r;
829  }
830  r = x;
831  *exponent = mpfr_get_exp(r.getReadPtr());
832  mpfr_set_exp(r.getWritePtr(),0);
833  return r;
834  }

◆ halfpi()

template<unsigned int Precision>
const ampf< Precision > amp::halfpi ( )

Definition at line 932 of file amp.h.

933  {
934  mpfr_record *v = mpfr_storage::newMpfr(Precision);
935  mpfr_const_pi(v->value, GMP_RNDN);
936  mpfr_mul_2si(v->value, v->value, -1, GMP_RNDN);
937  return v;
938  }

◆ ldexp2()

template<unsigned int Precision>
const ampf< Precision > amp::ldexp2 ( const ampf< Precision > &  x,
mp_exp_t  exponent 
)

Definition at line 837 of file amp.h.

838  {
839  // TODO: optimize temporary for return value
840  ampf<Precision> r;
841  mpfr_mul_2si(r.getWritePtr(), x.getReadPtr(), exponent, GMP_RNDN);
842  return r;
843  }

◆ log()

template<unsigned int Precision>
const ampf< Precision > amp::log ( const ampf< Precision > &  x)

Definition at line 1006 of file amp.h.

1007  {
1008  mpfr_record *v = mpfr_storage::newMpfr(Precision);
1009  mpfr_log(v->value, x.getReadPtr(), GMP_RNDN);
1010  return v;
1011  }

◆ log10()

template<unsigned int Precision>
const ampf< Precision > amp::log10 ( const ampf< Precision > &  x)

Definition at line 1022 of file amp.h.

1023  {
1024  mpfr_record *v = mpfr_storage::newMpfr(Precision);
1025  mpfr_log10(v->value, x.getReadPtr(), GMP_RNDN);
1026  return v;
1027  }

◆ log2()

template<unsigned int Precision>
const ampf< Precision > amp::log2 ( const ampf< Precision > &  x)

Definition at line 1014 of file amp.h.

1015  {
1016  mpfr_record *v = mpfr_storage::newMpfr(Precision);
1017  mpfr_log2(v->value, x.getReadPtr(), GMP_RNDN);
1018  return v;
1019  }

◆ maximum()

template<unsigned int Precision>
const ampf< Precision > amp::maximum ( const ampf< Precision > &  x,
const ampf< Precision > &  y 
)

Definition at line 722 of file amp.h.

723  {
724  // TODO: optimize temporary for return value
725  ampf<Precision> res;
726  mpfr_max(res.getWritePtr(), x.getReadPtr(), y.getReadPtr(), GMP_RNDN);
727  return res;
728  }

◆ minimum()

template<unsigned int Precision>
const ampf< Precision > amp::minimum ( const ampf< Precision > &  x,
const ampf< Precision > &  y 
)

Definition at line 731 of file amp.h.

732  {
733  // TODO: optimize temporary for return value
734  ampf<Precision> res;
735  mpfr_min(res.getWritePtr(), x.getReadPtr(), y.getReadPtr(), GMP_RNDN);
736  return res;
737  }

◆ operator!=() [1/4]

template<unsigned int Precision>
const bool amp::operator!= ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 610 of file amp.h.

611  {
612  return mpfr_cmp(op1.getReadPtr(), op2.getReadPtr())!=0;
613  }

◆ operator!=() [2/4]

template<unsigned int Precision>
bool amp::operator!= ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 1620 of file svd_si.h.

1625  {

◆ operator!=() [3/4]

template<unsigned int Precision>
const bool amp::operator!= ( const campf< Precision > &  lhs,
const campf< Precision > &  rhs 
)

Definition at line 1136 of file amp.h.

1137  { return lhs.x!=rhs.x || lhs.y!=rhs.y; }

◆ operator!=() [4/4]

template<unsigned int Precision>
bool amp::operator!= ( const campf< Precision > &  lhs,
const campf< Precision > &  rhs 
)

Definition at line 2155 of file svd_si.h.

2156  { return lhs.x==rhs.x && lhs.y==rhs.y; }

◆ operator*() [1/2]

template<unsigned int Precision>
const ampf< Precision > amp::operator* ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 674 of file amp.h.

675  {
676  mpfr_record *v = mpfr_storage::newMpfr(Precision);
677  mpfr_mul(v->value, op1.getReadPtr(), op2.getReadPtr(), GMP_RNDN);
678  return v;
679  }

◆ operator*() [2/2]

template<unsigned int Precision>
const campf< Precision > amp::operator* ( const campf< Precision > &  lhs,
const campf< Precision > &  rhs 
)

Definition at line 1173 of file amp.h.

1174  { campf<Precision> r = lhs; r *= rhs; return r; }

◆ operator*=()

template<unsigned int Precision>
campf< Precision > & amp::operator*= ( campf< Precision > &  lhs,
const campf< Precision > &  rhs 
)

Definition at line 1164 of file amp.h.

1165  {
1166  ampf<Precision> xx(lhs.x*rhs.x), yy(lhs.y*rhs.y), mm((lhs.x+lhs.y)*(rhs.x+rhs.y));
1167  lhs.x = xx-yy;
1168  lhs.y = mm-xx-yy;
1169  return lhs;
1170  }

◆ operator+() [1/4]

template<unsigned int Precision>
const ampf< Precision > amp::operator+ ( const ampf< Precision > &  op1)

Definition at line 643 of file amp.h.

644  {
645  return op1;
646  }

◆ operator+() [2/4]

template<unsigned int Precision>
const ampf< Precision > amp::operator+ ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 657 of file amp.h.

658  {
659  mpfr_record *v = mpfr_storage::newMpfr(Precision);
660  mpfr_add(v->value, op1.getReadPtr(), op2.getReadPtr(), GMP_RNDN);
661  return v;
662  }

◆ operator+() [3/4]

template<unsigned int Precision>
const campf< Precision > amp::operator+ ( const campf< Precision > &  lhs)

Definition at line 1140 of file amp.h.

1141  { return lhs; }

◆ operator+() [4/4]

template<unsigned int Precision>
const campf< Precision > amp::operator+ ( const campf< Precision > &  lhs,
const campf< Precision > &  rhs 
)

Definition at line 1148 of file amp.h.

1149  { campf<Precision> r = lhs; r += rhs; return r; }

◆ operator+=()

template<unsigned int Precision>
campf< Precision > & amp::operator+= ( campf< Precision > &  lhs,
const campf< Precision > &  rhs 
)

Definition at line 1144 of file amp.h.

1145  { lhs.x += rhs.x; lhs.y += rhs.y; return lhs; }

◆ operator-() [1/4]

template<unsigned int Precision>
const ampf< Precision > amp::operator- ( const ampf< Precision > &  op1)

Definition at line 649 of file amp.h.

650  {
651  mpfr_record *v = mpfr_storage::newMpfr(Precision);
652  mpfr_neg(v->value, op1.getReadPtr(), GMP_RNDN);
653  return v;
654  }

◆ operator-() [2/4]

template<unsigned int Precision>
const ampf< Precision > amp::operator- ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 665 of file amp.h.

666  {
667  mpfr_record *v = mpfr_storage::newMpfr(Precision);
668  mpfr_sub(v->value, op1.getReadPtr(), op2.getReadPtr(), GMP_RNDN);
669  return v;
670  }

◆ operator-() [3/4]

template<unsigned int Precision>
const campf< Precision > amp::operator- ( const campf< Precision > &  lhs)

Definition at line 1152 of file amp.h.

1153  { return campf<Precision>(-lhs.x, -lhs.y); }

◆ operator-() [4/4]

template<unsigned int Precision>
const campf< Precision > amp::operator- ( const campf< Precision > &  lhs,
const campf< Precision > &  rhs 
)

Definition at line 1160 of file amp.h.

1161  { campf<Precision> r = lhs; r -= rhs; return r; }

◆ operator-=()

template<unsigned int Precision>
campf< Precision > & amp::operator-= ( campf< Precision > &  lhs,
const campf< Precision > &  rhs 
)

Definition at line 1156 of file amp.h.

1157  { lhs.x -= rhs.x; lhs.y -= rhs.y; return lhs; }

◆ operator/() [1/2]

template<unsigned int Precision>
const ampf< Precision > amp::operator/ ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 682 of file amp.h.

683  {
684  mpfr_record *v = mpfr_storage::newMpfr(Precision);
685  mpfr_div(v->value, op1.getReadPtr(), op2.getReadPtr(), GMP_RNDN);
686  return v;
687  }

◆ operator/() [2/2]

template<unsigned int Precision>
const campf< Precision > amp::operator/ ( const campf< Precision > &  lhs,
const campf< Precision > &  rhs 
)

Definition at line 1177 of file amp.h.

1178  {
1179  campf<Precision> result;
1180  ampf<Precision> e;
1181  ampf<Precision> f;
1182  if( abs(rhs.y)<abs(rhs.x) )
1183  {
1184  e = rhs.y/rhs.x;
1185  f = rhs.x+rhs.y*e;
1186  result.x = (lhs.x+lhs.y*e)/f;
1187  result.y = (lhs.y-lhs.x*e)/f;
1188  }
1189  else
1190  {
1191  e = rhs.x/rhs.y;
1192  f = rhs.y+rhs.x*e;
1193  result.x = (lhs.y+lhs.x*e)/f;
1194  result.y = (-lhs.x+lhs.y*e)/f;
1195  }
1196  return result;
1197  }

◆ operator/=()

template<unsigned int Precision>
campf< Precision > & amp::operator/= ( campf< Precision > &  lhs,
const campf< Precision > &  rhs 
)

Definition at line 1200 of file amp.h.

1201  {
1202  lhs = lhs/rhs;
1203  return lhs;
1204  }

◆ operator<() [1/2]

template<unsigned int Precision>
const bool amp::operator< ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 616 of file amp.h.

617  {
618  return mpfr_cmp(op1.getReadPtr(), op2.getReadPtr())<0;
619  }

◆ operator<() [2/2]

template<unsigned int Precision>
bool amp::operator< ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 1626 of file svd_si.h.

1631  {

◆ operator<=() [1/2]

template<unsigned int Precision>
const bool amp::operator<= ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 628 of file amp.h.

629  {
630  return mpfr_cmp(op1.getReadPtr(), op2.getReadPtr())<=0;
631  }

◆ operator<=() [2/2]

template<unsigned int Precision>
bool amp::operator<= ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 1638 of file svd_si.h.

1643  {

◆ operator==() [1/4]

template<unsigned int Precision>
const bool amp::operator== ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 604 of file amp.h.

605  {
606  return mpfr_cmp(op1.getReadPtr(), op2.getReadPtr())==0;
607  }

◆ operator==() [2/4]

template<unsigned int Precision>
bool amp::operator== ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 1614 of file svd_si.h.

1619  {

◆ operator==() [3/4]

template<unsigned int Precision>
const bool amp::operator== ( const campf< Precision > &  lhs,
const campf< Precision > &  rhs 
)

Definition at line 1132 of file amp.h.

1133  { return lhs.x==rhs.x && lhs.y==rhs.y; }

◆ operator==() [4/4]

template<unsigned int Precision>
bool amp::operator== ( const campf< Precision > &  lhs,
const campf< Precision > &  rhs 
)

Definition at line 2151 of file svd_si.h.

2156  { return lhs.x==rhs.x && lhs.y==rhs.y; }

◆ operator>() [1/2]

template<unsigned int Precision>
const bool amp::operator> ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 622 of file amp.h.

623  {
624  return mpfr_cmp(op1.getReadPtr(), op2.getReadPtr())>0;
625  }

◆ operator>() [2/2]

template<unsigned int Precision>
bool amp::operator> ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 1632 of file svd_si.h.

1637  {

◆ operator>=() [1/2]

template<unsigned int Precision>
const bool amp::operator>= ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 634 of file amp.h.

635  {
636  return mpfr_cmp(op1.getReadPtr(), op2.getReadPtr())>=0;
637  }

◆ operator>=() [2/2]

template<unsigned int Precision>
bool amp::operator>= ( const ampf< Precision > &  op1,
const ampf< Precision > &  op2 
)

Definition at line 1644 of file svd_si.h.

1649  {

◆ pow()

template<unsigned int Precision>
const ampf< Precision > amp::pow ( const ampf< Precision > &  x,
const ampf< Precision > &  y 
)

Definition at line 1062 of file amp.h.

1063  {
1064  mpfr_record *v = mpfr_storage::newMpfr(Precision);
1065  mpfr_pow(v->value, x.getReadPtr(), y.getReadPtr(), GMP_RNDN);
1066  return v;
1067  }

◆ round() [1/2]

template<unsigned int Precision>
const signed long amp::round ( const ampf< Precision > &  x)

Definition at line 803 of file amp.h.

804  {
805  ampf<Precision> tmp;
806  signed long r;
807  mpfr_round(tmp.getWritePtr(), x.getReadPtr());
808  if( mpfr_integer_p(tmp.getReadPtr())==0 )
809  throw invalidConversion();
810  mpfr_clear_erangeflag();
811  r = mpfr_get_si(tmp.getReadPtr(), GMP_RNDN);
812  if( mpfr_erangeflag_p()!=0 )
813  throw invalidConversion();
814  return r;
815  }

◆ round() [2/2]

template<unsigned int Precision>
signed long amp::round ( const ampf< Precision > &  x)

Definition at line 1819 of file svd_si.h.

1824  {
1825  ampf<Precision> tmp;
1826  signed long r;
1827  mpfr_round(tmp.getWritePtr(), x.getReadPtr());
1828  if( mpfr_integer_p(tmp.getReadPtr())==0 )
1829  //throw invalidConversion();
1830  WerrorS("internalError");
1831  mpfr_clear_erangeflag();
1832  r = mpfr_get_si(tmp.getReadPtr(), GMP_RNDN);
1833  if( mpfr_erangeflag_p()!=0 )

◆ sign() [1/2]

template<unsigned int Precision>
const int amp::sign ( const ampf< Precision > &  x)

Definition at line 702 of file amp.h.

703  {
704  int s = mpfr_sgn(x.getReadPtr());
705  if( s>0 )
706  return +1;
707  if( s<0 )
708  return -1;
709  return 0;
710  }

◆ sign() [2/2]

template<unsigned int Precision>
int amp::sign ( const ampf< Precision > &  x)

Definition at line 1712 of file svd_si.h.

1717  {
1718  int s = mpfr_sgn(x.getReadPtr());
1719  if( s>0 )
1720  return +1;

◆ sin()

template<unsigned int Precision>
const ampf< Precision > amp::sin ( const ampf< Precision > &  x)

Definition at line 950 of file amp.h.

951  {
952  mpfr_record *v = mpfr_storage::newMpfr(Precision);
953  mpfr_sin(v->value, x.getReadPtr(), GMP_RNDN);
954  return v;
955  }

◆ sinh()

template<unsigned int Precision>
const ampf< Precision > amp::sinh ( const ampf< Precision > &  x)

Definition at line 1038 of file amp.h.

1039  {
1040  mpfr_record *v = mpfr_storage::newMpfr(Precision);
1041  mpfr_sinh(v->value, x.getReadPtr(), GMP_RNDN);
1042  return v;
1043  }

◆ sqr()

template<unsigned int Precision>
const ampf< Precision > amp::sqr ( const ampf< Precision > &  x)

Definition at line 693 of file amp.h.

694  {
695  // TODO: optimize temporary for return value
696  ampf<Precision> res;
697  mpfr_sqr(res.getWritePtr(), x.getReadPtr(), GMP_RNDN);
698  return res;
699  }

◆ sqrt()

template<unsigned int Precision>
const ampf< Precision > amp::sqrt ( const ampf< Precision > &  x)

Definition at line 740 of file amp.h.

741  {
742  // TODO: optimize temporary for return value
743  ampf<Precision> res;
744  mpfr_sqrt(res.getWritePtr(), x.getReadPtr(), GMP_RNDN);
745  return res;
746  }

◆ tan()

template<unsigned int Precision>
const ampf< Precision > amp::tan ( const ampf< Precision > &  x)

Definition at line 966 of file amp.h.

967  {
968  mpfr_record *v = mpfr_storage::newMpfr(Precision);
969  mpfr_tan(v->value, x.getReadPtr(), GMP_RNDN);
970  return v;
971  }

◆ tanh()

template<unsigned int Precision>
const ampf< Precision > amp::tanh ( const ampf< Precision > &  x)

Definition at line 1054 of file amp.h.

1055  {
1056  mpfr_record *v = mpfr_storage::newMpfr(Precision);
1057  mpfr_tanh(v->value, x.getReadPtr(), GMP_RNDN);
1058  return v;
1059  }

◆ trunc() [1/2]

template<unsigned int Precision>
const signed long amp::trunc ( const ampf< Precision > &  x)

Definition at line 749 of file amp.h.

750  {
751  ampf<Precision> tmp;
752  signed long r;
753  mpfr_trunc(tmp.getWritePtr(), x.getReadPtr());
754  if( mpfr_integer_p(tmp.getReadPtr())==0 )
755  throw invalidConversion();
756  mpfr_clear_erangeflag();
757  r = mpfr_get_si(tmp.getReadPtr(), GMP_RNDN);
758  if( mpfr_erangeflag_p()!=0 )
759  throw invalidConversion();
760  return r;
761  }

◆ trunc() [2/2]

template<unsigned int Precision>
signed long amp::trunc ( const ampf< Precision > &  x)

Definition at line 1759 of file svd_si.h.

1764  {
1765  ampf<Precision> tmp;
1766  signed long r;
1767  mpfr_trunc(tmp.getWritePtr(), x.getReadPtr());
1768  if( mpfr_integer_p(tmp.getReadPtr())==0 )
1769  //throw invalidConversion();
1770  WerrorS("internalError");
1771  mpfr_clear_erangeflag();
1772  r = mpfr_get_si(tmp.getReadPtr(), GMP_RNDN);
1773  if( mpfr_erangeflag_p()!=0 )

◆ twopi()

template<unsigned int Precision>
const ampf< Precision > amp::twopi ( )

Definition at line 941 of file amp.h.

942  {
943  mpfr_record *v = mpfr_storage::newMpfr(Precision);
944  mpfr_const_pi(v->value, GMP_RNDN);
945  mpfr_mul_2si(v->value, v->value, +1, GMP_RNDN);
946  return v;
947  }

◆ vAdd() [1/2]

template<unsigned int Precision>
void amp::vAdd ( ap::raw_vector< ampf< Precision > >  vDst,
ap::const_raw_vector< ampf< Precision > >  vSrc 
)

Definition at line 1379 of file amp.h.

1380  {
1382  int i, cnt = vDst.GetLength();
1383  ampf<Precision> *pDst = vDst.GetData();
1384  const ampf<Precision> *pSrc = vSrc.GetData();
1385  for(i=0; i<cnt; i++)
1386  {
1387  mpfr_ptr v = pDst->getWritePtr();
1388  mpfr_srcptr vs = pSrc->getReadPtr();
1389  mpfr_add(v, v, vs, GMP_RNDN);
1390  pDst += vDst.GetStep();
1391  pSrc += vSrc.GetStep();
1392  }
1393  }

◆ vAdd() [2/2]

template<unsigned int Precision, class T2 >
void amp::vAdd ( ap::raw_vector< ampf< Precision > >  vDst,
ap::const_raw_vector< ampf< Precision > >  vSrc,
T2  alpha 
)

Definition at line 1396 of file amp.h.

1397  {
1399  int i, cnt = vDst.GetLength();
1400  ampf<Precision> *pDst = vDst.GetData();
1401  const ampf<Precision> *pSrc = vSrc.GetData();
1402  ampf<Precision> a(alpha), tmp;
1403  for(i=0; i<cnt; i++)
1404  {
1405  mpfr_ptr v = pDst->getWritePtr();
1406  mpfr_srcptr vs = pSrc->getReadPtr();
1407  mpfr_mul(tmp.getWritePtr(), a.getReadPtr(), vs, GMP_RNDN);
1408  mpfr_add(v, v, tmp.getWritePtr(), GMP_RNDN);
1409  pDst += vDst.GetStep();
1410  pSrc += vSrc.GetStep();
1411  }
1412  }

◆ vMove() [1/2]

template<unsigned int Precision>
void amp::vMove ( ap::raw_vector< ampf< Precision > >  vDst,
ap::const_raw_vector< ampf< Precision > >  vSrc 
)

Definition at line 1327 of file amp.h.

1328  {
1330  int i, cnt = vDst.GetLength();
1331  ampf<Precision> *pDst = vDst.GetData();
1332  const ampf<Precision> *pSrc = vSrc.GetData();
1333  if( pDst==pSrc )
1334  return;
1335  for(i=0; i<cnt; i++)
1336  {
1337  *pDst = *pSrc;
1338  pDst += vDst.GetStep();
1339  pSrc += vSrc.GetStep();
1340  }
1341  }

◆ vMove() [2/2]

template<unsigned int Precision, class T2 >
void amp::vMove ( ap::raw_vector< ampf< Precision > >  vDst,
ap::const_raw_vector< ampf< Precision > >  vSrc,
T2  alpha 
)

Definition at line 1361 of file amp.h.

1362  {
1364  int i, cnt = vDst.GetLength();
1365  ampf<Precision> *pDst = vDst.GetData();
1366  const ampf<Precision> *pSrc = vSrc.GetData();
1367  ampf<Precision> a(alpha);
1368  for(i=0; i<cnt; i++)
1369  {
1370  *pDst = *pSrc;
1371  mpfr_ptr v = pDst->getWritePtr();
1372  mpfr_mul(v, v, a.getReadPtr(), GMP_RNDN);
1373  pDst += vDst.GetStep();
1374  pSrc += vSrc.GetStep();
1375  }
1376  }

◆ vMoveNeg()

template<unsigned int Precision>
void amp::vMoveNeg ( ap::raw_vector< ampf< Precision > >  vDst,
ap::const_raw_vector< ampf< Precision > >  vSrc 
)

Definition at line 1344 of file amp.h.

1345  {
1347  int i, cnt = vDst.GetLength();
1348  ampf<Precision> *pDst = vDst.GetData();
1349  const ampf<Precision> *pSrc = vSrc.GetData();
1350  for(i=0; i<cnt; i++)
1351  {
1352  *pDst = *pSrc;
1353  mpfr_ptr v = pDst->getWritePtr();
1354  mpfr_neg(v, v, GMP_RNDN);
1355  pDst += vDst.GetStep();
1356  pSrc += vSrc.GetStep();
1357  }
1358  }

◆ vMul()

template<unsigned int Precision, class T2 >
void amp::vMul ( ap::raw_vector< ampf< Precision > >  vDst,
T2  alpha 
)

Definition at line 1438 of file amp.h.

1439  {
1440  int i, cnt = vDst.GetLength();
1441  ampf<Precision> *pDst = vDst.GetData();
1442  ampf<Precision> a(alpha);
1443  for(i=0; i<cnt; i++)
1444  {
1445  mpfr_ptr v = pDst->getWritePtr();
1446  mpfr_mul(v, a.getReadPtr(), v, GMP_RNDN);
1447  pDst += vDst.GetStep();
1448  }
1449  }

◆ vSub() [1/2]

template<unsigned int Precision>
void amp::vSub ( ap::raw_vector< ampf< Precision > >  vDst,
ap::const_raw_vector< ampf< Precision > >  vSrc 
)

Definition at line 1415 of file amp.h.

1416  {
1418  int i, cnt = vDst.GetLength();
1419  ampf<Precision> *pDst = vDst.GetData();
1420  const ampf<Precision> *pSrc = vSrc.GetData();
1421  for(i=0; i<cnt; i++)
1422  {
1423  mpfr_ptr v = pDst->getWritePtr();
1424  mpfr_srcptr vs = pSrc->getReadPtr();
1425  mpfr_sub(v, v, vs, GMP_RNDN);
1426  pDst += vDst.GetStep();
1427  pSrc += vSrc.GetStep();
1428  }
1429  }

◆ vSub() [2/2]

template<unsigned int Precision, class T2 >
void amp::vSub ( ap::raw_vector< ampf< Precision > >  vDst,
ap::const_raw_vector< ampf< Precision > >  vSrc,
T2  alpha 
)

Definition at line 1432 of file amp.h.

1433  {
1434  vAdd(vDst, vSrc, -alpha);
1435  }
exponent
int exponent(const CanonicalForm &f, int q)
int exponent ( const CanonicalForm & f, int q )
Definition: gengftables-conway.cc:92
f
FILE * f
Definition: checklibs.c:9
x
Variable x
Definition: cfModGcd.cc:4023
y
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
result
return result
Definition: facAbsBiFact.cc:76
amp::abs
const ampf< Precision > abs(const ampf< Precision > &x)
Definition: amp.h:713
amp::sqrt
const ampf< Precision > sqrt(const ampf< Precision > &x)
Definition: amp.h:740
amp::operator+
const campf< Precision > operator+(const campf< Precision > &lhs, const campf< Precision > &rhs)
Definition: amp.h:1148
w
const CanonicalForm & w
Definition: facAbsFact.cc:55
amp::operator-
const campf< Precision > operator-(const campf< Precision > &lhs, const campf< Precision > &rhs)
Definition: amp.h:1160
pi
#define pi
Definition: libparse.cc:1144
i
int i
Definition: cfEzgcd.cc:125
res
CanonicalForm res
Definition: facAbsFact.cc:64
amp::operator*
const campf< Precision > operator*(const campf< Precision > &lhs, const campf< Precision > &rhs)
Definition: amp.h:1173
alpha
Variable alpha
Definition: facAbsBiFact.cc:52
amp::sqr
const ampf< Precision > sqr(const ampf< Precision > &x)
Definition: amp.h:693
amp::operator!=
const bool operator!=(const campf< Precision > &lhs, const campf< Precision > &rhs)
Definition: amp.h:1136
ap::const_raw_vector::GetLength
int GetLength() const
Definition: ap.h:149
amp::operator<
const bool operator<(const ampf< Precision > &op1, const ampf< Precision > &op2)
Definition: amp.h:616
ap::ap_error::make_assertion
static void make_assertion(bool bClause)
Definition: ap.h:51
amp::operator<=
const bool operator<=(const ampf< Precision > &op1, const ampf< Precision > &op2)
Definition: amp.h:628
amp::operator>=
const bool operator>=(const ampf< Precision > &op1, const ampf< Precision > &op2)
Definition: amp.h:634
amp::operator==
const bool operator==(const campf< Precision > &lhs, const campf< Precision > &rhs)
Definition: amp.h:1132
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
ap::const_raw_vector::GetStep
int GetStep() const
Definition: ap.h:152
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
__AMP_BINARY_OPF
#define __AMP_BINARY_OPF(type)
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
amp::vAdd
void vAdd(ap::raw_vector< ampf< Precision > > vDst, ap::const_raw_vector< ampf< Precision > > vSrc, T2 alpha)
Definition: amp.h:1396
ap::const_raw_vector::GetData
const T * GetData() const
Definition: ap.h:146
amp::operator>
const bool operator>(const ampf< Precision > &op1, const ampf< Precision > &op2)
Definition: amp.h:622
ap::raw_vector::GetData
T * GetData()
Definition: ap.h:175
amp::operator/
const campf< Precision > operator/(const campf< Precision > &lhs, const campf< Precision > &rhs)
Definition: amp.h:1177