My Project
Loading...
Searching...
No Matches
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 }
bool operator!=(const Rational &a, const Rational &b)
Definition: GMPrat.cc:318
bool operator<(const Rational &a, const Rational &b)
Definition: GMPrat.cc:288
bool operator==(const Rational &a, const Rational &b)
Definition: GMPrat.cc:312
Rational operator/(const Rational &a, const Rational &b)
Definition: GMPrat.cc:422
bool operator>(const Rational &a, const Rational &b)
Definition: GMPrat.cc:300
bool operator<=(const Rational &a, const Rational &b)
Definition: GMPrat.cc:294
bool operator>=(const Rational &a, const Rational &b)
Definition: GMPrat.cc:306
#define __AMP_BINARY_OPF(type)
Definition: amp.h:82
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
fglmVector operator-(const fglmVector &v)
Definition: fglmvec.cc:398
fglmVector operator+(const fglmVector &lhs, const fglmVector &rhs)
Definition: fglmvec.cc:412
fglmVector operator*(const fglmVector &v, const number n)
Definition: fglmvec.cc:426
#define pi
Definition: libparse.cc:1145

◆ 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
717 mpfr_abs(res.getWritePtr(), x.getReadPtr(), GMP_RNDN);
718 return res;
719 }
Variable x
Definition: cfModGcd.cc:4082
CanonicalForm res
Definition: facAbsFact.cc:60

◆ 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 }
Rational abs(const Rational &a)
Definition: GMPrat.cc:436
ampf< Precision > y
Definition: amp.h:1125
ampf< Precision > x
Definition: amp.h:1125
const CanonicalForm & w
Definition: facAbsFact.cc:51
gmp_float sqrt(const gmp_float &a)
Definition: mpr_complex.cc:327
const ampf< Precision > sqr(const ampf< Precision > &x)
Definition: amp.h:693

◆ 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 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:53

◆ 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 }
mpfr_ptr getWritePtr()
Definition: amp.h:302
mpfr_srcptr getReadPtr() const
Definition: amp.h:291

◆ ceil() [2/2]

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

Definition at line 1806 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 )
1817 //throw invalidConversion();
1818 WerrorS("internalError");
1819 return r;
1820 }
void WerrorS(const char *s)
Definition: feFopen.cc:24

◆ 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 1789 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 )
1800 //throw invalidConversion();
1801 WerrorS("internalError");
1802 return r;
1803 }

◆ 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
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
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 }
#define exponent

◆ 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
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
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
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 1624 of file svd_si.h.

1625 {
1626 return mpfr_cmp(op1.getReadPtr(), op2.getReadPtr())!=0;
1627 }

◆ 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 2159 of file svd_si.h.

2160 { 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 {
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 }
FILE * f
Definition: checklibs.c:9
return result
Definition: facAbsBiFact.cc:75

◆ 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 1630 of file svd_si.h.

1631 {
1632 return mpfr_cmp(op1.getReadPtr(), op2.getReadPtr())<0;
1633 }

◆ 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 1642 of file svd_si.h.

1643 {
1644 return mpfr_cmp(op1.getReadPtr(), op2.getReadPtr())<=0;
1645 }

◆ 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 1618 of file svd_si.h.

1619 {
1620 return mpfr_cmp(op1.getReadPtr(), op2.getReadPtr())==0;
1621 }

◆ 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 2155 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 1636 of file svd_si.h.

1637 {
1638 return mpfr_cmp(op1.getReadPtr(), op2.getReadPtr())>0;
1639 }

◆ 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 1648 of file svd_si.h.

1649 {
1650 return mpfr_cmp(op1.getReadPtr(), op2.getReadPtr())>=0;
1651 }

◆ 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 1823 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 )
1834 //throw invalidConversion();
1835 WerrorS("internalError");
1836 return r;
1837 }

◆ 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 }
const CanonicalForm int s
Definition: facAbsFact.cc:51

◆ sign() [2/2]

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

Definition at line 1716 of file svd_si.h.

1717 {
1718 int s = mpfr_sgn(x.getReadPtr());
1719 if( s>0 )
1720 return +1;
1721 if( s<0 )
1722 return -1;
1723 return 0;
1724 }

◆ 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
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
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 1763 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 )
1774 //throw invalidConversion();
1775 WerrorS("internalError");
1776 return r;
1777 }

◆ 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 }
int i
Definition: cfEzgcd.cc:132
static void make_assertion(bool bClause)
Definition: ap.h:49
int GetStep() const
Definition: ap.h:148
const T * GetData() const
Definition: ap.h:142
int GetLength() const
Definition: ap.h:145
T * GetData()
Definition: ap.h:172

◆ 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 }
Variable alpha
Definition: facAbsBiFact.cc:51

◆ 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();
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();
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 }
void vAdd(ap::raw_vector< ampf< Precision > > vDst, ap::const_raw_vector< ampf< Precision > > vSrc)
Definition: amp.h:1379