My Project
Loading...
Searching...
No Matches
Data Structures | Namespaces | Macros | Typedefs | Functions
amp.h File Reference
#include <gmp.h>
#include <mpfr.h>
#include <stdexcept>
#include <math.h>
#include <string>
#include <stdio.h>
#include <time.h>
#include <memory.h>
#include <vector>
#include <list>
#include <ap.h>

Go to the source code of this file.

Data Structures

class  amp::exception
 
class  amp::incorrectPrecision
 
class  amp::overflow
 
class  amp::divisionByZero
 
class  amp::sqrtOfNegativeNumber
 
class  amp::invalidConversion
 
class  amp::invalidString
 
class  amp::internalError
 
class  amp::domainError
 
struct  amp::mpfr_record
 
class  amp::mpfr_storage
 
class  amp::mpfr_reference
 
class  amp::ampf< Precision >
 
class  amp::campf< Precision >
 

Namespaces

namespace  amp
 

Macros

#define __AMP_BINARY_OPI(type)
 
#define __AMP_BINARY_OPF(type)
 
#define __AMP_BINARY_OPI(type)
 
#define __AMP_BINARY_OPF(type)
 

Typedefs

typedef unsigned long amp::unsigned32
 
typedef signed long amp::signed32
 
typedef mpfr_record * amp::mpfr_record_ptr
 

Functions

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

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

Macro Definition Documentation

◆ __AMP_BINARY_OPF [1/2]

#define __AMP_BINARY_OPF (   type)
Value:
template<unsigned int Precision> const ampf<Precision> operator+(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)+op2; } \
template<unsigned int Precision> const ampf<Precision> operator+(const ampf<Precision>& op1, const type& op2) { return op1+ampf<Precision>(op2); } \
template<unsigned int Precision> const ampf<Precision> operator-(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)-op2; } \
template<unsigned int Precision> const ampf<Precision> operator-(const ampf<Precision>& op1, const type& op2) { return op1-ampf<Precision>(op2); } \
template<unsigned int Precision> const ampf<Precision> operator*(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)*op2; } \
template<unsigned int Precision> const ampf<Precision> operator*(const ampf<Precision>& op1, const type& op2) { return op1*ampf<Precision>(op2); } \
template<unsigned int Precision> const ampf<Precision> operator/(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)/op2; } \
template<unsigned int Precision> const ampf<Precision> operator/(const ampf<Precision>& op1, const type& op2) { return op1/ampf<Precision>(op2); } \
template<unsigned int Precision> bool operator==(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)==op2; } \
template<unsigned int Precision> bool operator==(const ampf<Precision>& op1, const type& op2) { return op1==ampf<Precision>(op2); } \
template<unsigned int Precision> bool operator!=(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)!=op2; } \
template<unsigned int Precision> bool operator!=(const ampf<Precision>& op1, const type& op2) { return op1!=ampf<Precision>(op2); } \
template<unsigned int Precision> bool operator<=(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)<=op2; } \
template<unsigned int Precision> bool operator<=(const ampf<Precision>& op1, const type& op2) { return op1<=ampf<Precision>(op2); } \
template<unsigned int Precision> bool operator>=(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)>=op2; } \
template<unsigned int Precision> bool operator>=(const ampf<Precision>& op1, const type& op2) { return op1>=ampf<Precision>(op2); } \
template<unsigned int Precision> bool operator<(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)<op2; } \
template<unsigned int Precision> bool operator<(const ampf<Precision>& op1, const type& op2) { return op1<ampf<Precision>(op2); } \
template<unsigned int Precision> bool operator>(const type& op1, const ampf<Precision>& op2) { return ampf<Precision>(op1)>op2; } \
template<unsigned int Precision> bool operator>(const ampf<Precision>& op1, const type& op2) { return op1>ampf<Precision>(op2); }
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
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

◆ __AMP_BINARY_OPF [2/2]

#define __AMP_BINARY_OPF (   type)
Value:
template<unsigned int Precision> const campf<Precision> operator+ (const type& op1, const campf<Precision>& op2) { return campf<Precision>(op1+op2.x, op2.y); } \
template<unsigned int Precision> const campf<Precision> operator+ (const campf<Precision>& op1, const type& op2) { return campf<Precision>(op1.x+op2, op1.y); } \
template<unsigned int Precision> const campf<Precision> operator- (const type& op1, const campf<Precision>& op2) { return campf<Precision>(op1-op2.x, -op2.y); } \
template<unsigned int Precision> const campf<Precision> operator- (const campf<Precision>& op1, const type& op2) { return campf<Precision>(op1.x-op2, op1.y); } \
template<unsigned int Precision> const campf<Precision> operator* (const type& op1, const campf<Precision>& op2) { return campf<Precision>(op1*op2.x, op1*op2.y); } \
template<unsigned int Precision> const campf<Precision> operator* (const campf<Precision>& op1, const type& op2) { return campf<Precision>(op2*op1.x, op2*op1.y); } \
template<unsigned int Precision> const campf<Precision> operator/ (const type& op1, const campf<Precision>& op2) { return campf<Precision>(ampf<Precision>(op1),ampf<Precision>(0))/op2; } \
template<unsigned int Precision> const campf<Precision> operator/ (const campf<Precision>& op1, const type& op2) { return campf<Precision>(op1.x/op2, op1.y/op2); } \
template<unsigned int Precision> bool operator==(const type& op1, const campf<Precision>& op2) { return op1==op2.x && op2.y==0; } \
template<unsigned int Precision> bool operator==(const campf<Precision>& op1, const type& op2) { return op1.x==op2 && op1.y==0; } \
template<unsigned int Precision> bool operator!=(const type& op1, const campf<Precision>& op2) { return op1!=op2.x || op2.y!=0; } \
template<unsigned int Precision> bool operator!=(const campf<Precision>& op1, const type& op2) { return op1.x!=op2 || op1.y!=0; }

