Vps.h

Go to the documentation of this file.

#ifndef CLASSIC_Vps_HH
#define CLASSIC_Vps_HH
 
// ------------------------------------------------------------------------
// $RCSfile: Vps.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: Vps
//
// ------------------------------------------------------------------------
// Class category: Algebra
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:32 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
template <class T> class Matrix;
template <class T> class Vps;
 
#include "Algebra/Tps.h"
#include "Algebra/Vector.h"
#include <iosfwd>
 
 
// Template class Vps<T>
// ------------------------------------------------------------------------
//  A vector of truncated power series with coefficients of type [b]T[/b]
//  in [b]n[/b] variables. This class serves as the base class for maps.
 
template <class T>
class Vps {
 
public:
 
    //  Construct [b]nDim[/b] series in [b]nVar[/b] variables each.
    Vps(int nDim, int nVar = 0);
 
    //  The constant part is zero.
    //  The linear part is set to the contents of [b]M[/b].
    Vps(const Matrix<T> &M);
 
    //  The constant part is set to the contents of [b]V[/b].
    //  The linear part is zero.
    Vps(const Vector<T> &V);
 
    Vps();
    Vps(const Vps<T> &rhs);
    ~Vps();
    Vps<T> &operator=(const Vps<T> &);
 
    //  Return the component [b]index[/b].
    //  Throw RangeError, if [b]index[/b] is out of range.
    const Tps<T> &getComponent(int index) const;
 
    //  Set the component [b]index[/b].
    //  Throw RangeError, if [b]index[/b] is out of range.
    void setComponent(int index, const Tps<T> &value);
 
    //  Return the component [b]index[/b].
    //  Result is undefined, if [b]index[/b] is out of range.
    Tps<T> &operator[](int index);
 
    //  Set the component [b]index[/b].
    //  Result is undefined, if [b]index[/b] is out of range.
    const Tps<T> &operator[](int index) const;
 
    void check() const;
 
    Vps<T> operator+() const;
 
    Vps<T> operator-() const;
 
    Vps<T> &operator*=(const Tps<T> &y);
 
    // Throw DivideError if constant part of [b]y[/b] is zero.
    Vps<T> &operator/=(const Tps<T> &y);
 
    Vps<T> &operator*=(const T &y);
 
    //  Throw DivideError if [b]y[/b] is zero.
    Vps<T> &operator/=(const T &y);
 
    Vps<T> &operator+=(const Vps<T> &y);
 
    Vps<T> &operator-=(const Vps<T> &y);
 
    Vps<T> &operator+=(const Vector<T> &y);
 
    Vps<T> &operator-=(const Vector<T> &y);
 
    std::istream &get(std::istream &is);
 
    std::ostream &put(std::ostream &os) const;
 
    int getDimension() const;
 
    int getTopOrder() const;
 
    int getTruncOrder() const;
 
    int getVariables() const;
 
    Vps<T> filter(int lowOrder, int highOrder) const;
 
    Vps<T> truncate(int trunc);
 
protected:
 
    // Representation of the Vps<T>.
    Array1D< Tps<T> > data;
 
    // The number of variables.
    mutable int variables;
};
 
 
// Unchecked inline access to components.
// ------------------------------------------------------------------------
 
template <class T> inline
Tps<T> &Vps<T>::operator[](int index)
{ return data[index]; }
 
template <class T> inline
const Tps<T> &Vps<T>::operator[](int index) const
{ return data[index]; }
 
 
// Global Operators on Vps<T>
// ------------------------------------------------------------------------
 
template <class T> Vps<T> operator*(const Vps<T> &x, const Tps<T> &y);
 
template <class T> Vps<T> operator*(const Tps<T> &x, const Vps<T> &y);
 
template <class T> Vps<T> operator*(const Vps<T> &x, const T &y);
 
template <class T> Vps<T> operator*(const T &x, const Vps<T> &y);
 
//  Throw DivideError, if constant part of [b]y[/b] is zero.
template <class T> Vps<T> operator/(const Vps<T> &x, const Tps<T> &y);
 
//  Throw DivideError, if [b]y[/b] is zero.
template <class T> Vps<T> operator/(const Vps<T> &x, const T &y);
 
template <class T> Vps<T> operator+(const Vps<T> &x, const Vps<T> &y);
 
template <class T> Vps<T> operator-(const Vps<T> &x, const Vps<T> &y);
 
template <class T> Vps<T> operator+(const Vps<T> &x, const Vector<T> &y);
 
template <class T> Vps<T> operator-(const Vps<T> &x, const Vector<T> &y);
 
template <class T> Vps<T> operator+(const Vector<T> &x, const Vps<T> &y);
 
template <class T> Vps<T> operator-(const Vector<T> &x, const Vps<T> &y);
 
template <class T> std::istream &operator>>(std::istream &, Vps<T> &x);
 
template <class T> std::ostream &operator<<(std::ostream &, const Vps<T> &x);
 
 
// Implementation of global functions for class Vps<T>.
// ------------------------------------------------------------------------
 
template <class T> inline
Vps<T> operator*(const Vps<T> &x, const Tps<T> &y)
{ Vps<T> z(x); return z *= y; }
 
template <class T> inline
Vps<T> operator*(const Tps<T> &x, const Vps<T> &y)
{ Vps<T> z(x); return z *= y; }
 
template <class T> inline
Vps<T> operator*(const Vps<T> &x, const T &y)
{ Vps<T> z(x); return z *= y; }
 
template <class T> inline
Vps<T> operator*(const T &x, const Vps<T> &y)
{ Vps<T> z(x); return z *= y; }
 
template <class T> inline
Vps<T> operator/(const Vps<T> &x, const Tps<T> &y)
{ Vps<T> z(x); return z /= y; }
 
template <class T> inline
Vps<T> operator/(const Vps<T> &x, const T &y)
{ Vps<T> z(x); return z /= y; }
 
 
template <class T> inline
Vps<T> operator+(const Vps<T> &x, const Vps<T> &y)
{ Vps<T> z(x); return z += y; }
 
template <class T> inline
Vps<T> operator-(const Vps<T> &x, const Vps<T> &y)
{ Vps<T> z(x); return z -= y; }
 
template <class T> inline
Vps<T> operator+(const Vps<T> &x, const Vector<T> &y)
{ Vps<T> z(x); return z += y; }
 
template <class T> inline
Vps<T> operator-(const Vps<T> &x, const Vector<T> &y)
{ Vps<T> z(x); return z -= y; }
 
template <class T> inline
Vps<T> operator+(const Vector<T> &x, const Vps<T> &y)
{ Vps<T> z(y); return z += x; }
 
template <class T> inline
Vps<T> operator-(const Vector<T> &x, const Vps<T> &y)
{ Vps<T> z(- y); return z += x; }
 
template <class T> inline
std::istream &operator>>(std::istream &is, Vps<T> &x)
{ return x.get(is); }
 
template <class T> inline
std::ostream &operator<<(std::ostream &os, const Vps<T> &x)
{ return x.put(os); }
 
#endif // CLASSIC_Vps_HH