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