main.h File Reference

#include <cstdlib>
#include <cerrno>
#include <ctime>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <sstream>
#include <vector>
#include <typeinfo>
#include <type_traits>
#include <functional>
#include <limits>
#include <algorithm>
#include <complex>
#include <deque>
#include <queue>
#include <cassert>
#include <list>
#include "split_test_helper.h"
#include <Eigen/QR>
#include "random_matrix_helper.h"
#include "gpu_test_helper.h"

Go to the source code of this file.

Classes
struct	real
struct	imag
class	Eigen::EigenTest
struct	Eigen::eigen_assert_exception
struct	Eigen::eigen_static_assert_exception
struct	GetDifferentType< float >
struct	GetDifferentType< double >
struct	GetDifferentType< std::complex< T > >

Namespaces
	Eigen
	Namespace containing all symbols from the Eigen library.

Macros
#define	_OVERRIDE_COMPLEX_SPECIALIZATION_   1
#define	min(A, B)   please_protect_your_min_with_parentheses
#define	max(A, B)   please_protect_your_max_with_parentheses
#define	isnan(X)   please_protect_your_isnan_with_parentheses
#define	isinf(X)   please_protect_your_isinf_with_parentheses
#define	isfinite(X)   please_protect_your_isfinite_with_parentheses
#define	M_PI   please_use_EIGEN_PI_instead_of_M_PI
#define	FORBIDDEN_IDENTIFIER    (this_identifier_is_forbidden_to_avoid_clashes) this_identifier_is_forbidden_to_avoid_clashes
#define	B0   FORBIDDEN_IDENTIFIER
#define	I   FORBIDDEN_IDENTIFIER
#define	_res   FORBIDDEN_IDENTIFIER
#define	EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
#define	TEST_SET_BUT_UNUSED_VARIABLE(X)   EIGEN_UNUSED_VARIABLE(X)
#define	DEBUG
#define	DEFAULT_REPEAT   10
#define	EIGEN_DECLARE_TEST(X)
#define	TRACK   std::cerr << __FILE__ << " " << __LINE__ << std::endl
#define	EIGEN_DEFAULT_IO_FORMAT   IOFormat(4, 0, " ", "\n", "", "", "", "")
#define	eigen_assert(a)
#define	VERIFY_RAISES_ASSERT(a)   std::cout << "Can't VERIFY_RAISES_ASSERT( " #a " ) with exceptions disabled\n";
#define	EIGEN_USE_CUSTOM_ASSERT
#define	EIGEN_INTERNAL_DEBUGGING
#define	VERIFY(a)   ::verify_impl(a, g_test_stack.back().c_str(), __FILE__, __LINE__, EIGEN_MAKESTRING(a))
#define	VERIFY_GE(a, b)   ::verify_impl(a >= b, g_test_stack.back().c_str(), __FILE__, __LINE__, EIGEN_MAKESTRING(a >= b))
#define	VERIFY_LE(a, b)   ::verify_impl(a <= b, g_test_stack.back().c_str(), __FILE__, __LINE__, EIGEN_MAKESTRING(a <= b))
#define	VERIFY_IS_EQUAL(a, b)   VERIFY(test_is_equal(a, b, true))
#define	VERIFY_IS_NOT_EQUAL(a, b)   VERIFY(test_is_equal(a, b, false))
#define	VERIFY_IS_APPROX(a, b)   VERIFY(verifyIsApprox(a, b))
#define	VERIFY_IS_NOT_APPROX(a, b)   VERIFY(!test_isApprox(a, b))
#define	VERIFY_IS_MUCH_SMALLER_THAN(a, b)   VERIFY(test_isMuchSmallerThan(a, b))
#define	VERIFY_IS_NOT_MUCH_SMALLER_THAN(a, b)   VERIFY(!test_isMuchSmallerThan(a, b))
#define	VERIFY_IS_APPROX_OR_LESS_THAN(a, b)   VERIFY(test_isApproxOrLessThan(a, b))
#define	VERIFY_IS_NOT_APPROX_OR_LESS_THAN(a, b)   VERIFY(!test_isApproxOrLessThan(a, b))
#define	VERIFY_IS_CWISE_EQUAL(a, b)   VERIFY(verifyIsCwiseApprox(a, b, true))
#define	VERIFY_IS_CWISE_APPROX(a, b)   VERIFY(verifyIsCwiseApprox(a, b, false))
#define	VERIFY_IS_UNITARY(a)   VERIFY(test_isUnitary(a))
#define	STATIC_CHECK(COND)   EIGEN_STATIC_ASSERT((COND), EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT)
#define	CALL_SUBTEST(FUNC)
#define	EIGEN_TEST_SCALAR_TEST_OVERLOAD(TYPE)

