FLieGenerator.h

Go to the documentation of this file.

#ifndef CLASSIC_FLieGenerator_HH
#define CLASSIC_FLieGenerator_HH
 
// ------------------------------------------------------------------------
// $RCSfile: FLieGenerator.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.3.2.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template class: FLieGenerator<T,N>
//
// ------------------------------------------------------------------------
// Class category: FixedAlgebra
// ------------------------------------------------------------------------
//
// $Date: 2002/03/25 20:44:16 $
// $Author: dbruhwil $
//
// ------------------------------------------------------------------------
 
#include "Algebra/Array1D.h"
#include <complex>
 
// template <class T> class complex;
template <class T, int N> class FArray1D;
template <class T, int N, int M> class FMatrix;
template <class T, int N> class FTps;
 
 
// Template class FLieGenerator<T,N>.
// ------------------------------------------------------------------------
//  The number of variables must be even, it is equal to 2*N, where N is
//  a template parameter.  The indices have the same range as the
//  coefficients of the same order in an FTps<double,2*N> object.
 
template <class T, int N>
class FLieGenerator {
 
public:
 
    explicit FLieGenerator(int);
 
    //  from an FTps<T,2*N> object.
    FLieGenerator(const FTps<T, 2 * N> &, int);
 
    FLieGenerator();
    FLieGenerator(const FLieGenerator &);
    ~FLieGenerator();
    const FLieGenerator &operator=(const FLieGenerator &);
    bool operator==(const FLieGenerator &) const;
 
 
    //  Version for non-constant generator.
    inline T *begin();
 
    //  Version for non-constant generator.
    inline T *end();
 
    //  Version for constant generator.
    inline const T *begin() const;
 
    //  Version for constant generator.
    inline const T *end() const;
 
    //  Return a reference to element [b]n[/b].
    //  Result is undefined, if [b]n[/b] is out of range.
    T &operator[](int n);
 
    //  Return a reference to element [b]n[/b].
    //  Result is undefined, if [b]n[/b] is out of range.
    const T &operator[](int n) const;
 
 
    FLieGenerator operator-() const;
 
    FLieGenerator &operator*=(const T &);
 
    FLieGenerator &operator/=(const T &);
 
    FLieGenerator &operator+=(const FLieGenerator &);
 
    FLieGenerator &operator-=(const FLieGenerator &);
 
 
    void clear();
 
    //  Return partial derivative with respect to variable [b]var[/b].
    FLieGenerator derivative(int var) const;
 
    bool isZero() const;
 
    FLieGenerator scale(const FLieGenerator &) const;
 
    //  The coefficients of the source generator have type T, the
    //  elements of the matrix have type U, and the result of multiplying
    //  a T by a U must return a U.
    template <class U>
    FLieGenerator<U, N> transform(const FMatrix<U, 2 * N, 2 * N> &) const;
 
 
    inline int getOrder() const;
 
    inline int getBottomIndex() const;
 
    inline int getTopIndex() const;
 
private:
 
    // Return size of the generator.
    static inline int getSize(int order);
 
    // Return bottom index for given order.
    static inline int getBottomIndex(int order);
 
    // Return top index for given order.
    static inline int getTopIndex(int order);
 
    // The order of the generator, defines its size.
    int itsOrder;
 
    // The bottom Index.
    int bottomIndex;
 
    // The top index.
    int topIndex;
 
    // The representation of the coefficients.
    Array1D<T> itsCoeffs;
};
 
 
// Global functions.
// ------------------------------------------------------------------------
 
template <class T, int N>
FLieGenerator<T, N>
operator+(const FLieGenerator<T, N> &, const FLieGenerator<T, N> &);
 
template <class T, int N>
FLieGenerator<T, N>
operator-(const FLieGenerator<T, N> &, const FLieGenerator<T, N> &);
 
template <class T, int N>
FLieGenerator<T, N>
operator*(const FLieGenerator<T, N> &, const T &);
 
template <class T, int N>
FLieGenerator<T, N>
operator*(const T &, const FLieGenerator<T, N> &);
 
template <class T, int N>
FLieGenerator<T, N>
operator*(const FLieGenerator<T, N> &, const FLieGenerator<T, N> &);
 
template <class T, int N>
FLieGenerator<T, N>
operator/(const FLieGenerator<T, N> &, const T &);
 
template <class T, int N>
FLieGenerator<T, N>
real(const FLieGenerator<std::complex<T>, N> &);
 
template <class T, int N>
FLieGenerator<T, N>
imag(const FLieGenerator<std::complex<T>, N> &);
 
template <class T, int N>
FLieGenerator<std::complex<T>, N>
toComplex(const FLieGenerator<T, N> &);
 
template <class T, int N> FLieGenerator<T, N>
PoissonBracket(const FLieGenerator<T, N> &, const FLieGenerator<T, N> &);
 
template <class T, int N>
std::ostream &operator<<(std::ostream &, const FLieGenerator<T, N> &);
 
#include "FixedAlgebra/FLieGenerator.hpp"
 
#endif // CLASSIC_FLieGenerator_HH