CPositiveIrreducibleFraction.h

#pragma once

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

#define CPositiveIrreducibleFraction_RECURSES

#if !defined CPositiveIrreducibleFraction_h

#define CPositiveIrreducibleFraction_h

// Inclusions
#include <iostream>
#include <vector>
#include "DGtal/base/Common.h"
#include "DGtal/base/CBackInsertable.h"
#include "DGtal/base/CConstSinglePassRange.h"
#include "DGtal/kernel/CInteger.h"
#include "DGtal/kernel/CSignedInteger.h"

namespace DGtal
{

// class CPositiveIrreducibleFraction
template <typename T>
struct CPositiveIrreducibleFraction 
  : boost::CopyConstructible<T>, boost::DefaultConstructible<T>, boost::Assignable<T>, DGtal::CBackInsertable<T>, DGtal::CConstSinglePassRange<T>

{
    // ----------------------- Concept checks ------------------------------
public:
  typedef typename T::Integer Integer;
  typedef typename T::Quotient Quotient;
  typedef typename T::value_type value_type;
  typedef typename T::Value Value;
  typedef typename T::ConstIterator ConstIterator;
  typedef typename T::const_iterator const_iterator;

  BOOST_CONCEPT_ASSERT(( CInteger< Integer > ));
  BOOST_CONCEPT_ASSERT(( CSignedInteger< Quotient > ));
  BOOST_STATIC_ASSERT(( ConceptUtils::SameType<value_type, std::pair<Quotient,Quotient> >::value ));
  BOOST_STATIC_ASSERT(( ConceptUtils::SameType<value_type, Value >::value ));

  BOOST_CONCEPT_USAGE( CPositiveIrreducibleFraction )
  {
    ConceptUtils::sameType( myX, T( myP, myQ ) );
    myX.push_back( myValue );
    myX.pushBack( myValue );
    checkConstConstraints();
  }
  void checkConstConstraints() const
  {
    ConceptUtils::sameType( myP, myX.p() );
    ConceptUtils::sameType( myQ, myX.q() );
    ConceptUtils::sameType( myU, myX.u() );
    ConceptUtils::sameType( myU, myX.k() );
    ConceptUtils::sameType( myBool, myX.null() );
    ConceptUtils::sameType( myX, myX.left() );
    ConceptUtils::sameType( myX, myX.right() );
    ConceptUtils::sameType( myBool, myX.even() );
    ConceptUtils::sameType( myBool, myX.odd() );
    ConceptUtils::sameType( myX, myX.father() );
    ConceptUtils::sameType( myX, myX.father( myU ) );
    ConceptUtils::sameType( myX, myX.previousPartial() );
    ConceptUtils::sameType( myX, myX.inverse() );
    ConceptUtils::sameType( myX, myX.partial( myU ) );
    ConceptUtils::sameType( myX, myX.reduced( myU ) );
    myX.getSplit( myF1, myF2 );
    myX.getSplitBerstel( myF1, myN1, myF2, myN2 );
    myX.getCFrac( myQuots );
    ConceptUtils::sameType( myBool, myX.equals( myP, myQ ) );
    ConceptUtils::sameType( myBool, myX.lessThan( myP, myQ ) );
    ConceptUtils::sameType( myBool, myX.moreThan( myP, myQ ) );
    ConceptUtils::sameType( myBool, myX == myY );
    ConceptUtils::sameType( myBool, myX != myY );
    ConceptUtils::sameType( myBool, myX < myY );
    ConceptUtils::sameType( myBool, myX > myY );
    ConceptUtils::sameType( myIterator, myX.begin() );
    ConceptUtils::sameType( myIterator, myX.end() );
  }
  // ------------------------- Private Datas --------------------------------
private:
  T myX; // do not require T to be default constructible.
  T myY; // do not require T to be default constructible.
  Integer myP;
  Integer myQ;
  Quotient myU;
  bool myBool;
  mutable Quotient myN1;
  mutable Quotient myN2;
  mutable T myF1; 
  mutable T myF2; 
  mutable std::vector<Quotient> myQuots; 
  std::pair<Quotient,Quotient> myValue;
  ConstIterator myIterator;
  // ------------------------- Internals ------------------------------------
private:

}; // end of concept CPositiveIrreducibleFraction

} // namespace DGtal

//                                                                           //

#endif // !defined CPositiveIrreducibleFraction_h

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