AvnaimEtAl2x2DetSignComputer.h

 
#pragma once
 
#if defined(AvnaimEtAl2x2DetSignComputer_RECURSES)
#error Recursive header files inclusion detected in AvnaimEtAl2x2DetSignComputer.h
#else // defined(AvnaimEtAl2x2DetSignComputer_RECURSES)
#define AvnaimEtAl2x2DetSignComputer_RECURSES
 
#if !defined AvnaimEtAl2x2DetSignComputer_h
#define AvnaimEtAl2x2DetSignComputer_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/ExpressionTemplates.h"
 
#include "DGtal/kernel/NumberTraits.h"
#include "DGtal/kernel/CInteger.h"
#include "DGtal/kernel/CEuclideanRing.h"
#include "DGtal/kernel/CBoundedNumber.h"
 
namespace DGtal
{
 
  namespace detail
  {
 
    template <typename TNumber>
    struct EuclideanDivisionHelper
    {
      static TNumber compute(const TNumber& a, const TNumber& b)
      {
        BOOST_CONCEPT_ASSERT(( concepts::CInteger<TNumber> )); 
        return a / b; 
      }
    }; 
    //specialization for float and double
    template < >
    struct EuclideanDivisionHelper<float>
    {
      static float compute(const float& a, const float& b)
      {
        return std::floor(a / b); 
      }
    }; 
    template < >
    struct EuclideanDivisionHelper<double>
    {
      static double compute(const double& a, const double& b)
      {
        return std::floor(a / b); 
      }
    }; 
    template < >
    struct EuclideanDivisionHelper<long double>
    {
      static double compute(const double& a, const double& b)
      {
        return std::floor(a / b); 
      }
    }; 
  }
 
  // template class AvnaimEtAl2x2DetSignComputer
  template <typename TInteger>
  class AvnaimEtAl2x2DetSignComputer
  {
    // ----------------------- Types  ------------------------------------
  public:
    typedef TInteger ArgumentInteger; 
    BOOST_CONCEPT_ASSERT(( concepts::CEuclideanRing<ArgumentInteger> )); 
    BOOST_CONCEPT_ASSERT(( concepts::CBoundedNumber<ArgumentInteger> )); 
 
    typedef ArgumentInteger Integer; 
    typedef ArgumentInteger argument_type; 
 
    typedef Integer ResultInteger; 
    typedef ResultInteger Value; 
    typedef ResultInteger result_type;
 
    // ----------------------- Static members ---------------------------------
  public:
    BOOST_STATIC_CONSTANT( unsigned int, base = std::numeric_limits<Integer>::radix ); 
    BOOST_STATIC_CONSTANT( unsigned int, exponent = std::numeric_limits<Integer>::digits ); 
 
    // ----------------------- Standard services ------------------------------
  public:
    AvnaimEtAl2x2DetSignComputer(); 
 
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void init(const ArgumentInteger& aA, const ArgumentInteger& aB);
 
    ResultInteger operator()(const ArgumentInteger& aU, const ArgumentInteger& aV) const;
 
    ResultInteger operator()(const ArgumentInteger& aA, const ArgumentInteger& aB, 
                             const ArgumentInteger& aX, const ArgumentInteger& aY);
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Internals ------------------------------------
  private:
 
    int quadrant(const Integer& aX, const Integer& aY) const;  
 
    Integer computation(const Integer& aA, const Integer& aB, 
                        const Integer& aX, const Integer& aY) const;
 
    Integer recursiveComputation(const Integer& aA, const Integer& aB, 
                                 const Integer& aX, const Integer& aY) const;
 
    // ------------------------- Private Datas --------------------------------
  private:
 
    Integer myA; 
    Integer myB; 
    Integer myMax; 
 
  }; // end of class AvnaimEtAl2x2DetSignComputer
 
 
  template <typename TInteger>
  std::ostream&
  operator<< ( std::ostream & out, const AvnaimEtAl2x2DetSignComputer<TInteger> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/tools/determinant/AvnaimEtAl2x2DetSignComputer.ih"
 
//                                                                           //
 
#endif // !defined AvnaimEtAl2x2DetSignComputer_h
 
#undef AvnaimEtAl2x2DetSignComputer_RECURSES
#endif // else defined(AvnaimEtAl2x2DetSignComputer_RECURSES)