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