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(( concepts::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 Data ------------------------------
  private:
    // ------------------------- Private Data --------------------------------
  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)