Numeric Analysis / Computer Research C++ Classes (MPFRCPP)

Contents


1. FP-comparator [<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

2. Rational Numbers [<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

3. Polynomials [<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

3.1. Orthogonal Polynomials

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

3.2. Polynomial Roots

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

4. Complex Numbers [<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

4.1. Basic Functions (ISO/IEC 14882)

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

4.2. Additional Functions

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