Functions
void	verify_impl (bool condition, const char *testname, const char *file, int line, const char *condition_as_string)
template<typename T1 , typename T2 >
std::enable_if_t< internal::is_same< T1, T2 >::value, bool >	Eigen::is_same_type (const T1 &, const T2 &)
template<typename T >
NumTraits< T >::Real	Eigen::test_precision ()
template<>
float	Eigen::test_precision< float > ()
template<>
double	Eigen::test_precision< double > ()
template<>
long double	Eigen::test_precision< long double > ()
template<>
float	Eigen::test_precision< std::complex< float > > ()
template<>
double	Eigen::test_precision< std::complex< double > > ()
template<>
long double	Eigen::test_precision< std::complex< long double > > ()
bool	Eigen::test_isApprox (const std::complex< float > &a, const std::complex< float > &b)
bool	Eigen::test_isMuchSmallerThan (const std::complex< float > &a, const std::complex< float > &b)
bool	Eigen::test_isApprox (const std::complex< double > &a, const std::complex< double > &b)
bool	Eigen::test_isMuchSmallerThan (const std::complex< double > &a, const std::complex< double > &b)
bool	Eigen::test_isApprox (const std::complex< long double > &a, const std::complex< long double > &b)
bool	Eigen::test_isMuchSmallerThan (const std::complex< long double > &a, const std::complex< long double > &b)
bool	Eigen::test_isApprox (const long double &a, const long double &b)
bool	Eigen::test_isMuchSmallerThan (const long double &a, const long double &b)
bool	Eigen::test_isApproxOrLessThan (const long double &a, const long double &b)
template<typename T1 , typename T2 >
NumTraits< typename T1::RealScalar >::NonInteger	Eigen::test_relative_error (const EigenBase< T1 > &a, const EigenBase< T2 > &b)
template<typename T1 , typename T2 >
T1::RealScalar	Eigen::test_relative_error (const T1 &a, const T2 &b, const typename T1::Coefficients *=0)
template<typename T1 , typename T2 >
T1::Scalar	Eigen::test_relative_error (const T1 &a, const T2 &b, const typename T1::MatrixType *=0)
template<typename S , int D>
S	Eigen::test_relative_error (const Translation< S, D > &a, const Translation< S, D > &b)
template<typename S , int D, int O>
S	Eigen::test_relative_error (const ParametrizedLine< S, D, O > &a, const ParametrizedLine< S, D, O > &b)
template<typename S , int D>
S	Eigen::test_relative_error (const AlignedBox< S, D > &a, const AlignedBox< S, D > &b)
template<typename T1 , typename T2 >
T1::RealScalar	Eigen::test_relative_error (const MatrixBase< T1 > &a, const SparseMatrixBase< T2 > &b)
template<typename T1 , typename T2 >
T1::RealScalar	Eigen::test_relative_error (const SparseMatrixBase< T1 > &a, const MatrixBase< T2 > &b)
template<typename T1 , typename T2 >
T1::RealScalar	Eigen::test_relative_error (const SparseMatrixBase< T1 > &a, const SparseMatrixBase< T2 > &b)
template<typename T1 , typename T2 >
NumTraits< typename NumTraits< T1 >::Real >::NonInteger	Eigen::test_relative_error (const T1 &a, const T2 &b, std::enable_if_t< internal::is_arithmetic< typename NumTraits< T1 >::Real >::value, T1 > *=0)
template<typename T >
T	Eigen::test_relative_error (const Rotation2D< T > &a, const Rotation2D< T > &b)
template<typename T >
T	Eigen::test_relative_error (const AngleAxis< T > &a, const AngleAxis< T > &b)
template<typename Type1 , typename Type2 >
bool	Eigen::test_isApprox (const Type1 &a, const Type2 &b, typename Type1::Scalar *=0)
template<typename T >
NumTraits< typename T::Scalar >::Real	Eigen::get_test_precision (const T &, const typename T::Scalar *=0)
template<typename T >
NumTraits< T >::Real	Eigen::get_test_precision (const T &, std::enable_if_t< internal::is_arithmetic< typename NumTraits< T >::Real >::value, T > *=0)
template<typename Type1 , typename Type2 >
bool	Eigen::verifyIsApprox (const Type1 &a, const Type2 &b)
template<typename Type1 , typename Type2 >
bool	Eigen::verifyIsCwiseApprox (const Type1 &a, const Type2 &b, bool exact)
template<typename Scalar , typename ScalarRef >
bool	Eigen::test_isApproxWithRef (const Scalar &a, const Scalar &b, const ScalarRef &ref)
template<typename Derived1 , typename Derived2 >
bool	Eigen::test_isMuchSmallerThan (const MatrixBase< Derived1 > &m1, const MatrixBase< Derived2 > &m2)
template<typename Derived >
bool	Eigen::test_isMuchSmallerThan (const MatrixBase< Derived > &m, const typename NumTraits< typename internal::traits< Derived >::Scalar >::Real &s)
template<typename Derived >
bool	Eigen::test_isUnitary (const MatrixBase< Derived > &m)
template<typename Derived1 , typename Derived2 >
bool	Eigen::test_isCwiseApprox (const DenseBase< Derived1 > &m1, const DenseBase< Derived2 > &m2, bool exact)
template<typename Derived1 , typename Derived2 >
bool	Eigen::test_isCwiseApprox (const SparseMatrixBase< Derived1 > &m1, const SparseMatrixBase< Derived2 > &m2, bool exact)
template<typename T , typename U >
bool	Eigen::test_is_equal (const T &actual, const U &expected, bool expect_equal)
template<typename T >
bool	Eigen::isNotNaN (const T &x)
template<typename T >
bool	Eigen::isPlusInf (const T &x)
template<typename T >
bool	Eigen::isMinusInf (const T &x)
template<typename T >
std::string	type_name (T)
template<>
std::string	type_name< float > (float)
template<>
std::string	type_name< double > (double)
template<>
std::string	type_name< long double > (long double)
template<>
std::string	type_name< Eigen::half > (Eigen::half)
template<>
std::string	type_name< Eigen::bfloat16 > (Eigen::bfloat16)
template<>
std::string	type_name< int8_t > (int8_t)
template<>
std::string	type_name< int16_t > (int16_t)
template<>
std::string	type_name< int32_t > (int32_t)
template<>
std::string	type_name< int64_t > (int64_t)
template<>
std::string	type_name< uint8_t > (uint8_t)
template<>
std::string	type_name< uint16_t > (uint16_t)
template<>
std::string	type_name< uint32_t > (uint32_t)
template<>
std::string	type_name< uint64_t > (uint64_t)
template<>
std::string	type_name< std::complex< float > > (std::complex< float >)
template<>
std::string	type_name< std::complex< double > > (std::complex< double >)
template<>
std::string	type_name< std::complex< long double > > (std::complex< long double >)
template<>
std::string	type_name< std::complex< int > > (std::complex< int >)
template<typename T >
std::string	type_name ()
void	set_repeat_from_string (const char *str)
void	set_seed_from_string (const char *str)
int	main (int argc, char *argv[])

