JPolint.hh

Go to the documentation of this file.

#ifndef __JTOOLS__JPOLINT__
#define __JTOOLS__JPOLINT__

#include <cmath>
#include <iterator>
#include <algorithm>

#include "JLang/JException.hh"
#include "JLang/JBool.hh"
#include "JTools/JFunctional.hh"
#include "JTools/JDistance.hh"
#include "JTools/JResult.hh"
#include "JTools/JElement.hh"
#include "JTools/JMapCollection.hh"
#include "JTools/JQuadrature.hh"


/**
 * \author mdejong
 */

namespace JTOOLS {}
namespace JPP { using namespace JTOOLS; }

namespace JTOOLS {

  using JLANG::JEmptyCollection;
  using JLANG::JNumericalPrecision;
  using JLANG::JValueOutOfRange;


  /**
   * Template definition for functional collection with polynomial interpolation.
   */
  template<unsigned int N, 
           class JElement_t,
           template<class, class> class JCollection_t,
           class JResult_t,
           class JDistance_t>
  class JPolintFunction;


  /**
   * Template specialisation for functional collection with polynomial interpolation.
   *
   * Polynomial interpolation code is taken from reference:
   * Numerical Recipes in C++, W.H. Press, S.A. Teukolsky, W.T. Vetterling and B.P. Flannery,
   * Cambridge University Press.
   */
  template<unsigned int N, class JElement_t, template<class, class> class JCollection_t, class JDistance_t>
  class JPolintFunction<N, 
                        JElement_t, 
                        JCollection_t, 
                        typename JResultType<typename JElement_t::ordinate_type>::result_type,
                        JDistance_t> :
    public JCollection_t<JElement_t, JDistance_t>,
    public JFunction<typename JElement_t::abscissa_type,
                     typename JResultType<typename JElement_t::ordinate_type>::result_type>
  {
  public:

    typedef JCollection_t<JElement_t, JDistance_t>                               collection_type;

    typedef typename collection_type::abscissa_type                              abscissa_type;
    typedef typename collection_type::ordinate_type                              ordinate_type;
    typedef typename collection_type::value_type                                 value_type;
    typedef typename collection_type::distance_type                              distance_type;

    typedef typename collection_type::const_iterator                             const_iterator;
    typedef typename collection_type::const_reverse_iterator                     const_reverse_iterator;
    typedef typename collection_type::iterator                                   iterator;
    typedef typename collection_type::reverse_iterator                           reverse_iterator;

    typedef typename JResultType<ordinate_type>::result_type                     data_type;
    typedef JFunction<abscissa_type, data_type>                                  function_type;           

    typedef typename function_type::argument_type                                argument_type;
    typedef typename function_type::result_type                                  result_type;
    typedef typename function_type::JExceptionHandler                            exceptionhandler_type;


    /**
     * Default constructor.                     
     */
    JPolintFunction()
    {}


    /**
     * Recursive interpolation method implementation.
     *
     * \param  pX              pointer to abscissa values
     * \return                 function value
     */
    virtual result_type evaluate(const argument_type* pX) const
    {
      if (this->empty()) {
        return this->getExceptionHandler().action(JEmptyCollection("JPolintFunction<>::evaluate() no data."));
      }

      const argument_type x = *pX;

      const_iterator p = this->lower_bound(x);

      if ((p == this->begin() && this->getDistance(x, (p++)->getX()) > distance_type::precision) ||
          (p == this->end()   && this->getDistance((--p)->getX(), x) > distance_type::precision)) {
        return this->getExceptionHandler().action(JValueOutOfRange("JPolintFunction::evaluate() x out of range."));
      }

      ++pX;  // next argument value


      const int n = std::min((int) (N + 1), (int) this->size());         // number of points to interpolate      

      for (int i = n/2; i != 0 && p != this->end();   --i, ++p) {}       // move p to begin of data
      for (int i = n  ; i != 0 && p != this->begin(); --i, --p) {}


      int j = 0;

      for (int i = 0; i != n; ++p, ++i) {
        
        u[i] = this->getDistance(x, p->getX());
        v[i] = function_type::getValue(p->getY(), pX);
        w[i] = v[i];

        if (fabs(u[i]) < fabs(u[j])) {
          j = i;
        }
      }

      
      result_type y = v[j];

      --j;

      for (int m = 1; m != n; ++m) {

        for (int i = 0; i != n-m; ++i) {

          const double ho = u[ i ];
          const double hp = u[i+m];
          const double dx = ho - hp;

          v[i]  = v[i+1];
          v[i] -= w[ i ];
          w[i]  = v[ i ];

          v[i] *= ho/dx;
          w[i] *= hp/dx;
        }

        if (2*(j+1) < n - m)
          y += v[j+1];
        else
          y += w[j--];
      }

      return y;
    }

  private: 
    /**
     * Function compilation.
     */
    virtual void do_compile() 
    {}


    mutable double      u[N+1];
    mutable result_type v[N+1];
    mutable result_type w[N+1];
  };


