testLinearizer.cpp File Reference

#include <cstddef>
#include <cmath>
#include "DGtalCatch.h"
#include <DGtal/kernel/SpaceND.h>
#include <DGtal/kernel/domains/HyperRectDomain.h>
#include <DGtal/kernel/domains/Linearizer.h>

Include dependency graph for testLinearizer.cpp:

Go to the source code of this file.

Macros
#define	TEST_LINEARIZER(N, ORDER)
#define	BENCH_LINEARIZER(N, ORDER)

Detailed Description

This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author

Roland Denis (rolan.nosp@m.d.de.nosp@m.nis@u.nosp@m.niv-.nosp@m.smb.f.nosp@m.r )

Date

2015/09/10

This file is part of the DGtal library

Definition in file testLinearizer.cpp.

Macro Definition Documentation

BENCH_LINEARIZER

#define BENCH_LINEARIZER	(		N,
			ORDER )

Definition at line 245 of file testLinearizer.cpp.

#define BENCH_LINEARIZER( N , ORDER ) \
TEST_CASE( "Benchmarking Linearizer in dimension " #N " with " #ORDER, "[.bench][dim" #N "][" #ORDER "]" )\
{\
\
  typedef SpaceND<N>              Space;\
  typedef HyperRectDomain<Space>  Domain;\
  typedef Space::Point   Point;\
\
  typedef linearizer<Domain, N>   RefLinearizer;\
  typedef Linearizer<Domain, ORDER>   NewLinearizer;\
\
  typedef PointConverter<ORDER>   RefConverter;\
\
  std::size_t size = 1e8;\
\
  Point lowerBound;\
  for ( std::size_t i = 0 ; i < N ; ++i )\
    lowerBound[i] = 1 + 7*i;\
\
  std::size_t dim_size = std::size_t( std::pow( double(size), 1./N ) + 0.5 );\
  Point upperBound;\
  for ( std::size_t i = 0; i < N ; ++i )\
    upperBound[i] = lowerBound[i] + dim_size + i;\
\
  Domain domain( lowerBound, upperBound );\
  Point extent = upperBound - lowerBound + Point::diagonal(1);\
\
  Point refLowerBound = RefConverter::apply(lowerBound);\
  Point refExtent     = RefConverter::apply(extent);\
\
  std::size_t sum = 0;\
\
  for ( Domain::ConstIterator it = domain.begin(), it_end = domain.end(); it != it_end ; ++it )\
      sum += RefLinearizer::apply( RefConverter::apply(*it), refLowerBound, refExtent );\
  REQUIRE( sum > 0 );\
  sum = 0;\
\
  SECTION( "Benchmarking reference linearizer" )\
    {\
      for ( Domain::ConstIterator it = domain.begin(), it_end = domain.end(); it != it_end ; ++it )\
          sum += RefLinearizer::apply( RefConverter::apply(*it), refLowerBound, refExtent );\
    }\
\
  SECTION( "Benchmarking getIndex(Point, Point, Extent) syntax" )\
    {\
      for ( Domain::ConstIterator it = domain.begin(), it_end = domain.end(); it != it_end ; ++it )\
          sum += NewLinearizer::getIndex( *it, lowerBound, extent );\
    }\
\
  SECTION( "Benchmarking getIndex(Point, Extent) syntax" )\
    {\
      for ( Domain::ConstIterator it = domain.begin(), it_end = domain.end(); it != it_end ; ++it )\
          sum += NewLinearizer::getIndex( *it, extent );\
    }\
\
  SECTION( "Benchmarking getIndex(Point, Domain) syntax" )\
    {\
      for ( Domain::ConstIterator it = domain.begin(), it_end = domain.end(); it != it_end ; ++it )\
          sum += NewLinearizer::getIndex( *it, domain );\
    }\
\
  SECTION( "Benchmarking getPoint(Index, Point, Extent) syntax" )\
    {\
      for ( std::size_t i = 0; i < domain.size(); ++i )\
          sum += NewLinearizer::getPoint( i, lowerBound, extent )[N-1];\
    }\
\
  SECTION( "Benchmarking getPoint(Index, Extent) syntax" )\
    {\
      for ( std::size_t i = 0; i < domain.size(); ++i )\
          sum += NewLinearizer::getPoint( i, extent )[N-1];\
    }\
\
  SECTION( "Benchmarking getPoint(Index, Domain) syntax" )\
    {\
      for ( std::size_t i = 0; i < domain.size(); ++i )\
          sum += NewLinearizer::getPoint( i, domain )[N-1];\
    }\
\
  REQUIRE( sum > 0 );\
}

TEST_LINEARIZER

#define TEST_LINEARIZER	(		N,
			ORDER )