Variables
static std::vector< std::string >	Eigen::g_test_stack
static int	Eigen::g_test_level = 0
static int	Eigen::g_repeat = 1
static unsigned int	Eigen::g_seed = 0
static bool	Eigen::g_has_set_repeat = false
static bool	Eigen::g_has_set_seed = false
static const bool	Eigen::should_raise_an_assert = false
static bool	Eigen::no_more_assert = false
static bool	Eigen::report_on_cerr_on_assert_failure = true

Macro Definition Documentation

_OVERRIDE_COMPLEX_SPECIALIZATION_

#define _OVERRIDE_COMPLEX_SPECIALIZATION_   1

_res

#define _res   FORBIDDEN_IDENTIFIER

B0

#define B0   FORBIDDEN_IDENTIFIER

CALL_SUBTEST

#define CALL_SUBTEST

(

FUNC

)

Value:

  do {                                              \
    g_test_stack.push_back(EIGEN_MAKESTRING(FUNC)); \
    FUNC;                                           \
    g_test_stack.pop_back();                        \
  } while (0)

DEBUG

#define DEBUG

DEFAULT_REPEAT

#define DEFAULT_REPEAT   10

eigen_assert

#define eigen_assert

(

a

)

Value:

  if ((!(a)) && (!no_more_assert)) {                  \
    Eigen::no_more_assert = true;                     \
    if (report_on_cerr_on_assert_failure) {           \
      eigen_plain_assert(a);                          \
    } else {                                          \
      EIGEN_THROW_X(Eigen::eigen_assert_exception()); \
    }                                                 \
  }

EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS

#define EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS

EIGEN_DECLARE_TEST

#define EIGEN_DECLARE_TEST

(

X

)

Value:

  void EIGEN_CAT(test_, X)();                                                              \
  static EigenTest EIGEN_CAT(test_handler_, X)(EIGEN_MAKESTRING(X), &EIGEN_CAT(test_, X)); \
  void EIGEN_CAT(test_, X)()

EIGEN_DEFAULT_IO_FORMAT

#define EIGEN_DEFAULT_IO_FORMAT   IOFormat(4, 0, " ", "\n", "", "", "", "")

EIGEN_INTERNAL_DEBUGGING

#define EIGEN_INTERNAL_DEBUGGING

EIGEN_TEST_SCALAR_TEST_OVERLOAD

#define EIGEN_TEST_SCALAR_TEST_OVERLOAD

(

TYPE

)

Value:

  inline bool test_isApprox(TYPE a, TYPE b) {                                          \
    return numext::equal_strict(a, b) || ((numext::isnan)(a) && (numext::isnan)(b)) || \
           (internal::isApprox(a, b, test_precision<TYPE>()));                         \
  }                                                                                    \
  inline bool test_isCwiseApprox(TYPE a, TYPE b, bool exact) {                         \
    return numext::equal_strict(a, b) || ((numext::isnan)(a) && (numext::isnan)(b)) || \
           (!exact && internal::isApprox(a, b, test_precision<TYPE>()));               \
  }                                                                                    \
  inline bool test_isMuchSmallerThan(TYPE a, TYPE b) {                                 \
    return internal::isMuchSmallerThan(a, b, test_precision<TYPE>());                  \
  }                                                                                    \
  inline bool test_isApproxOrLessThan(TYPE a, TYPE b) {                                \
    return internal::isApproxOrLessThan(a, b, test_precision<TYPE>());                 \
  }

EIGEN_USE_CUSTOM_ASSERT

#define EIGEN_USE_CUSTOM_ASSERT

FORBIDDEN_IDENTIFIER

