FVps.h

Go to the documentation of this file.

#ifndef CLASSIC_FVps_HH
#define CLASSIC_FVps_HH

// ------------------------------------------------------------------------
// $RCSfile: FVps.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1.2.6 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template Class: FVps<T,N>
//
// ------------------------------------------------------------------------
// Class category: FixedAlgebra
// ------------------------------------------------------------------------
//
// $Date: 2003/11/07 18:06:20 $
// $Author: dbruhwil $
//
// ------------------------------------------------------------------------

#include <algorithm>
#include <iosfwd>

template <class T> class Array1D;
template <class T, int M, int N> class FMatrix;
template <class T, int N> class FTps;
template <class T, int N> class FVector;
template <class T, int N> class LinearMap;
template <class T, int N> class TransportMap;
template <class T, int N> class FArray1D;

// Template class FVps<T,N>
// ------------------------------------------------------------------------

template <class T, int N>
class FVps {

public:

    //  Construct zero map with given order [b]order[/b]
    //  and truncation [b]trunc[/b].
    explicit FVps(int minOrder, int maxOrder, int trcOrder);

    //  The constant part is set to zero.
    //  The linear part is filled from [b]M[/b].
    explicit FVps(const FMatrix<T, N, N> &M);

    //  The constant part is filled from [b]V[/b].
    explicit FVps(const FVector<T, N> &V);

    explicit FVps(const LinearMap<T, N> &rhs);

    explicit FVps(const TransportMap<T, N> &rhs);

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

    void identity();

    void zero();

    //  Return value of component [b]n[/b].
    //  Throw RangeError, if [b]n[/b] is out of range.
    const FTps<T, N> &getComponent(int n) const;

    //  Assign value of component [b]n[/b].
    //  Throw RangeError, if [b]n[/b] is out of range.
    void setComponent(int, const FTps<T, N> &);

    //  Return constant reference to component [b]n[/b].
    //  Result undefined for index out of range.
    inline const FTps<T, N> &operator[](int) const;

    //  Return reference to component [b]n[/b].
    //  Result undefined for index out of range.
    inline FTps<T, N> &operator[](int);

    //  Return the number of components.
    inline int getDimension() const;

    //  This is the same in all components.
    inline int getVariables() const;

    int getMinOrder() const;

    //  If necessary, this function will insert zeroes or modify the
    //  maximum order.  It will not modify the truncation order.
    void setMinOrder(int order);

    int getMaxOrder() const;

    //  If necessary, this function will insert zeroes or modify the minimum
    //  or maximum orders.  It will not modify the truncation order.
    void setMaxOrder(int order);

    int getTopOrder() const;

    int getTruncOrder() const;

    void setTruncOrder(int order);

    FVps filter(int minOrder, int maxOrder, int trcOrder = (FTps<T, N>::EXACT)) const;

    //  Limit truncation order to [b]trunc[/b].
    FVps truncate(int trunc);

    FVps operator+() const;

    FVps operator-() const;

    FVps &operator+=(const FVps &rhs);

    FVps &operator-=(const FVps &rhs);

    FVps &operator+=(const FVector<T, N> &);

    FVps &operator-=(const FVector<T, N> &);

    FVps &operator*=(const FTps<T, N> &rhs);
    
    FVps operator*(const FVps<T, N>& rhs) const;

    //  Throw DivideError if constant part of [b]rhs[/b] is zero.
    FVps &operator/=(const FTps<T, N> &rhs);

    FVps &operator*=(const T &rhs);

    //  Throw DivideError if [b]rhs[/b] is zero.
    FVps &operator/=(const T &rhs);

    //  Invert a map.
    FVps inverse(int trunc = (FTps<T, N>::EXACT)) const;

    //  Invert a map.
    FVps myInverse(int trunc = (FTps<T, N>::EXACT)) const;

    //  Return partial derivative with respect to variable [b]var[/b].
    FVps derivative(int var) const;

    //  Return partial integral with respect to variable [b]var[/b].
    //  Throw LogicalError for a constant.
    FVps integral(int var) const;

    //  This is equivalent to evaluating the map at the origin.
    FVector<T, N> constantTerm() const;

    //  This is equivalent to evaluating the map at point [b]P[/b].
    FVector<T, N> constantTerm(const FVector<T, N> &P) const;

    FMatrix<T, N, N> linearTerms() const;

    //  This is equivalent to the Jacobian matrix at point [b]P[/b].
    FMatrix<T, N, N> linearTerms(const FVector<T, N> &P) const;