Definition at line 178 of file testLinearizer.cpp.

#define TEST_LINEARIZER( N , ORDER ) \
TEST_CASE( "Testing Linearizer in dimension " #N " with " #ORDER, "[test][dim" #N "][" #ORDER "]" )\
{\
\
  typedef SpaceND<N>              Space;\
  typedef HyperRectDomain<Space>  Domain;\
  typedef Space::Point   Point;\
\
  typedef linearizer<Domain, N>   RefLinearizer;\
  typedef Linearizer<Domain, ORDER>   NewLinearizer;\
\
  typedef PointConverter<ORDER>   RefConverter;\
\
  std::size_t size = 1e3;\
\
  Point lowerBound;\
  for ( std::size_t i = 0 ; i < N ; ++i )\
    lowerBound[i] = 1 + 7*i;\
\
  std::size_t dim_size = std::size_t( std::pow( double(size), 1./N ) + 0.5 );\
  Point upperBound;\
  for ( std::size_t i = 0; i < N ; ++i )\
    upperBound[i] = lowerBound[i] + dim_size + i;\
\
  Domain domain( lowerBound, upperBound );\
  Point extent = upperBound - lowerBound + Point::diagonal(1);\
\
  Point refLowerBound = RefConverter::apply(lowerBound);\
  Point refExtent     = RefConverter::apply(extent);\
\
  SECTION( "Testing getIndex(Point, Point, Extent) syntax" )\
    {\
      for ( Domain::ConstIterator it = domain.begin(), it_end = domain.end(); it != it_end ; ++it )\
          REQUIRE(  RefLinearizer::apply( RefConverter::apply(*it), refLowerBound, refExtent ) == NewLinearizer::getIndex( *it, lowerBound, extent )  );\
    }\
\
  SECTION( "Testing getIndex(Point, Extent) syntax" )\
    {\
      for ( Domain::ConstIterator it = domain.begin(), it_end = domain.end(); it != it_end ; ++it )\
          REQUIRE(  RefLinearizer::apply( RefConverter::apply(*it), refLowerBound, refExtent ) == NewLinearizer::getIndex( *it - lowerBound, extent )  );\
    }\
\
  SECTION( "Testing getIndex(Point, Domain) syntax" )\
    {\
      for ( Domain::ConstIterator it = domain.begin(), it_end = domain.end(); it != it_end ; ++it )\
          REQUIRE(  RefLinearizer::apply( RefConverter::apply(*it), refLowerBound, refExtent ) == NewLinearizer::getIndex( *it, domain )  );\
    }\
\
  SECTION( "Testing getPoint(Index, Point, Extent) syntax" )\
    {\
      for ( std::size_t i = 0; i < domain.size(); ++i )\
          REQUIRE(  RefLinearizer::apply( RefConverter::apply( NewLinearizer::getPoint( i, lowerBound, extent ) ), refLowerBound, refExtent ) == i  );\
    }\
\
  SECTION( "Testing getPoint(Index, Extent) syntax" )\
    {\
      for ( std::size_t i = 0; i < domain.size(); ++i )\
          REQUIRE(  RefLinearizer::apply( RefConverter::apply( NewLinearizer::getPoint( i, extent ) + lowerBound ), refLowerBound, refExtent ) == i  );\
    }\
\
  SECTION( "Testing getPoint(Index, Domain) syntax" )\
    {\
      for ( std::size_t i = 0; i < domain.size(); ++i )\
          REQUIRE(  RefLinearizer::apply( RefConverter::apply( NewLinearizer::getPoint( i, domain ) ), refLowerBound, refExtent ) == i  );\
    }\
}