TransportFun.h

Go to the documentation of this file.

#ifndef CLASSIC_TransportFun_HH
#define CLASSIC_TransportFun_HH
 
// ------------------------------------------------------------------------
// $RCSfile: TransportFun.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template class: TransportFun<T,N>
//
// ------------------------------------------------------------------------
// Class category: FixedAlgebra
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:36 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include <iosfwd>
 
template <class T, int N> class FVector;
template <class T, int N> class TransportMap;
template <class T, int M, int N> class FMatrix;
 
 
// Template class TransportFun<T,N>.
// ------------------------------------------------------------------------
//  All divide operations throw DivideError,
//  if the constant part of the divisor is zero.
//  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 TransportFun {
 
public:
 
    //  Construct zero value.
    TransportFun();
 
    TransportFun(const T &);
 
    TransportFun(int);
 
    TransportFun &operator=(const T &y);
 
    //  Return value of the coefficient denoted by the index.
    //  The index zero stands for the constant term,
    //  any other value selects the derivative by the variable index+1.
    //  Return zero, if index is out of range.
    const T getCoefficient(int index) const;
 
    //  Return value of the second-order coefficient denoted by indices.
    //  Return zero, if indices are out of range.
    const T getCoefficient(int index1, int index2) const;
 
    //  Assign value of the coefficient denoted by the index.
    //  The index zero stands for the constant term,
    //  any other value selects the derivative by the variable index+1.
    //  Ignore, if index is out of range.
    void setCoefficient(int index, const T &value);
 
    //  Assign value of the second-order coefficient denoted by indices.
    //  Ignore, if indices are out of range.
    void setCoefficient(int index1, int index2, const T &value);
 
    //  Return value of the coefficient denoted by the index.
    //  The index zero stands for the constant term,
    //  any other value selects the derivative by the variable index+1.
    //  Result is undefined, if index is out of range.
    inline const T operator[](int) const;
 
    //  Return a reference to the coefficient denoted by the index.
    //  Result is undefined, if index is out of range.
    //  The index zero stands for the constant term,
    //  any other value selects the derivative by the variable index+1.
    inline T &operator[](int);
 
    //  Return value of the second-order coefficient denoted by indices.
    //  NOTE: i1 <= i2.
    //  Result is undefined, if indices are out of range.
    inline const T operator()(int i1, int i2) const;
 
    //  Return a reference to the second-order coefficient denoted by indices.
    //  NOTE: i1 <= i2.
    //  Result is undefined, if indices are out of range.
    inline T &operator()(int i1, int i2);
 
    //  Construct the variable identified by the index [b]var[/b],
    //  with total of [b]nVar[/b] variables.
    static TransportFun makeVariable(int var);
 
    TransportFun operator+() const;
 
    TransportFun operator-() const;
 
    TransportFun &operator+=(const TransportFun &y);
 
    TransportFun &operator-=(const TransportFun &y);
 
    TransportFun &operator*=(const TransportFun &y);
 
    TransportFun &operator/=(const TransportFun &y);
 
    TransportFun &operator+=(const T &y);
 
    TransportFun &operator-=(const T &y);
 
    TransportFun &operator*=(const T &y);
 
    TransportFun &operator/=(const T &y);
 
    bool operator==(const TransportFun &y) const;
 
    bool operator==(const T &y) const;
 
    bool operator!=(const TransportFun &y) const;
 
    bool operator!=(const T &y) const;
 
    TransportFun inverse() const;
 
    TransportFun multiply(const TransportFun &y) const;
 
    TransportFun<T, N> multiplyVariable(int var) const;
 
    T evaluate(const FVector<T, N> &) const;
 
    //  Substitute map [b]m[/b] in TransportFun, giving new TransportFun.
    TransportFun<T, N> substitute(const TransportMap<T, N> &m) const;
 
    //  Substitute matrix [b]M[/b] in TransportFun, giving new TransportFun.
    TransportFun<T, N> substitute(const FMatrix<T, N, N> &M) const;
 
    //  Expand Taylor series with coefficiens [b]series[/b] and order one.
    TransportFun taylor(const T series[2]) const;
 
    std::istream &get(std::istream &is);
 
    std::ostream &put(std::ostream &os) const;
 
private:
 
    static const int SIZE = (N + 1) *(N + 2) / 2;
 
    //  data[0] is the constant term,
    //  data[v+1] is the coefficient of variable [b]v[/b].
    T data[SIZE];
};
 
 
// Global functions.
// ------------------------------------------------------------------------
 
template <class T, int N>
TransportFun<T, N> operator+(const TransportFun<T, N> &, const TransportFun<T, N> &);
 
template <class T, int N>
TransportFun<T, N> operator-(const TransportFun<T, N> &, const TransportFun<T, N> &);
 
template <class T, int N>
TransportFun<T, N> operator+(const TransportFun<T, N> &, const T &);
 
template <class T, int N>
TransportFun<T, N> operator-(const TransportFun<T, N> &, const T &);
 
template <class T, int N>
TransportFun<T, N> operator+(const T &, const TransportFun<T, N> &);
 
template <class T, int N>
TransportFun<T, N> operator-(const T &, const TransportFun<T, N> &);
 
template <class T, int N>
TransportFun<T, N> operator*(const TransportFun<T, N> &, const TransportFun<T, N> &);
 
template <class T, int N>
TransportFun<T, N> operator/(const TransportFun<T, N> &, const TransportFun<T, N> &);
 
template <class T, int N>
TransportFun<T, N> operator*(const TransportFun<T, N> &, const T &);
 
template <class T, int N>
TransportFun<T, N> operator/(const TransportFun<T, N> &, const T &);
 
template <class T, int N>
TransportFun<T, N> operator*(const T &, const TransportFun<T, N> &);
 
template <class T, int N>
TransportFun<T, N> operator/(const T &, const TransportFun<T, N> &);
 
template <class T, int N>
bool operator==(const T &, const TransportFun<T, N> &);
 
template <class T, int N>
bool operator!=(const T &, const TransportFun<T, N> &);
 
template <class T, int N>
std::istream &operator>>(std::istream &is, TransportFun<T, N> &);
 
template <class T, int N>
std::ostream &operator<<(std::ostream &os, const TransportFun<T, N> &);
 
 
// Implementation.
#include "FixedAlgebra/TransportFun.hpp"
#include "FixedAlgebra/TransportMap.h"
 
#endif // CLASSIC_TransportFun_HH