ParametricFunction.h

/*
    Hyperspace Explorer - vizualizing higher-dimensional geometry
    Copyright (C) 2010  Lene Preuss <lene.preuss@gmail.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
    (Seriously, has anyone ever done this?)

*/

#ifndef VECTORFUNCTION_H
#define VECTORFUNCTION_H

#include "ParameterMap.h"
#include "Vector.h"

#include <memory>


template <unsigned N, unsigned P, typename NUM = double>
  class ParametricFunction {

    public:

      typedef VecMath::Vector<P, NUM> argument_type;
      typedef VecMath::Vector<N, NUM> return_type;

      ParametricFunction():
        _function_name(), _function_description(),
        _parameters(),
        _default_x_min(-1.), _default_x_max(1.) { }

      virtual ~ParametricFunction() { }


      virtual return_type f(const argument_type &x) = 0;

      std::string getName() const { return _function_name; }

      std::string getDescription() const { return _function_description; }

      unsigned getNumParameters() const { return _parameters.size(); }

      ParameterMap getParameterMap() const { return _parameters; }

      FunctionParameter::parameter_ptr_type getParameter(const std::string &name) {
        return FunctionParameter::parameter_ptr_type(_parameters.getParameter(name));
      }

      FunctionParameter::value_ptr_type getParameterValue(const std::string &name) {
        return FunctionParameter::value_ptr_type(_parameters.getValue(name));
      }

      argument_type getDefaultXMin() const { return _default_x_min; }
      argument_type getDefaultXMax() const { return _default_x_max; }

    protected:

      void setName(const std::string &newName) { _function_name = newName; }

      void setDescription(const std::string &newDescription) { _function_description = newDescription; }


      template <typename T> void declareParameter(const std::string &parameter_name,
                                                  const T &parameter_default_value);


      template <typename T> void declareParameter(const std::string &parameter_name,
                                                  const T &parameter_default_value,
                                                  const T &parameter_value);

      void setDefaultBoundaries(const ParametricFunction::argument_type &x_min,
                                const ParametricFunction::argument_type &x_max);

    private:

      std::string _function_name;
      std::string _function_description;
      ParameterMap _parameters;
      argument_type _default_x_min;
      argument_type _default_x_max;
};

template <unsigned N, unsigned P, typename NUM>
inline
void ParametricFunction<N, P, NUM>::setDefaultBoundaries(
  const ParametricFunction<N, P, NUM>::argument_type& x_min,
  const ParametricFunction<N, P, NUM>::argument_type& x_max) {
  _default_x_min = x_min;
  _default_x_max = x_max;
}

template <unsigned N, unsigned P, typename NUM>
template<typename T>
inline
void ParametricFunction<N, P, NUM>::declareParameter(
    const std::string &parameter_name,
    const T &parameter_default_value) {
  if (_parameters.find(parameter_name) != _parameters.end()) return;

  _parameters.insertByDefault(parameter_name, parameter_default_value);
}

template <unsigned N, unsigned P, typename NUM>
  template<typename T>
inline
void ParametricFunction<N, P, NUM>::declareParameter(
    const std::string& parameter_name,
    const T& parameter_default_value,
    const T& parameter_value) {
  declareParameter(parameter_name, parameter_default_value);
  _parameters[parameter_name]->setValue(new FunctionParameterValue<T>(parameter_value));
}

#endif // VECTORFUNCTION_H