◆ __AMP_BINARY_OPI [1/2]

#define __AMP_BINARY_OPI (   type)

Definition at line 1240 of file amp.h.

◆ __AMP_BINARY_OPI [2/2]

#define __AMP_BINARY_OPI (   type)
Value:
template<unsigned int Precision> const campf<Precision> operator+ (const signed type& op1, const campf<Precision>& op2) { return campf<Precision>(op1+op2.x, op2.y); } \
template<unsigned int Precision> const campf<Precision> operator+ (const unsigned type& op1, const campf<Precision>& op2) { return campf<Precision>(op1+op2.x, op2.y); } \
template<unsigned int Precision> const campf<Precision> operator+ (const campf<Precision>& op1, const signed type& op2) { return campf<Precision>(op1.x+op2, op1.y); } \
template<unsigned int Precision> const campf<Precision> operator+ (const campf<Precision>& op1, const unsigned type& op2) { return campf<Precision>(op1.x+op2, op1.y); } \
template<unsigned int Precision> const campf<Precision> operator- (const signed type& op1, const campf<Precision>& op2) { return campf<Precision>(op1-op2.x, -op2.y); } \
template<unsigned int Precision> const campf<Precision> operator- (const unsigned type& op1, const campf<Precision>& op2) { return campf<Precision>(op1-op2.x, -op2.y); } \
template<unsigned int Precision> const campf<Precision> operator- (const campf<Precision>& op1, const signed type& op2) { return campf<Precision>(op1.x-op2, op1.y); } \
template<unsigned int Precision> const campf<Precision> operator- (const campf<Precision>& op1, const unsigned type& op2) { return campf<Precision>(op1.x-op2, op1.y); } \
template<unsigned int Precision> const campf<Precision> operator* (const signed type& op1, const campf<Precision>& op2) { return campf<Precision>(op1*op2.x, op1*op2.y); } \
template<unsigned int Precision> const campf<Precision> operator* (const unsigned type& op1, const campf<Precision>& op2) { return campf<Precision>(op1*op2.x, op1*op2.y); } \
template<unsigned int Precision> const campf<Precision> operator* (const campf<Precision>& op1, const signed type& op2) { return campf<Precision>(op2*op1.x, op2*op1.y); } \
template<unsigned int Precision> const campf<Precision> operator* (const campf<Precision>& op1, const unsigned type& op2) { return campf<Precision>(op2*op1.x, op2*op1.y); } \
template<unsigned int Precision> const campf<Precision> operator/ (const signed type& op1, const campf<Precision>& op2) { return campf<Precision>(ampf<Precision>(op1),ampf<Precision>(0))/op2; } \
template<unsigned int Precision> const campf<Precision> operator/ (const unsigned type& op1, const campf<Precision>& op2) { return campf<Precision>(ampf<Precision>(op1),ampf<Precision>(0))/op2; } \
template<unsigned int Precision> const campf<Precision> operator/ (const campf<Precision>& op1, const signed type& op2) { return campf<Precision>(op1.x/op2, op1.y/op2); } \
template<unsigned int Precision> const campf<Precision> operator/ (const campf<Precision>& op1, const unsigned type& op2) { return campf<Precision>(op1.x/op2, op1.y/op2); } \
template<unsigned int Precision> bool operator==(const signed type& op1, const campf<Precision>& op2) { return op1==op2.x && op2.y==0; } \
template<unsigned int Precision> bool operator==(const unsigned type& op1, const campf<Precision>& op2) { return op1==op2.x && op2.y==0; } \
template<unsigned int Precision> bool operator==(const campf<Precision>& op1, const signed type& op2) { return op1.x==op2 && op1.y==0; } \
template<unsigned int Precision> bool operator==(const campf<Precision>& op1, const unsigned type& op2) { return op1.x==op2 && op1.y==0; } \
template<unsigned int Precision> bool operator!=(const campf<Precision>& op1, const signed type& op2) { return op1.x!=op2 || op1.y!=0; } \
template<unsigned int Precision> bool operator!=(const campf<Precision>& op1, const unsigned type& op2) { return op1.x!=op2 || op1.y!=0; } \
template<unsigned int Precision> bool operator!=(const signed type& op1, const campf<Precision>& op2) { return op1!=op2.x || op2.y!=0; } \
template<unsigned int Precision> bool operator!=(const unsigned type& op1, const campf<Precision>& op2) { return op1!=op2.x || op2.y!=0; }

Definition at line 1240 of file amp.h.