Taylor.h

Go to the documentation of this file.

#ifndef CLASSIC_Taylor_HH
#define CLASSIC_Taylor_HH

// ------------------------------------------------------------------------
// $RCSfile: Taylor.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.2 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template class: Taylor<T>
//
// ------------------------------------------------------------------------
// Class category: FixedAlgebra
// ------------------------------------------------------------------------
//
// $Date: 2001/11/15 08:52:26 $
// $Author: jsberg $
//
// ------------------------------------------------------------------------

#include "Algebra/Array1D.h"


// Template class Taylor<T>.
// ------------------------------------------------------------------------
//  whose coefficients are of type T.  For some operations this class
//  assumes that the type T has particular operations, like PoissonBracket.
//  The class Taylor<T> is mainly meant for implementing a Lie generator
//  with one parameter as a Taylor series in this parameter.  This permits
//  easy integration with respect to the parameter.

template <class T>
class Taylor {

public:

    explicit Taylor(int);

    Taylor();
    Taylor(const Taylor &);
    ~Taylor();
    const Taylor &operator=(const Taylor &);


    //  Version for non-constant series.
    inline T *begin();

    //  Version for constant series.
    inline const T *begin() const;

    //  Version for non-constant series.
    inline T *end();

    //  Version for constant series.
    inline const T *end() const;

    //  Return a reference to coefficient of order [b]n[/b].
    //  Result is undefined, if [b]n[/b] is out of range.
    T &operator[](int n);

    //  Return a reference to constant coefficient of order [b]n[/b].
    //  Result is undefined, if [b]n[/b] is out of range.
    const T &operator[](int n) const;


    Taylor operator-() const;

    Taylor &operator*=(const T &);

    Taylor &operator/=(const T &);

    Taylor &operator+=(const Taylor &);

    Taylor &operator-=(const Taylor &);


    void clear();

    Taylor integrate() const;

    T sum() const;


    inline int getOrder() const;

private:

    // The representation of the coefficients.
    Array1D<T> itsCoeffs;
};


// Global functions.
// ------------------------------------------------------------------------

template <class T>
Taylor<T>
operator+(const Taylor<T> &, const Taylor<T> &);

template <class T>
Taylor<T>
operator-(const Taylor<T> &, const Taylor<T> &);

template <class T>
Taylor<T>
operator*(const Taylor<T> &, double);

template <class T>
Taylor<T>
operator*(double, const Taylor<T> &);

template <class T>
Taylor<T>
operator/(const Taylor<T> &, double);

//  For this function the coefficients must have a Poisson bracket operation.
template <class T>
Taylor<T>
PoissonBracket(const Taylor<T> &, const Taylor<T> &);

template <class T>
std::ostream &operator<<(std::ostream &, const Taylor<T> &);

#include "FixedAlgebra/Taylor.hpp"

#endif // CLASSIC_Taylor_HH