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 = (unsigned int)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 = static_cast<unsigned int>(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;
    }
 
 
    // ------------------------- Data ----------------------------------------
 
  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)