geometry/sampled_mapping.h

// -*- c++ -*-

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

#ifndef _MATHTL_SAMPLED_MAPPING_H
#define _MATHTL_SAMPLED_MAPPING_H

#include <iostream>

#include <geometry/point.h>
#include <geometry/grid.h>
#include <utils/array1d.h>
#include <utils/function.h>
#include <utils/multiindex.h>
#include <utils/fixed_array1d.h>
#include <algebra/matrix.h>
#include <algebra/infinite_vector.h>

#include <geometry/chart.h>


namespace MathTL
{
  template <unsigned int DIM, class C=double>
  class SampledMapping
    : public Grid<DIM>
  {
  public:
    SampledMapping() {}

    SampledMapping(const SampledMapping<DIM>& sm);

    SampledMapping(const Grid<DIM>& grid);

    SampledMapping(const Grid<DIM>& grid, const Array1D<C>& values);

    SampledMapping(const Grid<DIM>& grid, const Function<DIM>& f);

    SampledMapping(const MultiIndex<int, DIM>& a,
                   const MultiIndex<int, DIM>& b,
                   const InfiniteVector<C, MultiIndex<int, DIM> >& values,
                   const int resolution);

    SampledMapping(const Point<DIM,C>& a,
                   const Point<DIM,C>& b,
                   const FixedArray1D<Array1D<C>,DIM>& values);

    SampledMapping(const Chart<DIM>& ch,
                   const FixedArray1D<Array1D<C>,DIM>& values,
                   const unsigned int resolution);

    SampledMapping(const Chart<DIM>& ch,
                   const unsigned int resolution);

    SampledMapping<DIM,C>& operator = (const SampledMapping<DIM,C>& sm);

    void add(const SampledMapping<DIM,C>& s);
    
    void add(const C alpha, const SampledMapping<DIM,C>& s);

    void mult(const C alpha);


    void matlab_output(std::ostream& os) const;
  };

  //
  //
  // template specializations to one and two space dimensions

  template <class C>
  class SampledMapping<1,C>
    : public Grid<1>
  {
  public:
    SampledMapping();

    SampledMapping(const SampledMapping<1,C>& sm);

    SampledMapping(const Grid<1>& grid);

    SampledMapping(const Grid<1>& grid, const Array1D<C>& values);

    SampledMapping(const Grid<1>& grid, const Function<1,C>& f);

    SampledMapping(const MultiIndex<int,1>& a,
                   const MultiIndex<int,1>& b,
                   const InfiniteVector<C, MultiIndex<int, 1> >& values,
                   const int resolution);

    SampledMapping(const int a,
                   const int b,
                   const InfiniteVector<C, int>& values,
                   const int resolution);

    SampledMapping(const Point<1,C>& a,
                   const Point<1,C>& b,
                   const FixedArray1D<Array1D<C>,1>& values);

    SampledMapping(const Chart<1>& ch,
                   const FixedArray1D<Array1D<C>,1>& values,
                   const unsigned int resolution);

    SampledMapping(const Chart<1>& ch,
                   const unsigned int resolution);

    SampledMapping<1,C>& operator = (const SampledMapping<1,C>& sm);

    void add(const SampledMapping<1,C>& s);
    
    void add(const C alpha, const SampledMapping<1,C>& s);

    void mult(const C alpha);

    inline const Array1D<C>& values() const { return values_; }

    void matlab_output(std::ostream& os) const;

    void gnuplot_output(std::ostream& os) const;

  protected:
    Array1D<C> values_;
  };

  template <class C>
  class SampledMapping<2,C>
    : public Grid<2>
  {
  public:
    SampledMapping();

    SampledMapping(const SampledMapping<2,C>& sm);

    SampledMapping(const Grid<2>& grid);

    SampledMapping(const Grid<2>& grid, const Matrix<C>& values);

    SampledMapping(const Grid<2>& grid, const Function<2,C>& f);

    SampledMapping(const Grid<2>& grid, Function<1,C>& f);

    SampledMapping(const MultiIndex<int, 2>& a,
                   const MultiIndex<int, 2>& b,
                   const InfiniteVector<C, MultiIndex<int, 2> >& values,
                   const int resolution);

    SampledMapping(const Point<2,C>& a,
                   const Point<2,C>& b,
                   const FixedArray1D<Array1D<C>,2>& values);

    SampledMapping(const Chart<2>& ch,
                   const FixedArray1D<Array1D<C>,2>& values,
                   const unsigned int resolution);

    SampledMapping(const Chart<2>& ch,
                   const unsigned int resolution);


    SampledMapping<2,C>& operator = (const SampledMapping<2,C>& sm);

    void add(const SampledMapping<2,C>& s);
    
    void add(const C alpha, const SampledMapping<2,C>& s);

    void mult(const C alpha);

    inline const Matrix<C>& values() const { return values_; }

    void matlab_output(std::ostream& os) const;
       
    void gnuplot_output(std::ostream& os) const;


    void octave_output(std::ostream& os) const;

  protected:
    Matrix<C> values_;
  };

  template <unsigned int DIM, class C>
  void matlab_output(std::ostream& os,
                     const Array1D<SampledMapping<DIM,C> >& values);

  template <unsigned int DIM, class C>
  void octave_output(std::ostream& os,
                     const Array1D<SampledMapping<DIM,C> >& values);

}

#include "geometry/sampled_mapping.cpp"

#endif