#define FORBIDDEN_IDENTIFIER    (this_identifier_is_forbidden_to_avoid_clashes) this_identifier_is_forbidden_to_avoid_clashes

I

#define I   FORBIDDEN_IDENTIFIER

isfinite

#define isfinite

(

X

)

please_protect_your_isfinite_with_parentheses

isinf

#define isinf

(

X

)

please_protect_your_isinf_with_parentheses

isnan

#define isnan

(

X

)

please_protect_your_isnan_with_parentheses

M_PI

#define M_PI   please_use_EIGEN_PI_instead_of_M_PI

max

#define max	(		A,
			B
	)		please_protect_your_max_with_parentheses

min

#define min	(		A,
			B
	)		please_protect_your_min_with_parentheses

STATIC_CHECK

#define STATIC_CHECK

(

COND

)

EIGEN_STATIC_ASSERT((COND), EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT)

TEST_SET_BUT_UNUSED_VARIABLE

#define TEST_SET_BUT_UNUSED_VARIABLE

(

X

)

EIGEN_UNUSED_VARIABLE(X)

TRACK

#define TRACK   std::cerr << __FILE__ << " " << __LINE__ << std::endl

VERIFY

#define VERIFY

(

a

)

::verify_impl(a, g_test_stack.back().c_str(), __FILE__, __LINE__, EIGEN_MAKESTRING(a))

VERIFY_GE

#define VERIFY_GE	(		a,
			b
	)		::verify_impl(a >= b, g_test_stack.back().c_str(), __FILE__, __LINE__, EIGEN_MAKESTRING(a >= b))

VERIFY_IS_APPROX

#define VERIFY_IS_APPROX	(		a,
			b
	)		VERIFY(verifyIsApprox(a, b))

VERIFY_IS_APPROX_OR_LESS_THAN

#define VERIFY_IS_APPROX_OR_LESS_THAN	(		a,
			b
	)		VERIFY(test_isApproxOrLessThan(a, b))

VERIFY_IS_CWISE_APPROX

#define VERIFY_IS_CWISE_APPROX	(		a,
			b
	)		VERIFY(verifyIsCwiseApprox(a, b, false))

VERIFY_IS_CWISE_EQUAL

#define VERIFY_IS_CWISE_EQUAL	(		a,
			b
	)		VERIFY(verifyIsCwiseApprox(a, b, true))

VERIFY_IS_EQUAL

#define VERIFY_IS_EQUAL	(		a,
			b
	)		VERIFY(test_is_equal(a, b, true))

VERIFY_IS_MUCH_SMALLER_THAN

#define VERIFY_IS_MUCH_SMALLER_THAN	(		a,
			b
	)		VERIFY(test_isMuchSmallerThan(a, b))

VERIFY_IS_NOT_APPROX

#define VERIFY_IS_NOT_APPROX	(		a,
			b
	)		VERIFY(!test_isApprox(a, b))

VERIFY_IS_NOT_APPROX_OR_LESS_THAN

#define VERIFY_IS_NOT_APPROX_OR_LESS_THAN	(		a,
			b
	)		VERIFY(!test_isApproxOrLessThan(a, b))

VERIFY_IS_NOT_EQUAL

#define VERIFY_IS_NOT_EQUAL	(		a,
			b
	)		VERIFY(test_is_equal(a, b, false))

VERIFY_IS_NOT_MUCH_SMALLER_THAN

#define VERIFY_IS_NOT_MUCH_SMALLER_THAN	(		a,
			b
	)		VERIFY(!test_isMuchSmallerThan(a, b))

VERIFY_IS_UNITARY

#define VERIFY_IS_UNITARY

(

a

)

VERIFY(test_isUnitary(a))

VERIFY_LE

#define VERIFY_LE	(		a,
			b
	)		::verify_impl(a <= b, g_test_stack.back().c_str(), __FILE__, __LINE__, EIGEN_MAKESTRING(a <= b))

VERIFY_RAISES_ASSERT

