LinearMap.h

Go to the documentation of this file.

#ifndef CLASSIC_LinearMap_HH
#define CLASSIC_LinearMap_HH

// ------------------------------------------------------------------------
// $RCSfile: LinearMap.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template Class: LinearMap<T,N>
//
// ------------------------------------------------------------------------
// Class category: FixedAlgebra
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:36 $
// $Author: fci $
//
// ------------------------------------------------------------------------

#include <iosfwd>

template <class T, int M, int N> class FMatrix;
template <class T, int N> class LinearFun;
template <class T, int N> class FVector;
template <class T, int N> class FVps;


// Template class LinearMap<T,N>
// ------------------------------------------------------------------------
//  The copy constructor, destructor, and assignment operator generated
//  by the compiler do the correct thing, and are not defined for speed.

template <class T, int N>
class LinearMap {

public:

    //  Construct identity map.
    LinearMap();

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

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

    //  The constant part is filled from [b]V[/b].
    //  The linear part is set to the identity.
    explicit LinearMap(const FVector<T, N> &V);

    //  Return value of component [b]n[/b].
    //  Throw RangeError, if [b]n[/b] is out of range.
    const LinearFun<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 LinearFun<T, N> &);

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

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

    LinearMap operator+() const;

    LinearMap operator-() const;

    LinearMap &operator*=(const LinearFun<T, N> &rhs);

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

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

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

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

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

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

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

    std::istream &get(std::istream &is);

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

    LinearMap inverse() const;

    void identity();

    FVector<T, N> constantTerm(const FVector<T, N> &P) const;

    FVector<T, N> constantTerm() const;

    //  This is equivalent to extracting linear part.
    FMatrix<T, N, N> linearTerms() const;

    LinearMap substitute(const FMatrix<T, N, N> &rhs) const;

    LinearMap substitute(const LinearMap &rhs) const;

    LinearMap substituteInto(const FMatrix<T, N, N> &lhs) const;

protected:

    // Representation of the LinearMap.
    LinearFun<T, N> data[N];
};


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

#endif // CLASSIC_LinearMap_HH