LinearFun.h

Go to the documentation of this file.

#ifndef CLASSIC_LinearFun_HH
#define CLASSIC_LinearFun_HH
 
// ------------------------------------------------------------------------
// $RCSfile: LinearFun.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template class: LinearFun<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 LinearMap;
template <class T, int M, int N> class FMatrix;
 
 
// Template class LinearFun<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 do the correct thing, and are not defined for speed.
 
template <class T, int N>
class LinearFun {
 
public:
 
    //  Construct zero value.
    LinearFun();
 
    LinearFun(const T &);
 
    LinearFun(int);
 
    LinearFun &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;
 
    //  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);
 
    //  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 index) 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.
    //  Use as a lvalue is only allowed when the LinearFun is unique().
    inline T &operator[](int index);
 
    //  Construct the variable identified by the index [b]var[/b],
    //  with total of [b]nVar[/b] variables.
    static LinearFun makeVariable(int var);
 
    LinearFun operator+() const;
 
    LinearFun operator-() const;
 
    LinearFun &operator+=(const LinearFun &y);
 
    LinearFun &operator-=(const LinearFun &y);
 
    LinearFun &operator*=(const LinearFun &y);
 
    LinearFun &operator/=(const LinearFun &y);
 
    LinearFun &operator+=(const T &y);
 
    LinearFun &operator-=(const T &y);
 
    LinearFun &operator*=(const T &y);
 
    LinearFun &operator/=(const T &y);
 
    bool operator==(const LinearFun &y) const;
 
    bool operator==(const T &y) const;
 
    bool operator!=(const LinearFun &y) const;
 
    bool operator!=(const T &y) const;
 
    LinearFun inverse() const;
 
    LinearFun multiply(const LinearFun &y) const;
 
    T evaluate(const FVector<T, N> &) const;
 
    //  Substitute map [b]m[/b] in LinearFun, giving new LinearFun.
    LinearFun<T, N> substitute(const LinearMap<T, N> &m) const;
 
    //  Substitute matrix [b]M[/b] in LinearFun, giving new LinearFun.
    LinearFun<T, N> substitute(const FMatrix<T, N, N> &M) const;
 
    //  Expand Taylor series with coefficiens [b]series[/b] and order one.
    LinearFun taylor(const T series[2]) const;
 
    std::istream &get(std::istream &is);
 
    std::ostream &put(std::ostream &os) const;
 
private:
 
    //  data[0] is the constant term,
    //  data[v+1] is the coefficient of variable [b]v[/b].
    T data[N+1];
};
 
 
// Global functions.
// ------------------------------------------------------------------------
 
template <class T, int N>
LinearFun<T, N> operator+(const LinearFun<T, N> &, const LinearFun<T, N> &);
 
template <class T, int N>
LinearFun<T, N> operator-(const LinearFun<T, N> &, const LinearFun<T, N> &);
 
template <class T, int N>
LinearFun<T, N> operator+(const LinearFun<T, N> &, const T &);
 
template <class T, int N>
LinearFun<T, N> operator-(const LinearFun<T, N> &, const T &);
 
template <class T, int N>
LinearFun<T, N> operator+(const T &, const LinearFun<T, N> &);
 
template <class T, int N>
LinearFun<T, N> operator-(const T &, const LinearFun<T, N> &);
 
template <class T, int N>
LinearFun<T, N> operator*(const LinearFun<T, N> &, const LinearFun<T, N> &);
 
template <class T, int N>
LinearFun<T, N> operator/(const LinearFun<T, N> &, const LinearFun<T, N> &);
 
template <class T, int N>
LinearFun<T, N> operator*(const LinearFun<T, N> &, const T &);
 
template <class T, int N>
LinearFun<T, N> operator/(const LinearFun<T, N> &, const T &);
 
template <class T, int N>
LinearFun<T, N> operator*(const T &, const LinearFun<T, N> &);
 
template <class T, int N>
LinearFun<T, N> operator/(const T &, const LinearFun<T, N> &);
 
template <class T, int N>
bool operator==(const T &, const LinearFun<T, N> &);
 
template <class T, int N>
bool operator!=(const T &, const LinearFun<T, N> &);
 
template <class T, int N>
std::istream &operator>>(std::istream &is, LinearFun<T, N> &);
 
template <class T, int N>
std::ostream &operator<<(std::ostream &os, const LinearFun<T, N> &);
 
 
// Implementation.
#include "FixedAlgebra/LinearFun.hpp"
#include "FixedAlgebra/LinearMap.h"
 
#endif // CLASSIC_LinearFun_HH