test2x2DetComputers.cpp

Go to the documentation of this file.

#include <iostream>
#include "DGtal/base/Common.h"
 
#include "DGtal/kernel/NumberTraits.h"
#include "DGtal/geometry/tools/determinant/C2x2DetComputer.h"
#include "DGtal/geometry/tools/determinant/Simple2x2DetComputer.h"
#include "DGtal/geometry/tools/determinant/SimpleIncremental2x2DetComputer.h"
#include "DGtal/geometry/tools/determinant/AvnaimEtAl2x2DetSignComputer.h"
#include "DGtal/geometry/tools/determinant/Filtered2x2DetComputer.h"
 
using namespace std;
using namespace DGtal;

// Functions for testing various model of CIncremental2x2DeterminantComputer

template<typename DetComputer>
bool simpleTest2x2DetComputer(DetComputer aComputer)
{
  BOOST_CONCEPT_ASSERT(( C2x2DetComputer<DetComputer> ));
  typedef typename DetComputer::Integer Integer;
  typedef typename DetComputer::Value Value;
 
  unsigned int nbok = 0;
  unsigned int nb = 0;
 
  trace.beginBlock ( "Testing block ..." );
  trace.info() << aComputer << endl;
 
  Integer a = 5;
  Integer b = 2;
 
 
  //first quadrant
  aComputer.init(a,b);
  if (aComputer(2,1) == NumberTraits<Value>::ONE)
    nbok++;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << endl;
 
  if (aComputer(3,1) == -NumberTraits<Value>::ONE)
    nbok++;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << endl;
 
  if (aComputer(5,2) == NumberTraits<Value>::ZERO)
    nbok++;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << endl;
 
  //second quadrant
  aComputer.init(-a,b);
  if (aComputer(2,-1) == NumberTraits<Value>::ONE)
    nbok++;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << endl;
 
  if (aComputer(3,-1) == -NumberTraits<Value>::ONE)
    nbok++;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << endl;
 
  if (aComputer(5,-2) == NumberTraits<Value>::ZERO)
    nbok++;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << endl;
 
  //third quadrant
  aComputer.init(-a,-b);
  if (aComputer(-2,-1) == NumberTraits<Value>::ONE)
    nbok++;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << endl;
 
  if (aComputer(-3,-1) == -NumberTraits<Value>::ONE)
    nbok++;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << endl;
 
  if (aComputer(-5,-2) == NumberTraits<Value>::ZERO)
    nbok++;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << endl;
 
  //fourth quadrant
  aComputer.init(a,-b);
  if (aComputer(-2,1) == NumberTraits<Value>::ONE)
    nbok++;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << endl;
 
  if (aComputer(-3,1) == -NumberTraits<Value>::ONE)
    nbok++;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << endl;
 
  if (aComputer(-5,2) == NumberTraits<Value>::ZERO)
    nbok++;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << endl;
 
  trace.endBlock();
 
  return nbok == nb;
}

template <typename I1, typename I2>
bool hasTheSameSign(I1 x1, I2 x2)
{
  if (x1 == NumberTraits<I1>::ZERO)
    {
      if (x2 == NumberTraits<I2>::ZERO)
        return true;
      else
        return false;
    }
  else if (x1 > NumberTraits<I1>::ZERO)
    {
      if (x2 > NumberTraits<I2>::ZERO)
        return true;
      else
        return false;
    }
  else //if (x1 < NumberTraits<I1>::ZERO)
    {
      if (x2 < NumberTraits<I2>::ZERO)
        return true;
      else
        return false;
    }
}
 
DGtal::int32_t randomBelow2exp15 ()
{
  return static_cast<DGtal::int32_t>(rand() % 32768);
}
DGtal::int32_t adHocRandom ()
{
  DGtal::int32_t x = randomBelow2exp15() +
    32768 * ( randomBelow2exp15() );
    return ((rand() % 2) ? x : -x);
}

template<typename DetComputer>
bool randomTest2x2DetComputer(DetComputer aComputer)
{
  BOOST_CONCEPT_ASSERT(( C2x2DetComputer<DetComputer> ));
 
  typedef Simple2x2DetComputer<DGtal::int32_t, DGtal::int64_t> TrueComputer;
  TrueComputer trueComputer;
 
  trace.beginBlock ( "Testing block ..." );
  trace.info() << trueComputer << " vs " << aComputer << endl;
 
  bool isOk = true;
 
  DGtal::int32_t a, b, x, y;
 
  const int n = 10000;
  for (int i = 0; ( (i < n)&&(isOk) ); ++i)
    {
      a = adHocRandom();
      b = adHocRandom();
      x = adHocRandom();
      y = adHocRandom();
      trueComputer.init(a, b);
      aComputer.init(a, b);
      TrueComputer::Value trueRes = trueComputer(x,y);
      typename DetComputer::Value res = aComputer(x,y);
      // trace.info() << a << "." << y << " - "
      //                   << b << " " << x << " => "
      //                   << trueRes << " / " << res << endl;
      if ( !hasTheSameSign( trueRes, res ) )
        isOk = false;
    }
 
  trace.endBlock();
 
  return isOk;
}

// Standard services - public :
 
int main( int argc, char** argv )
{
  trace.beginBlock ( "Testing class 2x2DetComputers" );
  trace.info() << "Args:";
  for ( int i = 0; i < argc; ++i )
    trace.info() << " " << argv[ i ];
  trace.info() << endl;
 
  bool res = true;
 
 
  res = res
    && simpleTest2x2DetComputer( Simple2x2DetComputer<DGtal::int16_t, DGtal::int32_t>() )
    && simpleTest2x2DetComputer( Simple2x2DetComputer<DGtal::int32_t, DGtal::int64_t>() )
    && simpleTest2x2DetComputer( Simple2x2DetComputer<DGtal::int32_t, DGtal::BigInteger>() )
    && simpleTest2x2DetComputer( SimpleIncremental2x2DetComputer<DGtal::int16_t, DGtal::int32_t>() )
    && simpleTest2x2DetComputer( SimpleIncremental2x2DetComputer<DGtal::int32_t, DGtal::int64_t>() )
    && simpleTest2x2DetComputer( SimpleIncremental2x2DetComputer<DGtal::int32_t, DGtal::BigInteger>() )
    && simpleTest2x2DetComputer( AvnaimEtAl2x2DetSignComputer<DGtal::int16_t>() )
    && simpleTest2x2DetComputer( AvnaimEtAl2x2DetSignComputer<DGtal::int32_t>() )
    && simpleTest2x2DetComputer( AvnaimEtAl2x2DetSignComputer<float>() )
    && simpleTest2x2DetComputer( AvnaimEtAl2x2DetSignComputer<double>() )
    && simpleTest2x2DetComputer( Filtered2x2DetComputer<AvnaimEtAl2x2DetSignComputer<double> >() )
 
    && randomTest2x2DetComputer( Simple2x2DetComputer<DGtal::int32_t, DGtal::BigInteger>() )
    && randomTest2x2DetComputer( SimpleIncremental2x2DetComputer<DGtal::int32_t, DGtal::BigInteger>() )
    && randomTest2x2DetComputer( AvnaimEtAl2x2DetSignComputer<DGtal::int32_t>() )
    && randomTest2x2DetComputer( Filtered2x2DetComputer<AvnaimEtAl2x2DetSignComputer<double> >() )
    ;
 
  trace.emphase() << ( res ? "Passed." : "Error." ) << endl;
  trace.endBlock();
  return res ? 0 : 1;
}
//                                                                           //