  /**
   * Template specialisation for zero-degree polynomial interpolation method.
   * The interpolation is based on a simple lookup table.
   */
  template<class JElement_t, template<class, class> class JCollection_t, class JDistance_t>
  class JPolintFunction<0, 
                        JElement_t,
                        JCollection_t,
                        typename JResultType<typename JElement_t::ordinate_type>::result_type,
                        JDistance_t> :
    public JCollection_t<JElement_t, JDistance_t>,
    public JFunction<typename JElement_t::abscissa_type,
                     typename JResultType<typename JElement_t::ordinate_type>::result_type>
  {
  public:

    typedef JCollection_t<JElement_t, JDistance_t>                               collection_type;

    typedef typename collection_type::abscissa_type                              abscissa_type;
    typedef typename collection_type::ordinate_type                              ordinate_type;
    typedef typename collection_type::value_type                                 value_type;
    typedef typename collection_type::distance_type                              distance_type;

    typedef typename collection_type::const_iterator                             const_iterator;
    typedef typename collection_type::const_reverse_iterator                     const_reverse_iterator;
    typedef typename collection_type::iterator                                   iterator;
    typedef typename collection_type::reverse_iterator                           reverse_iterator;

    typedef typename JResultType<ordinate_type>::result_type                     data_type;
    typedef JFunction<abscissa_type, data_type>                                  function_type;           

    typedef typename function_type::argument_type                                argument_type;
    typedef typename function_type::result_type                                  result_type;
    typedef typename function_type::JExceptionHandler                            exceptionhandler_type;


    /**
     * Default constructor.                     
     */
    JPolintFunction()
    {}


    /**
     * Recursive interpolation method implementation.
     *
     * \param  pX              pointer to abscissa values
     * \return                 function value
     */
    virtual result_type evaluate(const argument_type* pX) const
    {
      if (this->empty()) {
        return this->getExceptionHandler().action(JEmptyCollection("JPolintFunction<>::evaluate() no data."));
      }

      const argument_type x = *pX;

      const_iterator p = this->lower_bound(x);

      if ((p == this->begin() && this->getDistance(x, (p++)->getX()) > distance_type::precision) ||
          (p == this->end()   && this->getDistance((--p)->getX(), x) > distance_type::precision)) {

        return this->getExceptionHandler().action(JValueOutOfRange("JPolintFunction::evaluate() x out of range."));
      }

      ++pX;  // next argument value


      const_iterator q = p--;

      if (q == this->begin() || this->getDistance(x, q->getX()) < this->getDistance(p->getX(), x)) 
        return function_type::getValue(q->getY(), pX);
      else
        return function_type::getValue(p->getY(), pX);
    }

  private:
    /**
     * Function compilation.
     */
    virtual void do_compile() 
    {}
  };