#define VERIFY_RAISES_ASSERT

(

a

)

std::cout << "Can't VERIFY_RAISES_ASSERT( " #a " ) with exceptions disabled\n";

Function Documentation

main()

int main	(	int argc	,
		char *	argv[]
	)

                                 {
  g_has_set_repeat = false;
  g_has_set_seed = false;
  bool need_help = false;
 
  for (int i = 1; i < argc; i++) {
    if (argv[i][0] == 'r') {
      if (g_has_set_repeat) {
        std::cout << "Argument " << argv[i] << " conflicting with a former argument" << std::endl;
        return 1;
      }
      set_repeat_from_string(argv[i] + 1);
    } else if (argv[i][0] == 's') {
      if (g_has_set_seed) {
        std::cout << "Argument " << argv[i] << " conflicting with a former argument" << std::endl;
        return 1;
      }
      set_seed_from_string(argv[i] + 1);
    } else {
      need_help = true;
    }
  }
 
  if (need_help) {
    std::cout << "This test application takes the following optional arguments:" << std::endl;
    std::cout << "  rN     Repeat each test N times (default: " << DEFAULT_REPEAT << ")" << std::endl;
    std::cout << "  sN     Use N as seed for random numbers (default: based on current time)" << std::endl;
    std::cout << std::endl;
    std::cout << "If defined, the environment variables EIGEN_REPEAT and EIGEN_SEED" << std::endl;
    std::cout << "will be used as default values for these parameters." << std::endl;
    return 1;
  }
 
  char* env_EIGEN_REPEAT = getenv("EIGEN_REPEAT");
  if (!g_has_set_repeat && env_EIGEN_REPEAT) set_repeat_from_string(env_EIGEN_REPEAT);
  char* env_EIGEN_SEED = getenv("EIGEN_SEED");
  if (!g_has_set_seed && env_EIGEN_SEED) set_seed_from_string(env_EIGEN_SEED);
 
  if (!g_has_set_seed) g_seed = (unsigned int)time(NULL);
  if (!g_has_set_repeat) g_repeat = DEFAULT_REPEAT;
 
  std::cout << "Initializing random number generator with seed " << g_seed << std::endl;
  std::stringstream ss;
  ss << "Seed: " << g_seed;
  g_test_stack.push_back(ss.str());
  srand(g_seed);
  std::cout << "Repeating each test " << g_repeat << " times" << std::endl;
 
  VERIFY(EigenTest::all().size() > 0);
 
  for (std::size_t i = 0; i < EigenTest::all().size(); ++i) {
    const EigenTest& current_test = *EigenTest::all()[i];
    Eigen::g_test_stack.push_back(current_test.name());
    current_test();
    Eigen::g_test_stack.pop_back();
  }
 
  return 0;
}

References Eigen::EigenTest::all(), DEFAULT_REPEAT, Eigen::g_has_set_repeat, Eigen::g_has_set_seed, Eigen::g_repeat, Eigen::g_seed, Eigen::g_test_stack, i, int(), Eigen::EigenTest::name(), set_repeat_from_string(), set_seed_from_string(), size, and VERIFY.

set_repeat_from_string()

void set_repeat_from_string ( const char *  str )

inline

Set number of repetitions for unit test from input string.

Parameters

str	input string

                                                    {
  errno = 0;
  g_repeat = int(strtoul(str, 0, 10));
  if (errno || g_repeat <= 0) {
    std::cout << "Invalid repeat value " << str << std::endl;
    exit(EXIT_FAILURE);
  }
  g_has_set_repeat = true;
}

References Eigen::g_has_set_repeat, Eigen::g_repeat, int(), and compute_granudrum_aor::str.

Referenced by main().

set_seed_from_string()

void set_seed_from_string ( const char *  str )

inline

Set seed for randomized unit tests from input string.

Parameters

