function.h

Go to the documentation of this file.

#ifndef MATH_FUNCTION_H
#define MATH_FUNCTION_H

#include "math.h"
#include <KrisLibrary/errors.h>
#include <string>
namespace Math
{
  template <class T> class VectorTemplate;
  template <class T> class MatrixTemplate;
  typedef VectorTemplate<Real> Vector;
  typedef MatrixTemplate<Real> Matrix;
} //namespace Math

namespace Math {


class RealFunction
{
public:
  virtual ~RealFunction() {}
  virtual std::string Label() const { return "<unknown R->R>"; }
  virtual std::string VariableLabel() const { return "x"; }
  virtual Real operator ()(Real t) { PreEval(t); return Eval(t); }
  virtual void PreEval(Real t) {}
  virtual Real Eval(Real t) =0;
  virtual Real Deriv(Real t) { FatalError("Deriv not defined in subclass of RealFunction"); return 0; }
  virtual Real Deriv2(Real t) { FatalError("Deriv2 not defined in subclass of RealFunction"); return 0; }
};

class RealFunction2
{
public:
  virtual ~RealFunction2() {}
  virtual std::string Label() const { return "<unknown R2->R>"; }
  virtual std::string VariableLabel(int i) const { return (i==0?"t":"x"); }
  virtual Real operator ()(Real t, Real x) { PreEval(t,x); return Eval(t,x); }
  virtual void PreEval(Real t, Real x) {}
  virtual Real Eval(Real t, Real x) =0;
};

class VectorFunction
{
public:
  virtual ~VectorFunction() {}
  virtual std::string Label() const { return "<unknown R->Rn>"; }
  virtual std::string Label(int i) const;
  virtual std::string VariableLabel() const { return "t"; }
  virtual int NumDimensions() const { FatalError("NumDimensions() not defined in subclass of VectorFunction"); return -1; }
  virtual void operator()(Real t,Vector& x);// { PreEval(t); Eval(t,x); }
  virtual void PreEval(Real t) {}
  virtual void Eval(Real t,Vector& x) =0;
  virtual void Deriv(Real t,Vector& dx) { FatalError("Deriv not defined in subclass of VectorFunction"); }
  virtual void Deriv2(Real t,Vector& ddx) { FatalError("Deriv2 not defined in subclass of VectorFunction"); }
};

class ScalarFieldFunction
{
public:
  virtual ~ScalarFieldFunction() {}
  virtual std::string Label() const { return "<unknown Rn->R>"; }
  virtual std::string VariableLabel(int i) const;
  virtual Real operator ()(const Vector& x) { PreEval(x); return Eval(x); }
  virtual void PreEval(const Vector& x) {}  //called before evaluations at x
  virtual Real Eval(const Vector& x) =0;
  virtual void Gradient(const Vector& x,Vector& grad) { FatalError("Gradient not defined in subclass of ScalarFieldFunction"); }
  virtual Real Gradient_i(const Vector& x,int i) { FatalError("Gradient_i not defined in subclass of ScalarFieldFunction"); return 0; }
  virtual Real DirectionalDeriv(const Vector& x,const Vector& h);
  virtual void Hessian(const Vector& x,Matrix& H) { FatalError("Hessian not defined in subclass of ScalarFieldFunction"); }
  virtual Real Hessian_ij(const Vector& x,int i,int j) { FatalError("Hessian_ij not defined in subclass of ScalarFieldFunction"); return 0; }
  virtual Real DirectionalDeriv2(const Vector& x,const Vector& h);
};


class VectorFieldFunction
{
public:
  virtual ~VectorFieldFunction() {}
  virtual std::string Label() const;
  virtual std::string Label(int i) const;
  virtual std::string VariableLabel(int i) const;
  virtual int NumDimensions() const { FatalError("NumDimensions() not defined in subclass of VectorFieldFunction"); return -1; }
  virtual void operator ()(const Vector& x,Vector& v) { PreEval(x);Eval(x,v); }
  virtual void PreEval(const Vector& x) {}  //called before evaluations at x
  virtual void Eval(const Vector& x,Vector& v) =0;
  virtual Real Eval_i(const Vector& x,int i);
  virtual Real Jacobian_ij(const Vector& x,int i,int j) { FatalError("Jacobian_ij() not defined in subclass of VectorFieldFunction"); return 0; }
  virtual void Jacobian_i(const Vector& x,int i,Vector& Ji);
  virtual void Jacobian_j(const Vector& x,int j,Vector& Jj);
  virtual void Jacobian(const Vector& x,Matrix& J);
  virtual void DirectionalDeriv(const Vector& x,const Vector& h,Vector& v);
  virtual Real Divergence(const Vector& x);

  virtual void Hessian_i(const Vector& x,int i,Matrix& Hi) { FatalError("Hessian_i() not defined in subclass of VectorFieldFunction"); }
  virtual Real Hessian_ijk(const Vector& x,int i,int j,int k) { FatalError("Hessian_ijk() not defined in subclass of VectorFieldFunction"); return 0; }
};

class DiffEqFunction
{
public:
  virtual ~DiffEqFunction() {}
  virtual int NumDimensions() const { FatalError("NumDimensions not defined in subclass of DiffEqFunction"); return -1; }
  virtual void operator ()(Real t,const Vector& y,Vector& fy) { PreEval(t,y); Eval(t,y,fy); }
  virtual void PreEval(Real t,const Vector& y) {}
  virtual void Eval(Real t,const Vector& y,Vector& fy) =0;
};


} //namespace Math

#endif