utils/function.h

// -*- c++ -*-

// +--------------------------------------------------------------------+
// | This file is part of MathTL - the Mathematical Template Library    |
// |                                                                    |
// | Copyright (c) 2002-2009                                            |
// | Thorsten Raasch, Manuel Werner                                     |
// +--------------------------------------------------------------------+

#ifndef _MATHTL_FUNCTION_H
#define _MATHTL_FUNCTION_H

#include <algebra/vector.h>
#include <utils/function_time.h>
#include <geometry/point.h>

namespace MathTL
{
  template <unsigned int DIM, class VALUE> class Point;
  template <unsigned int RANK, unsigned int DIM, class VALUE> class Tensor;
  template <unsigned int DIM, class VALUE> class Tensor<1, DIM, VALUE>;

  template <unsigned int DIM, class VALUE = double>
  class Function : public FunctionTime
  {
  public:
    static const unsigned int dimension = DIM;

    typedef size_t size_type;

    const unsigned int n_components;

    Function(const unsigned int n_components = 1,
             const double initial_time = 0.0);

    virtual ~Function() = 0;

    virtual VALUE value (const Point<DIM,VALUE>& p,
                         const unsigned int component = 0) const = 0;

    virtual void vector_value(const Point<DIM,VALUE> &p,
                              Vector<VALUE>& values) const = 0;

    const size_type memory_consumption() const;
  };


  //
  //
  // some example functions

  template <unsigned int DIM, class VALUE = double>
  class ZeroFunction
    : public Function<DIM, VALUE>
  {
  public:
    ZeroFunction(const unsigned int n_components = 1);
    virtual ~ZeroFunction();
    VALUE value(const Point<DIM,VALUE>& p,
                const unsigned int component = 0) const;
    void vector_value(const Point<DIM,VALUE> &p,
                      Vector<VALUE>& values) const;
  };

  template <unsigned int DIM, class VALUE = double>
  class ConstantFunction
    : public Function<DIM, VALUE>
  {
  public:
    ConstantFunction(const Vector<VALUE>& value);
    virtual ~ConstantFunction();
    VALUE value(const Point<DIM,VALUE>& p,
                const unsigned int component = 0) const;
    void vector_value(const Point<DIM,VALUE> &p,
                      Vector<VALUE>& values) const;
  protected:
    Vector<VALUE> c;
  };

  template <unsigned int DIM, class VALUE = double>
  class ProductFunction
    : public Function<DIM, VALUE>
  {
  public:
    ProductFunction(const Function<DIM,VALUE>* f1,
                    const Function<DIM,VALUE>* f2);
    virtual ~ProductFunction();
    VALUE value(const Point<DIM,VALUE>& p,
                const unsigned int component = 0) const;
    void vector_value(const Point<DIM,VALUE> &p,
                      Vector<VALUE>& values) const;
    
  protected:
    const Function<DIM,VALUE>* f1_;
    const Function<DIM,VALUE>* f2_;
  };
}

// implementations of inline functions
#include "utils/function.cpp"

#endif