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/CBackInsertable.h"
#include "DGtal/base/CConstSinglePassRange.h"
#include "DGtal/kernel/CInteger.h"
 
namespace DGtal
{
 
  namespace concepts
  {

// class CPositiveIrreducibleFraction
template <typename T>
struct CPositiveIrreducibleFraction
  : boost::CopyConstructible<T>, boost::DefaultConstructible<T>, boost::Assignable<T>, CBackInsertable<T>, 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(( concepts::CInteger< Integer > ));
  BOOST_CONCEPT_ASSERT(( concepts::CInteger< Quotient > ));
  BOOST_STATIC_ASSERT(( concepts::ConceptUtils::SameType<value_type, std::pair<Quotient,Quotient> >::value ));
  BOOST_STATIC_ASSERT(( concepts::ConceptUtils::SameType<value_type, Value >::value ));
 
  BOOST_CONCEPT_USAGE( CPositiveIrreducibleFraction )
  {
    concepts::ConceptUtils::sameType( myX, T( myP, myQ ) );
    myX.push_back( myValue );
    myX.pushBack( myValue );
    checkConstConstraints();
  }
  void checkConstConstraints() const
  {
    concepts::ConceptUtils::sameType( myP, myX.p() );
    concepts::ConceptUtils::sameType( myQ, myX.q() );
    concepts::ConceptUtils::sameType( myU, myX.u() );
    concepts::ConceptUtils::sameType( myU, myX.k() );
    concepts::ConceptUtils::sameType( myBool, myX.null() );
    concepts::ConceptUtils::sameType( myX, myX.left() );
    concepts::ConceptUtils::sameType( myX, myX.right() );
    concepts::ConceptUtils::sameType( myBool, myX.even() );
    concepts::ConceptUtils::sameType( myBool, myX.odd() );
    concepts::ConceptUtils::sameType( myX, myX.father() );
    concepts::ConceptUtils::sameType( myX, myX.father( myU ) );
    concepts::ConceptUtils::sameType( myX, myX.previousPartial() );
    concepts::ConceptUtils::sameType( myX, myX.inverse() );
    concepts::ConceptUtils::sameType( myX, myX.partial( myU ) );
    concepts::ConceptUtils::sameType( myX, myX.reduced( myU ) );
    myX.getSplit( myF1, myF2 );
    myX.getSplitBerstel( myF1, myN1, myF2, myN2 );
    myX.getCFrac( myQuots );
    concepts::ConceptUtils::sameType( myBool, myX.equals( myP, myQ ) );
    concepts::ConceptUtils::sameType( myBool, myX.lessThan( myP, myQ ) );
    concepts::ConceptUtils::sameType( myBool, myX.moreThan( myP, myQ ) );
    concepts::ConceptUtils::sameType( myBool, myX == myY );
    concepts::ConceptUtils::sameType( myBool, myX != myY );
    concepts::ConceptUtils::sameType( myBool, myX < myY );
    concepts::ConceptUtils::sameType( myBool, myX > myY );
    concepts::ConceptUtils::sameType( myIterator, myX.begin() );
    concepts::ConceptUtils::sameType( myIterator, myX.end() );
  }
  // ------------------------- Private Data --------------------------------
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 concepts
 
} // namespace DGtal
 
//                                                                           //
 
#endif // !defined CPositiveIrreducibleFraction_h
 
#undef CPositiveIrreducibleFraction_RECURSES
#endif // else defined(CPositiveIrreducibleFraction_RECURSES)