Pattern.h

#pragma once

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

#define Pattern_RECURSES

#if !defined Pattern_h

#define Pattern_h

// Inclusions
#include <iostream>
#include <string>
#include "DGtal/base/Common.h"
#include "DGtal/arithmetic/CPositiveIrreducibleFraction.h"
#include "DGtal/arithmetic/IntegerComputer.h"
#include "DGtal/arithmetic/SternBrocot.h"

namespace DGtal
{

  // template class Pattern
  template <typename TFraction>
  class Pattern
  {
  public:
    typedef TFraction Fraction;
    BOOST_CONCEPT_ASSERT(( CPositiveIrreducibleFraction< Fraction > ));

    typedef Pattern<TFraction> Self;
    typedef typename Fraction::Integer Integer;
    typedef typename Fraction::Quotient Quotient;
    
    // BOOST_CONCEPT_ASSERT(( CInteger< Quotient > ));

    // ----------------------- associated types ------------------------------
  public:

    typedef IntegerComputer<Integer> IC;
    typedef typename IC::Point2I Point2I;
    typedef typename IC::Vector2I Vector2I;

    // ----------------------- Standard services ------------------------------
  public:

    ~Pattern();

    Pattern( Fraction f = Fraction( 0 ) );

    Pattern( Integer p, Integer q );

    Pattern ( const Pattern & other );

    Pattern & operator= ( const Pattern & other );

    // ----------------------- Pattern services -------------------------------
  public:

    std::string rE() const;

    std::string rEs( const std::string & seps = "(|)" ) const;

    Fraction slope() const;

    Integer length() const;

    Integer posU( Quotient k ) const;

    Integer posL( Quotient k ) const;

    Point2I U( Quotient k ) const;

    Point2I L( Quotient k ) const;

    Vector2I bezout() const;
    Vector2I v() const;

    Pattern previousPattern() const;


    bool
    getSmallestCoveringSubpattern( Pattern & subpattern,
                                   Quotient & nb,
                                   Vector2I & startPos,
                                   Integer posA, Integer posB,
                                   bool reversed = false ) const;

    bool
    getGreatestIncludedSubpattern( Pattern & subpattern,
                                   Quotient & nb,
                                   Vector2I & startPos,
                                   Integer posA, Integer posB,
                                   bool reversed = false ) const;

    // ----------------------- Interface --------------------------------------
  public:

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;

    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:

    Fraction mySlope;

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

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

  }; // end of class Pattern


  template <typename TFraction>
  std::ostream&
  operator<< ( std::ostream & out, const Pattern<TFraction> & object );

} // namespace DGtal


// Includes inline functions.
#include "DGtal/arithmetic/Pattern.ih"

//                                                                           //

#endif // !defined Pattern_h

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