    // NB: This routine is NOT guaranteed to return min <= max <= trc.
    // If min exceeds max, then f(rhs(z)) = 0 + O(z^{trc+1}).
    // This possibility must be checked for.
    Array1D<int> getSubstOrders(const FVps<T, N> &rhs, int trunc = (FTps<T, N>::EXACT)) const;

    //  Use the linear map with matrix representation [b]M[/b] to transform the
    //  order n part of an FVps; leave remaining parts unchanged.  Return a new FVps.
    // NB: This method uses static local memory.
    FVps substitute(const FMatrix<T, N, N> &M, int n) const;

    //  Use the linear map with matrix representation [b]M[/b] to transform the
    //  order nl through nh parts of an FVps; leave remaining parts unchanged.
    //  Return a new FVps.
    // NB: This method uses static local memory.
    FVps substitute(const FMatrix<T, N, N> &M, int nl, int nh) const;

    //  Use the linear map with matrix representation [b]M[/b]
    //  to transform an FVps.  Return a new FVps.
    // NB: This method (indirectly) uses static local memory.
    FVps substitute(const FMatrix<T, N, N> &M) const;

    //  Use the (nonlinear) map [b]m[/b] to transform an FVps.  Return a new FVps.
    // NB: This method uses static local memory.
    FVps substitute(const FVps<T, N> &m, int trunc = (FTps<T, N>::EXACT)) const;

    FVps substituteInto(const FMatrix<T, N, N> &lhs) const;
    
    // Computes a FTps by multiplying the FTps of FVps using the powers specified by [b]power[/b].
    FTps<T, N> getFTps(const FArray1D<int, N>& power) const;
    
    std::istream &get(std::istream &is);

    std::ostream &put(std::ostream &os) const;

protected:

    // Representation of the FVps.
    FTps<T, N> data[N];

};


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

template <class T, int N>
FVps<T, N> operator+(const FVps<T, N> &lhs, const FVps<T, N> &rhs);

template <class T, int N>
FVps<T, N> operator-(const FVps<T, N> &lhs, const FVps<T, N> &rhs);

template <class T, int N>
FVps<T, N> operator+(const FVps<T, N> &lhs, const FVector<T, N> &rhs);

template <class T, int N>
FVps<T, N> operator-(const FVps<T, N> &lhs, const FVector<T, N> &rhs);

template <class T, int N>
FVps<T, N> operator+(const FVector<T, N> &lhs, const FVps<T, N> &rhs);

template <class T, int N>
FVps<T, N> operator-(const FVector<T, N> &lhs, const FVps<T, N> &rhs);

template <class T, int N>
FVector<T, N> operator*(const FVps<T, N> &lhs, const FVector<T, N>& rhs);

template <class T, int N>
FVps<T, N> operator*(const FVps<T, N> &lhs, const FTps<T, N> &rhs);

template <class T, int N>
FVps<T, N> operator*(const FTps<T, N> &lhs, const FVps<T, N> &rhs);

template <class T, int N>
FVps<T, N> operator*(const FVps<T, N> &lhs, const T &rhs);

template <class T, int N>
FVps<T, N> operator*(const T &lhs, const FVps<T, N> &rhs);

template <class T, int N>
FVps<T, N> operator*(const FMatrix<T, N, N> &lhs, const FVps<T, N> &rhs);

//  Throw DivideError, if constant part of [b]rhs[/b] is zero.
template <class T, int N>
FVps<T, N> operator/(const FVps<T, N> &lhs, const FTps<T, N> &rhs);

//  Throw DivideError, if [b]rhs[/b] is zero.
template <class T, int N>
FVps<T, N> operator/(const FVps<T, N> &lhs, const T &rhs);

//  Return the series exp(:H:) M,
//  the Lie transform exp(:H:) acting on the map [b]M[/b].
template <class T, int N> FVps<T, N>
ExpMap(const FTps<T, N> &H, const FVps<T, N> &M, int trunc = (FTps<T, N>::EXACT));

template <class T, int N> FVps<T, N>
PoissonBracket(const FTps<T, N> &x, const FVps<T, N> &y, int trunc = (FTps<T, N>::EXACT));

template <class T, int N>
std::istream &operator>>(std::istream &is, FVps<T, N> &);

template <class T, int N>
std::ostream &operator<<(std::ostream &os, const FVps<T, N> &vps);


// Implementation.
#include "FixedAlgebra/FVps.hpp"

#endif // CLASSIC_FVps_HH