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/CUnsignedInteger.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((CInteger<Integer>));
    BOOST_CONCEPT_ASSERT((CUnsignedInteger<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)