FunctionValueGrid.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.

*/

#ifndef FUNCTIONVALUEGRID_H
#define FUNCTIONVALUEGRID_H

#include "VertexGrid.h"

#include "ParametricFunction.h"

#include "LoopHelper.h"
#include "MultiDimensionalVector.h"
#include "Vector.h"

#include <memory>


template <unsigned N, unsigned P, typename NUM = double>
  class FunctionValueGrid: public VertexGrid<N, P, NUM> {

    public:

      typedef typename VertexGrid<N, P, NUM>::grid_size_type grid_size_type;
      typedef typename VertexGrid<N, P, NUM>::value_storage_type value_storage_type;

      typedef ParametricFunction<N, P, NUM> function_type;
      typedef std::shared_ptr<function_type> function_ptr_type;
      typedef VecMath::Vector<P, NUM> boundary_type;

      FunctionValueGrid();
      FunctionValueGrid(const function_ptr_type &f);
      FunctionValueGrid(const function_ptr_type &f,
                        const grid_size_type &grid_size);
      FunctionValueGrid(const function_ptr_type &f,
                        const grid_size_type &grid_size,
                        const boundary_type &x_min, const boundary_type &x_max);

      virtual ~FunctionValueGrid() { }

      void setGridSize(const grid_size_type &grid_size);
      void setBoundaries(const boundary_type &x_min, const boundary_type &x_max);

    private:

      void recalculate_grid();

      function_ptr_type _f;
      boundary_type _x_min;
      boundary_type _x_max;

      static constexpr double EPSILON = 1e-8;
};

template <unsigned N, unsigned P, typename NUM>
  FunctionValueGrid<N, P, NUM>::FunctionValueGrid():
    VertexGrid<N, P, NUM>(),
    _f(), _x_min(), _x_max() { }

template <unsigned N, unsigned P, typename NUM>
  FunctionValueGrid<N, P, NUM>::FunctionValueGrid(
        const FunctionValueGrid::function_ptr_type &f):
    VertexGrid<N, P, NUM>(),
    _f(f), _x_min(), _x_max() {
  setBoundaries(f->getDefaultXMin(), f->getDefaultXMax());
}

template <unsigned N, unsigned P, typename NUM>
  FunctionValueGrid<N, P, NUM>::FunctionValueGrid(
        const FunctionValueGrid::function_ptr_type &f,
        const FunctionValueGrid::grid_size_type &grid_size):
      VertexGrid<N, P, NUM>(),        
      _f(f), _x_min(), _x_max() {
    setGridSize(grid_size);
    setBoundaries(f->getDefaultXMin(), f->getDefaultXMax());
  }

template <unsigned N, unsigned P, typename NUM>
  FunctionValueGrid<N, P, NUM>::FunctionValueGrid(
        const FunctionValueGrid::function_ptr_type &f,
        const FunctionValueGrid::grid_size_type &grid_size,
        const FunctionValueGrid::boundary_type &x_min,
        const FunctionValueGrid::boundary_type &x_max):
      VertexGrid<N, P, NUM>(),
      _f(f), _x_min(), _x_max() {
    setGridSize(grid_size);
    setBoundaries(x_min, x_max);
  }

template <unsigned N, unsigned P, typename NUM>
  void FunctionValueGrid<N, P, NUM>::setGridSize(
    const FunctionValueGrid::grid_size_type &grid_size) {
  if (grid_size == VertexGrid<N, P, NUM>::_grid_size) return;
  VertexGrid<N, P, NUM>::_grid_size = grid_size;
  if (abs(VecMath::sqnorm(_x_max-_x_min)) > EPSILON) recalculate_grid();
}

template <unsigned N, unsigned P, typename NUM>
  void FunctionValueGrid<N, P, NUM>::setBoundaries(
    const FunctionValueGrid::boundary_type &x_min, const FunctionValueGrid::boundary_type &x_max) {
  if (abs(VecMath::sqnorm(_x_max-x_max)) < EPSILON && abs(VecMath::sqnorm(_x_min-x_min)) < EPSILON) return;
  _x_min = x_min;
  _x_max = x_max;
  if (VecMath::sqnorm(VertexGrid<N, P, NUM>::_grid_size)) recalculate_grid();
}

template <unsigned N, unsigned P, typename NUM>
  void FunctionValueGrid<N, P, NUM>::recalculate_grid() {
    LoopHelper< N, P, P, NUM > looper(
      _x_min, _x_max, VertexGrid<N, P, NUM>::_grid_size, _f);
    VecMath::Vector<P, NUM> x = _x_min;
    looper.recalculateOneDimensionOfGrid(VertexGrid<N, P, NUM>::_vertices, x);
}

#endif // FUNCTIONVALUEGRID_H