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 Data --------------------------------
  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)