  /**
   * Template specialisation for first-degree polynomial interpolation method.
   * The interpolation is based on a simple linear interpolation.
   */
  template<class JElement_t, template<class, class> class JCollection_t, class JDistance_t>
  class JPolintFunction<1, 
                        JElement_t,
                        JCollection_t,
                        typename JResultType<typename JElement_t::ordinate_type>::result_type,
                        JDistance_t> :
    public JCollection_t<JElement_t, JDistance_t>,
    public JFunction<typename JElement_t::abscissa_type,
                     typename JResultType<typename JElement_t::ordinate_type>::result_type>
  {
  public:

    typedef JCollection_t<JElement_t, JDistance_t>                               collection_type;

    typedef typename collection_type::abscissa_type                              abscissa_type;
    typedef typename collection_type::ordinate_type                              ordinate_type;
    typedef typename collection_type::value_type                                 value_type;
    typedef typename collection_type::distance_type                              distance_type;

    typedef typename collection_type::const_iterator                             const_iterator;
    typedef typename collection_type::const_reverse_iterator                     const_reverse_iterator;
    typedef typename collection_type::iterator                                   iterator;
    typedef typename collection_type::reverse_iterator                           reverse_iterator;

    typedef typename JResultType<ordinate_type>::result_type                     data_type;
    typedef JFunction<abscissa_type, data_type>                                  function_type;           

    typedef typename function_type::argument_type                                argument_type;
    typedef typename function_type::result_type                                  result_type;
    typedef typename function_type::JExceptionHandler                            exceptionhandler_type;


    /**
     * Default constructor.                     
     */
    JPolintFunction() 
    {}


    /**
     * Recursive interpolation method implementation.
     *
     * \param  pX              pointer to abscissa values
     * \return                 function value
     */
    virtual result_type evaluate(const argument_type* pX) const
    {
      if (this->empty()) {
        return this->getExceptionHandler().action(JEmptyCollection("JPolintFunction<>::evaluate() no data."));
      }

      const argument_type x = *pX;

      const_iterator p = this->lower_bound(x);

      if ((p == this->begin() && this->getDistance(x, (p++)->getX()) > distance_type::precision) ||
          (p == this->end()   && this->getDistance((--p)->getX(), x) > distance_type::precision)) {

        return this->getExceptionHandler().action(JValueOutOfRange("JPolintFunction::evaluate() x out of range."));
      }

      ++pX;  // next argument value


      const_iterator q = p--;

      const double dx = this->getDistance(p->getX(), q->getX());
      const double a  = this->getDistance(x, q->getX()) / dx;
      const double b  = 1.0 - a;

      return a * function_type::getValue(p->getY(), pX) + b * function_type::getValue(q->getY(), pX);
    }

  private:
    /**
     * Function compilation.
     */
    virtual void do_compile() 
    {}
  };