str	input string

                                                  {
  errno = 0;
  g_seed = int(strtoul(str, 0, 10));
  if (errno || g_seed == 0) {
    std::cout << "Invalid seed value " << str << std::endl;
    exit(EXIT_FAILURE);
  }
  g_has_set_seed = true;
}

References Eigen::g_has_set_seed, Eigen::g_seed, int(), and compute_granudrum_aor::str.

Referenced by main().

type_name() [1/2]

template<typename T >

std::string type_name

(

)

                      {
  return type_name(T());
}

References type_name().

type_name() [2/2]

template<typename T >

std::string type_name

(

T

)

                       {
  return typeid(T).name();
}

References plotDoE::name.

Referenced by type_name().

type_name< double >()

template<>

std::string type_name< double >

(

double

)

                                    {
  return "double";
}

type_name< Eigen::bfloat16 >()

template<>

std::string type_name< Eigen::bfloat16 >

(

Eigen::bfloat16

)

                                                  {
  return "bfloat16";
}

type_name< Eigen::half >()

template<>

std::string type_name< Eigen::half >

(

Eigen::half

)

                                          {
  return "half";
}

type_name< float >()

template<>

std::string type_name< float >

(

float

)

                                  {
  return "float";
}

type_name< int16_t >()

template<>

std::string type_name< int16_t >

(

int16_t

)

                                      {
  return "int16_t";
}

type_name< int32_t >()

template<>

std::string type_name< int32_t >

(

int32_t

)

                                      {
  return "int32_t";
}

type_name< int64_t >()

template<>

std::string type_name< int64_t >

(

int64_t

)

                                      {
  return "int64_t";
}

type_name< int8_t >()

template<>

std::string type_name< int8_t >

(

int8_t

)

                                    {
  return "int8_t";
}

type_name< long double >()

template<>

std::string type_name< long double >

(

long double

)

                                              {
  return "long double";
}

type_name< std::complex< double > >()

template<>

std::string type_name< std::complex< double > >

(

std::complex< double >

)

                                                             {
  return "complex<double>";
}

type_name< std::complex< float > >()

template<>

std::string type_name< std::complex< float > >

(

std::complex< float >

)

                                                           {
  return "complex<float>";
}

type_name< std::complex< int > >()

template<>

std::string type_name< std::complex< int > >

(

std::complex< int >

)

                                                       {
  return "complex<int>";
}

type_name< std::complex< long double > >()

template<>

std::string type_name< std::complex< long double > >

(

std::complex< long double >

)

                                                                       {
  return "complex<long double>";
}

type_name< uint16_t >()

template<>

std::string type_name< uint16_t >

(

uint16_t

)

                                        {
  return "uint16_t";
}

type_name< uint32_t >()

template<>

std::string type_name< uint32_t >

(

uint32_t

)

                                        {
  return "uint32_t";
}

type_name< uint64_t >()

template<>

std::string type_name< uint64_t >

(

uint64_t

)

                                        {
  return "uint64_t";
}

type_name< uint8_t >()

template<>

std::string type_name< uint8_t >

(

uint8_t

)

                                      {
  return "uint8_t";
}

verify_impl()

void verify_impl ( bool  condition, const char *  testname, const char *  file, int  line, const char *  condition_as_string  )

inline

                                                         {
  if (!condition) {
    if (Eigen::g_test_level > 0) std::cerr << "WARNING: ";
    std::cerr << "Test " << testname << " failed in " << file << " (" << line << ")" << std::endl
              << "    " << condition_as_string << std::endl;
    std::cerr << "Stack:\n";
    const int test_stack_size = static_cast<int>(Eigen::g_test_stack.size());
    for (int i = test_stack_size - 1; i >= 0; --i) std::cerr << "  - " << Eigen::g_test_stack[i] << "\n";
    std::cerr << "\n";
    if (Eigen::g_test_level == 0) abort();
  }
}

References Eigen::g_test_level, Eigen::g_test_stack, i, and calibrate::line.