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