  /**
   * Template specialisation for polynomial interpolation method with returning JResultHesse data structure.
   */
  template<unsigned int N, class JElement_t, template<class, class> class JCollection_t, class JDistance_t>
  class JPolintFunction<N,
                        JElement_t,
                        JCollection_t,
                        JResultHesse<typename JResultType<typename JElement_t::ordinate_type>::result_type>,
                        JDistance_t> :
    public JCollection_t<JElement_t, JDistance_t>,
    public JFunction<typename JElement_t::abscissa_type, 
                     JResultHesse<typename JResultType<typename JElement_t::ordinate_type>::result_type> >
  {
  public:

    typedef JCollection_t<JElement_t, JDistance_t>                               collection_type;

    typedef typename collection_type::abscissa_type                              abscissa_type;
    typedef typename collection_type::ordinate_type                              ordinate_type;
    typedef typename collection_type::value_type                                 value_type;
    typedef typename collection_type::distance_type                              distance_type;

    typedef typename collection_type::const_iterator                             const_iterator;
    typedef typename collection_type::const_reverse_iterator                     const_reverse_iterator;
    typedef typename collection_type::iterator                                   iterator;
    typedef typename collection_type::reverse_iterator                           reverse_iterator;

    typedef typename JResultType<ordinate_type>::result_type                     data_type;
    typedef JFunction<abscissa_type, JResultHesse<data_type> >                   function_type;

    typedef typename function_type::argument_type                                argument_type;
    typedef typename function_type::result_type                                  result_type;
    typedef typename function_type::JExceptionHandler                            exceptionhandler_type;

    using JFunctional<>::compile;


    /**
     * Default contructor.
     */
    JPolintFunction()
    {}


    /**
     * Recursive interpolation method implementation.
     *
     * \param  pX              pointer to abscissa values
     * \return                 function value
     */
    virtual result_type evaluate(const argument_type* pX) const
    {
      if (this->empty()) {
        return this->getExceptionHandler().action(JEmptyCollection("JPolintFunction<>::evaluate() no data."));
      }

      const argument_type x = *pX;

      const_iterator p = this->lower_bound(x);

      if ((p == this->begin() && this->getDistance(x, (p++)->getX()) > distance_type::precision) ||
          (p == this->end()   && this->getDistance((--p)->getX(), x) > distance_type::precision)) {

        return this->getExceptionHandler().action(JValueOutOfRange("JPolintFunction::evaluate() x out of range."));
      }

      ++pX;  // next argument value


      const int n = std::min((int) (N + 1), (int) this->size());         // number of points to interpolate      

      for (int i = n/2; i != 0 && p != this->end();   --i, ++p) {}       // move p to begin of data
      for (int i = n  ; i != 0 && p != this->begin(); --i, --p) {}


      int j = 0;

      for (int i = 0; i != n; ++p, ++i) {
        
        u [i] = this->getDistance(x, p->getX());
        v [i] = JFunctional<argument_type, data_type>::getValue(p->getY(), pX);
        w [i] = v[i];
        vp[i] = JMATH::zero;
        wp[i] = JMATH::zero;
          
        if (fabs(u[i]) < fabs(u[j])) {
          j = i;
        }
      }


      result.f  = v[j];
      result.fp = JMATH::zero;

      --j;

      for (int m = 1; m != n; ++m) {

        for (int i = 0; i != n-m; ++i) {

          const double ho = u[ i ];
          const double hp = u[i+m];
          const double dx = ho - hp;

          const data_type r  = (v [i+1] - w [i]) / dx;
          const data_type rp = (vp[i+1] - wp[i]) / dx;

          v [i] = ho * r;
          w [i] = hp * r;
          vp[i] = ho * rp - r;
          wp[i] = hp * rp - r;
        }

        if (2*(j+1) < n - m) {

          result.f  += v [j+1];
          result.fp += vp[j+1];

        } else {

          result.f  += w [j];
          result.fp += wp[j];

          --j;
        }
      }

      return result;
    }

  private: 
    /**
     * Function compilation.
     */
    virtual void do_compile() 
    {}


    mutable double    u [N+1];
    mutable data_type v [N+1];
    mutable data_type w [N+1];
    mutable data_type vp[N+1];
    mutable data_type wp[N+1];

    mutable result_type result;
  };


