IntegerComputer.h

 
#pragma once
 
#if defined(IntegerComputer_RECURSES)
#error Recursive header files inclusion detected in IntegerComputer.h
#else // defined(IntegerComputer_RECURSES)
#define IntegerComputer_RECURSES
 
#if !defined IntegerComputer_h
#define IntegerComputer_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/NumberTraits.h"
#include "DGtal/kernel/CUnsignedNumber.h"
#include "DGtal/kernel/CIntegralNumber.h"
#include "DGtal/kernel/CInteger.h"
#include "DGtal/kernel/SpaceND.h"
 
namespace DGtal
{
 
  // template class IntegerComputer
  template <typename TInteger>
  class IntegerComputer
  {
    // ----------------------- Associated types ------------------------------
  public:
    typedef IntegerComputer<TInteger> Self;
    typedef typename NumberTraits<TInteger>::SignedVersion Integer;
    typedef typename NumberTraits<Integer>::ParamType IntegerParamType;
 
    typedef typename NumberTraits<TInteger>::UnsignedVersion UnsignedInteger;
    typedef typename NumberTraits<UnsignedInteger>::ParamType UnsignedIntegerParamType;
 
    typedef typename SpaceND<2,Integer>::Point Point2I;
    typedef typename SpaceND<2,Integer>::Vector Vector2I;
    typedef typename SpaceND<3,Integer>::Point Point3I;
    typedef typename SpaceND<3,Integer>::Vector Vector3I;
 
    BOOST_CONCEPT_ASSERT((concepts::CInteger<Integer>));
    BOOST_CONCEPT_ASSERT((concepts::CUnsignedNumber<UnsignedInteger>));
    BOOST_CONCEPT_ASSERT((concepts::CIntegralNumber<UnsignedInteger>));
 
    // ----------------------- Standard services ------------------------------
  public:
 
    ~IntegerComputer();
 
    IntegerComputer();
 
    IntegerComputer ( const Self & other );
 
    Self & operator= ( const Self & other );
 
 
    // ----------------------- Integer services ------------------------------
  public:
 
    static bool isZero( IntegerParamType a );
 
    static bool isNotZero( IntegerParamType a );
 
    static bool isPositive( IntegerParamType a );
 
    static bool isNegative( IntegerParamType a );
 
    static bool isPositiveOrZero( IntegerParamType a );
 
    static bool isNegativeOrZero( IntegerParamType a );
 
    static Integer abs( IntegerParamType a );
 
    static Integer max( IntegerParamType a, IntegerParamType b );
 
    static Integer max( IntegerParamType a, IntegerParamType b, IntegerParamType c );
 
    static Integer min( IntegerParamType a, IntegerParamType b );
 
    static Integer min( IntegerParamType a, IntegerParamType b, IntegerParamType c );
 
    void getEuclideanDiv( Integer & q, Integer & r,
                       IntegerParamType a, IntegerParamType b ) const;
 
    Integer floorDiv( IntegerParamType na, IntegerParamType nb ) const;
 
    Integer ceilDiv( IntegerParamType na, IntegerParamType nb ) const;
 
    void getFloorCeilDiv( Integer & fl, Integer & ce,
                          IntegerParamType na, IntegerParamType nb ) const;
 
    static Integer staticGcd( IntegerParamType a, IntegerParamType b );
 
    Integer gcd( IntegerParamType a, IntegerParamType b ) const;
 
    void getGcd( Integer & g, IntegerParamType a, IntegerParamType b ) const;
 
    Integer getCFrac( std::vector<Integer> & quotients,
                   IntegerParamType a, IntegerParamType b ) const;
    template <typename OutputIterator>
    Integer getCFrac( OutputIterator outIt,
                      IntegerParamType a, IntegerParamType b ) const;
 
    Point2I convergent( const std::vector<Integer> & quotients,
                        unsigned int k ) const;
 
    // ----------------------- Point2I services ------------------------------
  public:
    void reduce( Vector2I & p ) const ;
 
 
    Integer crossProduct( const Vector2I & u, const Vector2I & v) const;
 
    void getCrossProduct( Integer & cp, 
                          const Vector2I & u, const Vector2I & v) const;
 
    Integer dotProduct( const Vector2I & u, const Vector2I & v ) const;
 
    void getDotProduct( Integer & dp, 
                        const Vector2I & u, const Vector2I & v) const;
 
    Vector2I extendedEuclid( IntegerParamType a, IntegerParamType b, 
                             IntegerParamType c ) const;
 
    void getCoefficientIntersection( Integer & fl, Integer & ce,
                                     const Vector2I & p, 
                                     const Vector2I & u, 
                                     const Vector2I & N, 
                                     IntegerParamType c ) const;
                                  
    void getValidBezout ( Vector2I & v, 
                          const Point2I & A, const Vector2I & u,
                          const Vector2I & N, IntegerParamType c, 
                          const Vector2I & N2, IntegerParamType c2, 
                          bool compute_v = true ) const;
 
    // ----------------------- Point3I services ------------------------------
  public:
 
    void reduce( Vector3I & p ) const;
 
    Integer dotProduct( const Vector3I & u, const Vector3I & v) const;
 
    void getDotProduct( Integer & dp, 
                        const Vector3I & u, const Vector3I & v) const;
 
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:
 
    mutable Integer _m_a;
    mutable Integer _m_b;
    mutable Integer _m_a0;
    mutable Integer _m_a1;
    mutable Integer _m_q;
    mutable Integer _m_r;
    mutable std::vector<Integer> _m_bezout[ 4 ];
    mutable Vector2I _m_v;
    mutable Vector2I _m_v0;
    mutable Vector2I _m_v1;
    mutable Integer _m_c0;
    mutable Integer _m_c1;
    mutable Integer _m_c2;
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class IntegerComputer
 
 
  template <typename TInteger>
  std::ostream&
  operator<< ( std::ostream & out, const IntegerComputer<TInteger> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/arithmetic/IntegerComputer.ih"
 
//                                                                           //
 
#endif // !defined IntegerComputer_h
 
#undef IntegerComputer_RECURSES
#endif // else defined(IntegerComputer_RECURSES)