OrderedLinearRegression.h

#pragma once

#if defined(OrderedLinearRegression_RECURSES)
#error Recursive header files inclusion detected in OrderedLinearRegression.h
#else // defined(OrderedLinearRegression_RECURSES)

#define OrderedLinearRegression_RECURSES

#if !defined OrderedLinearRegression_h

#define OrderedLinearRegression_h


#include <iostream>
#include <vector>
#include "DGtal/math/SimpleLinearRegression.h"
namespace DGtal
{
  // class OrderedLinearRegression

  class OrderedLinearRegression
  {
    // ----------------------- Standard services ------------------------------
  public:
    
    ~OrderedLinearRegression()
    {}
    
    OrderedLinearRegression( double eps_zero = 1e-8 ):
      myEpsilonZero(eps_zero),
      myN(0)
    {}

    void clear()
    {
      myX.clear();
      myY.clear();
      myN = 0;
    }

    template <class XIterator, class YIterator>
    void addSamples( XIterator begin_x, XIterator end_x, YIterator begin_y )
      {
        for ( ; begin_x != end_x; ++begin_x, ++begin_y )
          {
            addSample( *begin_x, *begin_y );
          }
      }


    void addSample( const double x, const double y )
    {
      myX.push_back( x );
      myY.push_back( y );
      ++myN;
    }


    // ----------------------- Interface --------------------------------------
    void forwardSLR(SimpleLinearRegression &linearModel,
                    const unsigned int n = 4,
                    const double alpha = 0.01) const
    {
      linearModel.setEpsilonZero(myEpsilonZero);
      linearModel.clear();
      std::vector<double>::const_iterator itx = myX.begin(); 
      std::vector<double>::const_iterator itxe = myX.end(); 
      std::vector<double>::const_iterator ity = myY.begin(); 
      linearModel.addSamples( itx, itx + n, ity );
      linearModel.computeRegression();
      itx += n;
      ity += n;
      unsigned int l = myX.size() - n + 1;
      for ( ; itx != itxe; ++itx, ++ity, --l )
        {
          std::pair<double,double> ic;
          ic = linearModel.trustIntervalForY( *itx, alpha );
          if ( ( *ity < ic.first ) || ( *ity > ic.second ) )
            break;
          linearModel.addSample( *itx, *ity );
          linearModel.computeRegression();
        }
    }

    
    void backwardSLR(SimpleLinearRegression &linearModel,
                     const unsigned int n = 4,
                     const double alpha = 0.01 ) const
    {
      linearModel.setEpsilonZero(myEpsilonZero);
      linearModel.clear();
      std::vector<double>::const_reverse_iterator itx = myX.rbegin(); 
      std::vector<double>::const_reverse_iterator itxe = myX.rend(); 
      std::vector<double>::const_reverse_iterator ity = myY.rbegin(); 
      linearModel.addSamples( itx, itx + n, ity );
      linearModel.computeRegression();
      itx += n;
      ity += n;
      unsigned int l = myX.size() - n + 1;
      for ( ; itx != itxe; ++itx, ++ity, --l )
        {
          std::pair<double,double> ic;
          ic = linearModel.trustIntervalForY( *itx, alpha );
          if ( ( *ity < ic.first ) || ( *ity > ic.second ) )
            break;
          linearModel.addSample( *itx, *ity );
          linearModel.computeRegression();
        }
    }
    
    // ----------------------- Interface --------------------------------------
  public:

    void selfDisplay( std::ostream & that_stream ) const
    {
      that_stream << "[OrderedLinearRegression]  Number of samples="<< myN;
    }
    
    bool isValid() const
    {
      return true;
    }


    // ------------------------- Datas ----------------------------------------

  private:

    double myEpsilonZero;

    unsigned int myN;

    std::vector<double> myY;
    
    std::vector<double> myX;
   

    // ------------------------- Hidden services ------------------------------
  protected:

  private:

    OrderedLinearRegression( const OrderedLinearRegression & other );

     OrderedLinearRegression & operator=( const OrderedLinearRegression & other );

    // ------------------------- Internals ------------------------------------
  private:


  };

  std::ostream&
  operator<<( std::ostream & that_stream,
              const OrderedLinearRegression & that_object_to_display );


} // namespace DGtal

//                                                                           //
#endif // !defined OrderedLinearRegression_h

#undef OrderedLinearRegression_RECURSES
#endif // else defined(OrderedLinearRegression_RECURSES)