  /**
   * Template specialisation for polynomial interpolation method with returning JResultPDF data structure.
   *
   * Note that the data structure of the elements in the collection should have the additional methods:
   * <pre>
   *     ordinate_type getIntegral() const;
   *     void setIntegral(ordinate_type v);
   * </pre>
   * to get and set the integral values, respectively.
   */
  template<unsigned int N, class JElement_t, template<class, class> class JCollection_t, class JDistance_t>
  class JPolintFunction<N,
                        JElement_t,
                        JCollection_t,
                        JResultPDF<typename JResultType<typename JElement_t::ordinate_type>::result_type>,
                        JDistance_t> :
    public JCollection_t<JElement_t, JDistance_t>,
    public JFunction<typename JElement_t::abscissa_type, 
                     JResultPDF<typename JResultType<typename JElement_t::ordinate_type>::result_type> >
  {
  public:

    typedef JCollection_t<JElement_t, JDistance_t>                               collection_type;

    typedef typename collection_type::abscissa_type                              abscissa_type;
    typedef typename collection_type::ordinate_type                              ordinate_type;
    typedef typename collection_type::value_type                                 value_type;
    typedef typename collection_type::distance_type                              distance_type;

    typedef typename collection_type::const_iterator                             const_iterator;
    typedef typename collection_type::const_reverse_iterator                     const_reverse_iterator;
    typedef typename collection_type::iterator                                   iterator;
    typedef typename collection_type::reverse_iterator                           reverse_iterator;

    typedef typename JResultType<ordinate_type>::result_type                     data_type;
    typedef JFunction<abscissa_type, JResultPDF<data_type> >                     function_type;

    typedef typename function_type::argument_type                                argument_type;
    typedef typename function_type::result_type                                  result_type;
    typedef typename function_type::JExceptionHandler                            exceptionhandler_type;

    using JFunctional<>::compile;


    /**
     * Default contructor.
     */
    JPolintFunction()
    {}


    /**
     * Recursive interpolation method implementation.
     *
     * \param  pX              pointer to abscissa values
     * \return                 function value
     */
    virtual result_type evaluate(const argument_type* pX) const
    {
      if (this->empty()) {
        return this->getExceptionHandler().action(JEmptyCollection("JPolintFunction<>::evaluate() no data."));
      }

      const argument_type x = *pX;

      const_iterator p = this->lower_bound(x);

      if ((p == this->begin() && this->getDistance(x, (p++)->getX()) > distance_type::precision) ||
          (p == this->end()   && this->getDistance((--p)->getX(), x) > distance_type::precision)) {

        return this->getExceptionHandler().action(JValueOutOfRange("JPolintFunction::evaluate() x out of range."));
      }

      ++pX;  // next argument value

      {
        const int n = std::min((int) (N + 1), (int) this->size());         // number of points to interpolate

        for (int i = n/2; i != 0 && p != this->end();   --i, ++p) {}       // move p to begin of data
        for (int i = n  ; i != 0 && p != this->begin(); --i, --p) {}

        
        int j = 0;
        
        for (int i = 0; i != n; ++p, ++i) {

          u [i] = this->getDistance(x, p->getX());
          v [i] = JFunctional<argument_type, data_type>::getValue(p->getY(), pX);
          w [i] = v[i];
          vp[i] = JMATH::zero;
          wp[i] = JMATH::zero;
          vi[i] = p->getIntegral();
          wi[i] = vi[i];
          
          if (fabs(u[i]) < fabs(u[j])) {
            j = i;
          }
        }
        
        
        result.f  = v [j];
        result.fp = JMATH::zero;
        result.v  = vi[j];
        result.V  = this->rbegin()->getIntegral();
        
        --j;
        
        for (int m = 1; m != n; ++m) {
          
          for (int i = 0; i != n-m; ++i) {
            
            const double ho = u[ i ];
            const double hp = u[i+m];
            const double dx = ho - hp;
            
            const data_type r  = (v [i+1] - w [i]) / dx;
            const data_type rp = (vp[i+1] - wp[i]) / dx;
            const data_type ri = (vi[i+1] - wi[i]) / dx;
            
            v [i] = ho * r;
            w [i] = hp * r;
            vp[i] = ho * rp - r;
            wp[i] = hp * rp - r;
            vi[i] = ho * ri;
            wi[i] = hp * ri;
          }

          if (2*(j+1) < n - m) {
            
            result.f  += v [j+1];
            result.fp += vp[j+1];
            result.v  += vi[j+1];
            
          } else {
            
            result.f  += w [j];
            result.fp += wp[j];
            result.v  += wi[j];
          
            --j;
          }
        }
      }
      
      return result;
    }

  private: 
    /**
     * Function compilation.
     */
    virtual void do_compile() 
    {
      ordinate_type V(JMATH::zero);

      if (this->getSize() > 1) {

        const JGaussLegendre engine(N);

        this->begin()->setIntegral(V);

        for (iterator j = this->begin(), i = j++; j != this->end(); ++i, ++j) {
          
          const abscissa_type xmin = i->getX();
          const abscissa_type xmax = j->getX();
          
          for (JGaussLegendre::const_iterator m = engine.begin(); m != engine.end(); ++m) {
            
            const abscissa_type x = 0.5 * (xmax + xmin  +  m->getX() * (xmax - xmin));
            const ordinate_type v = 0.5 * (xmax - xmin) *  m->getY() * get_value(this->evaluate(&x));
            
            V += v;
          }
          
          j->setIntegral(V);
        }
      }
    }


    mutable double    u [N+1];
    mutable data_type v [N+1];
    mutable data_type w [N+1];
    mutable data_type vp[N+1];
    mutable data_type wp[N+1];
    mutable data_type vi[N+1];
    mutable data_type wi[N+1];

    mutable result_type result;
  };


