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