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