  /**
   * Template specialisation for polynomial interpolation method with returning JResultPolynome data structure.
   */
  template<unsigned int N, class JElement_t, template<class, class> class JCollection_t, class JDistance_t>
  class JPolintFunction<N,
                        JElement_t,
                        JCollection_t,
                        JResultPolynome<N, typename JResultType<typename JElement_t::ordinate_type>::result_type>,
                        JDistance_t> :
    public JCollection_t<JElement_t, JDistance_t>,
    public JFunction<typename JElement_t::abscissa_type, 
                     JResultPolynome<N, typename JResultType<typename JElement_t::ordinate_type>::result_type> >
  {
  public:

    typedef JCollection_t<JElement_t, JDistance_t>                               collection_type;

    typedef typename collection_type::abscissa_type                              abscissa_type;
    typedef typename collection_type::ordinate_type                              ordinate_type;
    typedef typename collection_type::value_type                                 value_type;
    typedef typename collection_type::distance_type                              distance_type;

    typedef typename collection_type::const_iterator                             const_iterator;
    typedef typename collection_type::const_reverse_iterator                     const_reverse_iterator;
    typedef typename collection_type::iterator                                   iterator;
    typedef typename collection_type::reverse_iterator                           reverse_iterator;

    typedef typename JResultType<ordinate_type>::result_type                     data_type;
    typedef JFunction<abscissa_type, JResultPolynome<N, data_type> >             function_type;

    typedef typename function_type::argument_type                                argument_type;
    typedef typename function_type::result_type                                  result_type;
    typedef typename function_type::JExceptionHandler                            exceptionhandler_type;

    using JFunctional<>::compile;


    /**
     * Default contructor.
     */
    JPolintFunction()
    {}


    /**
     * Recursive interpolation method implementation.
     *
     * \param  pX              pointer to abscissa values
     * \return                 function value
     */
    virtual result_type evaluate(const argument_type* pX) const
    {
      if (this->empty()) {
        return this->getExceptionHandler().action(JEmptyCollection("JPolintFunction<>::evaluate() no data."));
      }

      const argument_type x = *pX;

      const_iterator p = this->lower_bound(x);

      if ((p == this->begin() && this->getDistance(x, (p++)->getX()) > distance_type::precision) ||
          (p == this->end()   && this->getDistance((--p)->getX(), x) > distance_type::precision)) {

        return this->getExceptionHandler().action(JValueOutOfRange("JPolintFunction::evaluate() x out of range."));
      }

      ++pX;  // next argument value


      const int n = std::min((int) (N + 1), (int) this->size());         // number of points to interpolate      

      for (int i = n/2; i != 0 && p != this->end();   --i, ++p) {}       // move p to begin of data
      for (int i = n  ; i != 0 && p != this->begin(); --i, --p) {}

      
      for (unsigned int i = 0; i != N+1; ++i) {
        for (unsigned int j = 0; j != N+1; ++j) {

          v[i][j] = JMATH::zero;
          w[i][j] = JMATH::zero;
        }

        result.y[i] = JMATH::zero;
      }


      int j = 0;

      for (int i = 0; i != n; ++p, ++i) {
        
        u[i]    = this->getDistance(x, p->getX());
        v[i][0] = JFunctional<argument_type, data_type>::getValue(p->getY(), pX);
        w[i][0] = v[i][0];
          
        if (fabs(u[i]) < fabs(u[j])) {
          j = i;
        }
      }

      result.y[0] = v[j][0];

      --j;

      for (int m = 1; m != n; ++m) {

        for (int i = 0; i != n-m; ++i) {

          const double ho = u[ i ];
          const double hp = u[i+m];
          const double dx = ho - hp;

          for (int k = 0; k != N+1; ++k) {
            r[k] = (v[i+1][k] - w[i][k]) / dx;
          }

          v[i][0] = ho * r[0];
          w[i][0] = hp * r[0];

          for (int k = 1; k != N+1; ++k) {
            v[i][k] = ho * r[k]  -  k * r[k-1];
            w[i][k] = hp * r[k]  -  k * r[k-1];
          }
        }

        if (2*(j+1) < n - m) {

          for (int k = 0; k != N+1; ++k) {
            result.y[k] += v[j+1][k];
          }

        } else {

          for (int k = 0; k != N+1; ++k) {
            result.y[k] += w[j][k];
          }

          --j;
        }
      }

      return result;
    }

  private: 
    /**
     * Function compilation.
     */
    virtual void do_compile() 
    {}


    mutable double    u[N+1];
    mutable data_type v[N+1][N+1];
    mutable data_type w[N+1][N+1];
    mutable data_type r[N+1];

    mutable result_type result;
  };


