<nacre/fp_comparator.hpp>
]<nacre/rational.hpp>
]<nacre/polynomial.hpp>
]
<nacre/complex.hpp>
]
<nacre/fp_comparator.hpp>
]Comparison of two floating point numbers respecting to some epsilon, machine epsilon by default.
namespace nacre {
namespace comparator {
template<typename T> class FpComparator {
public:
FpComparator (const T& epsilon = std::numeric_limits<T>::epsilon()) throw ();
T& getEpsilon () throw();
const T& getEpsilon () const throw();
void setEpsilon (const T&) throw();
/**
* Ternary.
* +1 if x > y,
* 0 if x = y,
* -1 if x < y.
*/
int operator () (const T&, const T&);
};
} // namespace comparator
} // namespace nacre
<nacre/rational.hpp>
]namespace nacre {
namespace rational {
template<typename T> class Rational {
public:
Rational ();
template<typename I> Rational (const I& num, const I& den = T(1));
template<typename I> Rational (const Rational<I>&);
const T& num () const;
const T& den () const;
T& num ();
T& den ();
template<typename F> operator F () const;
template<typename I> Rational<T>& operator+= (const I&);
template<typename I> Rational<T>& operator-= (const I&);
template<typename I> Rational<T>& operator*= (const I&);
template<typename I> Rational<T>& operator/= (const I&);
template<typename I> Rational<T>& operator= (const Rational<I>&);
template<typename I> Rational<T>& operator+= (const Rational<I>&);
template<typename I> Rational<T>& operator-= (const Rational<I>&);
template<typename I> Rational<T>& operator*= (const Rational<I>&);
template<typename I> Rational<T>& operator/= (const Rational<I>&);
}; // class Rational
template<typename T> Rational<T> operator+(const Rational<T>&, const Rational<T>&);
template<typename T> Rational<T> operator+(const Rational<T>&, const T&);
template<typename T> Rational<T> operator+(const T&, const Rational<T>&);
template<typename T> Rational<T> operator-(const Rational<T>&, const Rational<T>&);
template<typename T> Rational<T> operator-(const Rational<T>&, const T&);
template<typename T> Rational<T> operator-(const T&, const Rational<T>&);
template<typename T> Rational<T> operator*(const Rational<T>&, const Rational<T>&);
template<typename T> Rational<T> operator*(const Rational<T>&, const T&);
template<typename T> Rational<T> operator*(const T&, const Rational<T>&);
template<typename T> Rational<T> operator/(const Rational<T>&, const Rational<T>&);
template<typename T> Rational<T> operator/(const Rational<T>&, const T&);
template<typename T> Rational<T> operator/(const T&, const Rational<T>&);
template<typename T> Rational<T> operator+(const Rational<T>&);
template<typename T> Rational<T> operator-(const Rational<T>&);
template<typename T> bool operator== (const Rational<T>&, const Rational<T>&);
template<typename T> bool operator!= (const Rational<T>&, const Rational<T>&);
template<typename T> bool operator> (const Rational<T>&, const Rational<T>&);
template<typename T> bool operator>= (const Rational<T>&, const Rational<T>&);
template<typename T> bool operator< (const Rational<T>&, const Rational<T>&);
template<typename T> bool operator<= (const Rational<T>&, const Rational<T>&);
template<typename T, class CharT, class Traits>
std::basic_ostream<CharT, Traits>& operator<<
(std::basic_ostream<CharT, Traits>&, const Rational<T>&);
template<typename T> Rational<T> abs (const Rational<T>&);
template<typename T> Rational<T> pow (Rational<T>, int);
} // namespace rational
} // namespace nacre
namespace std {
template<typename T> nacre::rational::Rational<T>
abs (const nacre::rational::Rational<T>&);
template<typename T> nacre::rational::Rational<T>
pow (nacre::rational::Rational<T>, int);
} // namespace std
<nacre/polynomial.hpp>
]namespace nacre {
namespace polynomial {
template<typename T> struct div_t {
div_t();
T quot;
T rem;
};
// P_n = sum_{i=0}^n c_i x^i
template<typename T> class Polynomial {
public:
Polynomial (const T& = T(0));
template<typename T2> Polynomial (const Polynomial<T2>&);
size_t order () const;
void order (size_t);
// remove leading zero coefficients
void normalize ();
// evaluation
T operator() (const T&) const;
// indexation { c_0; ...; c_n } :
T& operator[] (size_t);
const T& operator[] (size_t) const;
// arithmetic
Polynomial& operator= (const T&);
Polynomial& operator+= (const T&);
Polynomial& operator-= (const T&);
Polynomial& operator*= (const T&);
Polynomial& operator/= (const T&);
template<typename T2> Polynomial<T>& operator= (const Polynomial<T2>&);
template<typename T2> Polynomial<T>& operator+= (const Polynomial<T2>&);
template<typename T2> Polynomial<T>& operator-= (const Polynomial<T2>&);
template<typename T2> Polynomial<T>& operator*= (const Polynomial<T2>&);
template<typename T2> div_t<Polynomial<T> > div (const Polynomial<T2>&) const;
template<typename T2> Polynomial<T>& operator/= (const Polynomial<T2>&);
template<typename T2> Polynomial<T>& operator%= (const Polynomial<T2>&);
virtual ~Polynomial () {}
};
template<typename T> Polynomial<T> operator+ (const Polynomial<T>&, const Polynomial<T>&);
template<typename T> Polynomial<T> operator+ (const Polynomial<T>&, const T&);
template<typename T> Polynomial<T> operator+ (const T&, const Polynomial<T>&);
template<typename T> Polynomial<T> operator- (const Polynomial<T>&, const Polynomial<T>&);
template<typename T> Polynomial<T> operator- (const Polynomial<T>&, const T&);
template<typename T> Polynomial<T> operator- (const T&, const Polynomial<T>&);
template<typename T> Polynomial<T> operator* (const Polynomial<T>&, const Polynomial<T>&);
template<typename T> Polynomial<T> operator* (const Polynomial<T>&, const T&);
template<typename T> Polynomial<T> operator* (const T&, const Polynomial<T>&);
template<typename T> Polynomial<T> operator/ (const Polynomial<T>&, const Polynomial<T>&);
template<typename T> Polynomial<T> operator/ (const Polynomial<T>&, const T&);
template<typename T> Polynomial<T> operator/ (const T&, const Polynomial<T>&);
template<typename T> Polynomial<T> operator% (const Polynomial<T>&, const Polynomial<T>&);
template<typename T> Polynomial<T> operator% (const Polynomial<T>&, const T&);
template<typename T> Polynomial<T> operator% (const T&, const Polynomial<T>&);
template<typename T> Polynomial<T> operator+ (const Polynomial<T>& P);
template<typename T> Polynomial<T> operator- (const Polynomial<T>& P);
template<typename T> bool operator== (const Polynomial<T>&, const Polynomial<T>&);
template<typename T> bool operator== (const Polynomial<T>&, const T&);
template<typename T> bool operator== (const T&, const Polynomial<T>&);
template<typename T> bool operator!= (const Polynomial<T>&, const Polynomial<T>&);
template<typename T> bool operator!= (const Polynomial<T>&, const T&);
template<typename T> bool operator!= (const T&, const Polynomial<T>&);
template<typename T> Polynomial<T> pow (Polynomial<T>, size_t);
template<typename T> Polynomial<T> operator^ (Polynomial<T>, size_t);
template<typename T> Polynomial<T> diff (Polynomial<T>);
template<typename T> Polynomial<T> integrate (Polynomial<T>);
template<typename T, typename CharT, class Traits>
std::basic_ostream<CharT, Traits>& operator<<
(std::basic_ostream<CharT, Traits>&, const Polynomial<T>&);
} // namespace polynomial
} // namespace nacre
Chebyshev, Legendre, Laguerre, Hermite polynomials implementation based on recurrence relations.
namespace nacre {
namespace polynomial {
template<typename T> class BuildChebyshevPolynomial {
public:
BuildChebyshevPolynomial();
Polynomial<T> operator() (size_t n, std::vector<Polynomial<T> >& cache);
};
template<typename T> class BuildLegendrePolynomial {
public:
BuildLegendrePolynomial();
Polynomial<T> operator() (size_t n, std::vector<Polynomial<T> >& cache);
};
template<typename T> class BuildLaguerrePolynomial {
public:
BuildLaguerrePolynomial();
Polynomial<T> operator() (size_t n, std::vector<Polynomial<T> >& cache);
};
template<typename T> class BuildHermitePolynomial {
public:
BuildHermitePolynomial();
Polynomial<T> operator() (size_t n, std::vector<Polynomial<T> >& cache);
};
template<typename T, class Builder>
class OrthogonalPolynomial : public Polynomial<T> {
public:
OrthogonalPolynomial (size_t n);
static void clearTable();
static T weightFunction (const T&);
static T orthogonalityIntervalLB ();
static T orthogonalityIntervalUB ();
virtual ~OrthogonalPolynomial();
};
template<typename T> class ChebyshevPolynomial
: public OrthogonalPolynomial<T, BuildChebyshevPolynomial<T> > {
public:
ChebyshevPolynomial (size_t n);
static T weightFunction (const T&);
static T orthogonalityIntervalLB ();
static T orthogonalityIntervalUB ();
};
template<typename T> class LegendrePolynomial
: public OrthogonalPolynomial<T, BuildLegendrePolynomial<T> > {
public:
LegendrePolynomial (size_t n);
static T weightFunction (const T&);
static T orthogonalityIntervalLB ();
static T orthogonalityIntervalUB ();
};
template<typename T> class LaguerrePolynomial
: public OrthogonalPolynomial<T, BuildLaguerrePolynomial<T> > {
public:
LaguerrePolynomial (size_t n);
static T weightFunction (const T&);
static T orthogonalityIntervalLB ();
static T orthogonalityIntervalUB ();
};
template<typename T> class HermitePolynomial
: public OrthogonalPolynomial<T, BuildHermitePolynomial<T> > {
public:
HermitePolynomial (size_t n);
static T weightFunction (const T&);
static T orthogonalityIntervalLB ();
static T orthogonalityIntervalUB ();
};
} // namespace polynomial
} // namespace nacre
Current code uses Muller method.
namespace nacre {
namespace polynomial {
class TooManyIterations : public std::exception {
public:
const char* what () const throw();
};
template<class F, typename T, typename Cplx> Cplx
MullerRoot (const F& f,
Cplx x0, Cplx x1, Cplx x2,
const T& eps, size_t maxIter);
template<typename T, typename Cplx>
std::vector<Cplx> PolynomialRoots (const nacre::polynomial::Polynomial<Cplx>&,
const T& eps, size_t maxIter);
} // namespace polynomial
} // namespace nacre
<nacre/complex.hpp>
]namespace nacre {
namespace complex {
template<typename T> class Complex {
public:
Complex (const T& = T(), const T& = T());
template<typename T2> Complex(const Complex<T2>&);
T real() const;
T imag() const;
Complex& operator= (const T&);
Complex& operator+= (const T&);
Complex& operator-= (const T&);
Complex& operator*= (const T&);
Complex& operator/= (const T&);
template<typename T2> Complex<T>& operator= (const Complex<T2>&);
template<typename T2> Complex<T>& operator+= (const Complex<T2>&);
template<typename T2> Complex<T>& operator-= (const Complex<T2>&);
template<typename T2> Complex<T>& operator*= (const Complex<T2>&);
template<typename T2> Complex<T>& operator/= (const Complex<T2>&);
};
template<typename T> Complex<T> operator+ (const Complex<T>&, const Complex<T>&);
template<typename T> Complex<T> operator+ (const Complex<T>&, const T&);
template<typename T> Complex<T> operator+ (const T&, const Complex<T>&);
template<typename T> Complex<T> operator- (const Complex<T>&, const Complex<T>&);
template<typename T> Complex<T> operator- (const Complex<T>&, const T&);
template<typename T> Complex<T> operator- (const T&, const Complex<T>&);
template<typename T> Complex<T> operator* (const Complex<T>&, const Complex<T>&);
template<typename T> Complex<T> operator* (const Complex<T>&, const T&);
template<typename T> Complex<T> operator* (const T&, const Complex<T>&);
template<typename T> Complex<T> operator/ (const Complex<T>&, const Complex<T>&);
template<typename T> Complex<T> operator/ (const Complex<T>&, const T&);
template<typename T> Complex<T> operator/ (const T&, const Complex<T>&);
template<typename T> Complex<T> operator+ (const Complex<T>&);
template<typename T> Complex<T> operator- (const Complex<T>&);
template<typename T> bool operator== (const Complex<T>&, const Complex<T>&);
template<typename T> bool operator== (const Complex<T>&, const T&);
template<typename T> bool operator== (const T&, const Complex<T>&);
template<typename T> bool operator!= (const Complex<T>&, const Complex<T>&);
template<typename T> bool operator!= (const Complex<T>&, const T&);
template<typename T> bool operator!= (const T&, const Complex<T>&);
template<typename T, typename CharT, class Traits>
std::basic_istream<CharT, Traits>&
operator>>(std::basic_istream<CharT, Traits>&, Complex<T>&);
template<typename T, typename CharT, class Traits>
std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>&, const Complex<T>&);
template<typename T> T real (const Complex<T>&);
template<typename T> T imag (const Complex<T>&);
} // namespace complex
} // namespace nacre
namespace nacre {
namespace complex {
template<typename T> T abs (const Complex<T>&);
template<typename T> T arg (const Complex<T>&);
template<typename T> T norm (const Complex<T>&);
template<typename T> Complex<T> polar (const T& rho, const T& theta);
template<typename T> Complex<T> conj (const Complex<T>&);
template<typename T> Complex<T> cos (const Complex<T>&);
template<typename T> Complex<T> cosh (const Complex<T>&);
template<typename T> Complex<T> exp (const Complex<T>&);
template<typename T> Complex<T> log (const Complex<T>&);
template<typename T> Complex<T> log10 (const Complex<T>&);
template<typename T> Complex<T> sin (const Complex<T>&);
template<typename T> Complex<T> sinh (const Complex<T>&);
template<typename T> Complex<T> sqrt (const Complex<T>&);
template<typename T> Complex<T> tan (const Complex<T>&);
template<typename T> Complex<T> tanh (const Complex<T>&);
template<typename T> Complex<T> pow (Complex<T>, int);
template<typename T> Complex<T> pow (const Complex<T>&, const T&);
template<typename T> Complex<T> pow (const Complex<T>&, const Complex<T>&);
template<typename T> Complex<T> pow (const T&, const Complex<T>&);
} // namespace complex
} // namespace nacre
namespace std {
template<typename T> T abs (const nacre::complex::Complex<T>&);
template<typename T> T arg (const nacre::complex::Complex<T>&);
template<typename T> T norm (const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> conj (const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> cos (const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> cosh (const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> exp (const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> log (const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> log10 (const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> sin (const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> sinh (const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> sqrt (const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> tan (const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> tanh (const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> pow (nacre::complex::Complex<T>, int);
template<typename T> nacre::complex::Complex<T> pow (const nacre::complex::Complex<T>&, const T&);
template<typename T> nacre::complex::Complex<T> pow (const nacre::complex::Complex<T>&,
const nacre::complex::Complex<T>&);
template<typename T> nacre::complex::Complex<T> pow (const T&, const nacre::complex::Complex<T>&);
} // namespace std
namespace nacre {
namespace complex {
template<typename T> Complex<T> acos (const Complex<T>&);
template<typename T> Complex<T> acosh (const Complex<T>&);
template<typename T> Complex<T> acot (const Complex<T>&);
template<typename T> Complex<T> acoth (const Complex<T>&);
template<typename T> Complex<T> asin (const Complex<T>&);
template<typename T> Complex<T> asinh (const Complex<T>&);
template<typename T> Complex<T> atan (const Complex<T>&);
template<typename T> Complex<T> atanh (const Complex<T>&);
template<typename T> Complex<T> cot (const Complex<T>&);
template<typename T> Complex<T> coth (const Complex<T>&);
} // namespace complex
} // namespace nacre