TransportMap.h

Go to the documentation of this file.

#ifndef CLASSIC_TransportMap_HH
#define CLASSIC_TransportMap_HH
 
// ------------------------------------------------------------------------
// $RCSfile: TransportMap.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template Class: TransportMap<T,N>
//
// ------------------------------------------------------------------------
// Class category: FixedAlgebra
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:37 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include <iosfwd>
 
template <class T, int M, int N> class FMatrix;
template <class T, int N> class FVector;
template <class T, int N> class FVps;
template <class T, int N> class TransportFun;
 
 
// Template class TransportMap<T,N>
// ------------------------------------------------------------------------
//  The copy constructor, destructor, and assignment operator generated
//  by the compiler perform the correct operation.  For speed reasons
//  they are not implemented.
 
template <class T, int N>
class TransportMap {
 
public:
 
    //  Construct identity map.
    TransportMap();
 
    explicit TransportMap(const FVps<T, N> &rhs);
 
    //  The constant part is set to zero.
    //  The Transport part is filled from [b]M[/b].
    explicit TransportMap(const FMatrix<T, N, N> &M);
 
    //  The constant part is filled from [b]V[/b].
    //  The Transport part is set to the identity.
    explicit TransportMap(const FVector<T, N> &V);
 
    //  Return value of component [b]n[/b].
    //  Throw RangeError, if [b]n[/b] is out of range.
    const TransportFun<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 TransportFun<T, N> &);
 
    //  Return reference to component [b]n[/b].
    //  Result is undefined, if index is out of range.
    TransportFun<T, N> &operator[](int);
 
    //  Return constant reference to component [b]n[/b].
    //  Result is undefined, if index is out of range.
    const TransportFun<T, N> &operator[](int) const;
 
    TransportMap operator+() const;
 
    TransportMap operator-() const;
 
    TransportMap &operator*=(const TransportFun<T, N> &rhs);
 
    //  Throw DivideError if constant part of [b]rhs[/b] is zero.
    TransportMap &operator/=(const TransportFun<T, N> &rhs);
 
    TransportMap &operator*=(const T &rhs);
 
    //  Throw DivideError if [b]rhs[/b] is zero.
    TransportMap &operator/=(const T &rhs);
 
    TransportMap &operator+=(const TransportMap &rhs);
 
    TransportMap &operator-=(const TransportMap &rhs);
 
    TransportMap &operator+=(const FVector<T, N> &);
 
    TransportMap &operator-=(const FVector<T, N> &);
 
    TransportMap inverse() const;
 
    void identity();
 
    FVector<T, N> constantTerm(const FVector<T, N> &P) const;
 
    FVector<T, N> constantTerm() const;
 
    //  This is equivalent to extracting Transport part.
    FMatrix<T, N, N> linearTerms() const;
 
    TransportMap substitute(const FMatrix<T, N, N> &rhs) const;
 
    TransportMap substitute(const TransportMap &rhs) const;
 
    TransportMap substituteInto(const FMatrix<T, N, N> &lhs) const;
 
protected:
 
    static const int SIZE = (N + 1) *(N + 2) / 2;
 
    // Representation of the TransportMap.
    TransportFun<T, N> data[N];
};
 
 
// Global functions.
// ------------------------------------------------------------------------
 
template <class T, int N>
TransportMap<T, N>
operator*(const TransportMap<T, N> &lhs, const TransportFun<T, N> &rhs);
 
template <class T, int N>
TransportMap<T, N>
operator*(const TransportFun<T, N> &lhs, const TransportMap<T, N> &rhs);
 
template <class T, int N>
TransportMap<T, N>
operator*(const TransportMap<T, N> &lhs, const T &rhs);
 
template <class T, int N>
TransportMap<T, N>
operator*(const T &lhs, const TransportMap<T, N> &rhs);
 
template <class T, int N>
TransportMap<T, N>
operator*(const FMatrix<T, N, N> &lhs, const TransportMap<T, N> &rhs);
 
//  Throw DivideError, if constant part of [b]rhs[/b] is zero.
template <class T, int N>
TransportMap<T, N>
operator/(const TransportMap<T, N> &lhs, const TransportFun<T, N> &rhs);
 
//  Throw DivideError, if [b]rhs[/b] is zero.
template <class T, int N>
TransportMap<T, N>
operator/(const TransportMap<T, N> &lhs, const T &rhs);
 
template <class T, int N>
TransportMap<T, N>
operator+(const TransportMap<T, N> &lhs, const TransportMap<T, N> &rhs);
 
template <class T, int N>
TransportMap<T, N>
operator-(const TransportMap<T, N> &lhs, const TransportMap<T, N> &rhs);
 
template <class T, int N>
TransportMap<T, N>
operator+(const TransportMap<T, N> &lhs, const FVector<T, N> &rhs);
 
template <class T, int N>
TransportMap<T, N>
operator-(const TransportMap<T, N> &lhs, const FVector<T, N> &rhs);
 
template <class T, int N>
TransportMap<T, N>
operator+(const FVector<T, N> &lhs, const TransportMap<T, N> &rhs);
 
template <class T, int N>
TransportMap<T, N>
operator-(const FVector<T, N> &lhs, const TransportMap<T, N> &rhs);
 
 
// Implementation.
#include "FixedAlgebra/TransportMap.hpp"
 
#endif // CLASSIC_TransportMap_HH