  /**
   * Template class for polynomial interpolation in 1D
   *
   * This class implements the JFunction1D interface.
   */
  template<unsigned int N,
           class JElement_t,
           template<class, class> class JCollection_t,
           class JResult_t   = typename JElement_t::ordinate_type,
           class JDistance_t = JDistance<typename JElement_t::abscissa_type> >
  class JPolintFunction1D :
    public JPolintFunction<N, JElement_t, JCollection_t, JResult_t, JDistance_t>,
    public JFunction1D<typename JElement_t::abscissa_type, JResult_t> 
  {
  public:

    typedef JCollection_t<JElement_t, JDistance_t>                               collection_type;

    typedef typename collection_type::abscissa_type                              abscissa_type;
    typedef typename collection_type::ordinate_type                              ordinate_type;
    typedef typename collection_type::value_type                                 value_type;
    typedef typename collection_type::distance_type                              distance_type;

    typedef typename collection_type::const_iterator                             const_iterator;
    typedef typename collection_type::const_reverse_iterator                     const_reverse_iterator;
    typedef typename collection_type::iterator                                   iterator;
    typedef typename collection_type::reverse_iterator                           reverse_iterator;

    typedef JFunction1D<abscissa_type, JResult_t>                                function_type;           

    typedef typename function_type::argument_type                                argument_type;
    typedef typename function_type::result_type                                  result_type;
    typedef typename function_type::JExceptionHandler                            exceptionhandler_type;


    /**
     * Default contructor.
     */
    JPolintFunction1D()
    {}
  };


  /**
   * Functional map with polynomial interpolation.
   */
  template<unsigned int N,
           class JKey_t,
           class JValue_t,
           template<class, class, class> class JMap_t,
           class JResult_t,
           class JDistance_t = JDistance<JKey_t> >
  class JPolintMap :
    public JPolintFunction<N, 
                           JElement2D<JKey_t, JValue_t>, 
                           JMapCollection<JMap_t>::template collection_type, 
                           JResult_t,
                           JDistance_t>
  {
  public:

    typedef JElement2D<JKey_t, JValue_t>                                         element_type;
    typedef JPolintFunction<N, 
                            element_type,
                            JMapCollection<JMap_t>::template collection_type,
                            JResult_t,
                            JDistance_t>                                         JPolintFunction_t;

    typedef typename JPolintFunction_t::abscissa_type                            abscissa_type;
    typedef typename JPolintFunction_t::ordinate_type                            ordinate_type;
    typedef typename JPolintFunction_t::value_type                               value_type;
    typedef typename JPolintFunction_t::distance_type                            distance_type;

    typedef typename JPolintFunction_t::const_iterator                           const_iterator;
    typedef typename JPolintFunction_t::const_reverse_iterator                   const_reverse_iterator;
    typedef typename JPolintFunction_t::iterator                                 iterator;
    typedef typename JPolintFunction_t::reverse_iterator                         reverse_iterator;

    typedef typename JPolintFunction_t::argument_type                            argument_type;
    typedef typename JPolintFunction_t::result_type                              result_type;
    typedef typename JPolintFunction_t::JExceptionHandler                        exceptionhandler_type;


    /**
     * Default constructor.
     */
    JPolintMap()
    {}
  };

                    
  /**
   * Conversion of data points to integral values.
   *
   * This method transfers the integration to the corresponding specialised function.
   *
   * \param  input             collection   
   * \param  output            mappable collection
   * \return                   integral
   */
  template<unsigned int N,
           class JElement_t,
           template<class, class> class JCollection_t,
           class JResult_t,
           class JDistance_t>
  inline typename JElement_t::ordinate_type
  integrate(const JPolintFunction1D<N, JElement_t, JCollection_t, JResult_t, JDistance_t>& input, 
            typename JMappable<JElement_t>::map_type&                                      output)
  {
    return integrate(input, output, JLANG::JBool<N == 0 || N == 1>());
  }


  /**
   * Conversion of data points to integral values.
   *
   * The integration uses the Gauss-Legendre quadratures with the number of points set
   * to the degree of the input polynomial interpolating function.
   *
   * \param  input             collection   
   * \param  output            mappable collection
   * \param  option            false
   * \return                   integral
   */
  template<unsigned int N,
           class JElement_t,
           template<class, class> class JCollection_t,
           class JResult_t,
           class JDistance_t>
  inline typename JElement_t::ordinate_type
  integrate(const JPolintFunction1D<N, JElement_t, JCollection_t, JResult_t, JDistance_t>& input, 
            typename JMappable<JElement_t>::map_type&                                      output,
            const JLANG::JBool<false>&                                                     option)
  {
    typedef typename JElement_t::abscissa_type                                                                abscissa_type;
    typedef typename JElement_t::ordinate_type                                                                ordinate_type;
    typedef typename JPolintFunction1D<N, JElement_t, JCollection_t, JResult_t, JDistance_t>::const_iterator  const_iterator;
    
    ordinate_type V(JMATH::zero);

    if (input.getSize() > 1) {
      
      output.put(input.begin()->getX(), V);
      
      const JGaussLegendre engine(N);
      
      for (const_iterator j = input.begin(), i = j++; j != input.end(); ++i, ++j) {
        
        const abscissa_type xmin = i->getX();
        const abscissa_type xmax = j->getX();
        
        for (JGaussLegendre::const_iterator m = engine.begin(); m != engine.end(); ++m) {
          
          const abscissa_type x = 0.5 * (xmax + xmin  +  m->getX() * (xmax - xmin));
          const ordinate_type v = 0.5 * (xmax - xmin) *  m->getY() * get_value(input(x));
          
          V += v;
        }
        
        output.put(xmax, V);
      }
    }
    
    return V;
  }
  
  
  /**
   * Conversion of data points to integral values.
   *
   * The integration is based on the sum of ordinates of the input data points.
   *
   * \param  input             collection   
   * \param  output            mappable collection
   * \param  option            true
   * \return                   integral
   */
  template<class JElement_t,
           template<class, class> class JCollection_t,
           class JResult_t,
           class JDistance_t>
  inline typename JElement_t::ordinate_type
  integrate(const JPolintFunction1D<0, JElement_t, JCollection_t, JResult_t, JDistance_t>& input, 
            typename JMappable<JElement_t>::map_type&                                      output,
            const JLANG::JBool<true>&                                                      option)
  {
    typedef typename JElement_t::ordinate_type                                                                ordinate_type;
    typedef typename JPolintFunction1D<0, JElement_t, JCollection_t, JResult_t, JDistance_t>::const_iterator  const_iterator;
    
    ordinate_type V(JMATH::zero);
    
    if (input.getSize() > 1) {
      
      output.put(input.begin()->getX(), V);
      
      for (const_iterator j = input.begin(), i = j++; j != input.end(); ++i, ++j) {
        
        V += input.getDistance(i->getX(), j->getX()) * j->getY();
        
        output.put(j->getX(), V);
      }
    }
    
    return V;
  }
  

  /**
   * Conversion of data points to integral values.
   *
   * The integration is based on the trapezoidal rule applied to the input data points.
   *
   * \param  input             collection   
   * \param  output            mappable collection
   * \param  option            true
   * \return                   integral
   */
  template<class JElement_t,
           template<class, class> class JCollection_t,
           class JResult_t,
           class JDistance_t>
  inline typename JElement_t::ordinate_type
  integrate(const JPolintFunction1D<1, JElement_t, JCollection_t, JResult_t, JDistance_t>& input, 
            typename JMappable<JElement_t>::map_type&                                      output,
            const JLANG::JBool<true>&                                                      option)
  {
    typedef typename JElement_t::ordinate_type                                                                ordinate_type;
    typedef typename JPolintFunction1D<1, JElement_t, JCollection_t, JResult_t, JDistance_t>::const_iterator  const_iterator;
    
    ordinate_type V(JMATH::zero);
    
    if (input.getSize() > 1) {
      
      output.put(input.begin()->getX(), V);
      
      for (const_iterator j = input.begin(), i = j++; j != input.end(); ++i, ++j) {
        
        V += 0.5 * input.getDistance(i->getX(), j->getX()) * (i->getY() + j->getY());
        
        output.put(j->getX(), V);
      }
    }
    
    return V;
  }
}

#endif