Precision Tests Macros

Macros for performing tests taking floating-point precision into account. More...

Macros
#define	TTS_ABSOLUTE_EQUAL(L, R, N, ...)
	Checks if the absolute distance between values is less or equal to a threshold.
#define	TTS_IEEE_EQUAL(L, R, ...)
	Checks if two values are exactly within 0 ULP.
#define	TTS_RELATIVE_EQUAL(L, R, N, ...)
	Checks if values are within a given relative distance.
#define	TTS_ULP_EQUAL(L, R, N, ...)
	Checks if two values are within a given ULP distance.
#define	TTS_ULP_RANGE_CHECK(Producer, RefType, NewType, RefFunc, NewFunc, Ulpmax)
	Generate a range based test between two functions.

Macro Definition Documentation

TTS_ABSOLUTE_EQUAL

#define TTS_ABSOLUTE_EQUAL	(		L,
			R,
			N,
			... )

#include <tts/test/precision.hpp>

Checks if the absolute distance between values is less or equal to a threshold.

This comparison is performed by using the proper tts::absolute_distance overload.

L and R must have the same type. A mismatch is a compile-time error: the distance would be measured after promotion to the common type, hence in the unit of that type rather than the one under test.

Parameters

L,R	Expressions to compare.
N	Maximum absolute distance accepted between L and R.
...	Optional tag. If equals to REQUIRED, this test will stop the program if it fails.

Example

#define TTS_MAIN // No need for main()
#include <tts/tts.hpp>
 
TTS_CASE("Absolute distance")
{
  TTS_ABSOLUTE_EQUAL(-2., 2., 4.);
  TTS_ABSOLUTE_EQUAL(static_cast<long long>('A'), 80LL, 15, REQUIRED);
};

TTS_IEEE_EQUAL

#define TTS_IEEE_EQUAL	(		L,
			R,
			... )

#include <tts/test/precision.hpp>

Checks if two values are exactly within 0 ULP.

This also allow for infinites and NaNs to be compared equal if both values are the same infinites or are both $NaN$. This comparison is performed by using the proper tts::ulp_distance overload.

Parameters

L,R	Expressions to compare.
...	Optional tag. If equals to REQUIRED, this test will stop the program if it fails.

Example

#define TTS_MAIN // No need for main()
#include <tts/tts.hpp>
 
TTS_CASE("ULP distance")
{
  float x = std::numeric_limits<float>::quiet_NaN();
  TTS_IEEE_EQUAL(x, x);
 
  TTS_IEEE_EQUAL(1.f, 1.f);
  TTS_IEEE_EQUAL(2., 2.);
  TTS_IEEE_EQUAL(65, 'A');
};

TTS_RELATIVE_EQUAL

#define TTS_RELATIVE_EQUAL	(		L,
			R,
			N,
			... )

#include <tts/test/precision.hpp>

Checks if values are within a given relative distance.

This comparison is performed by using the proper tts::relative_distance overload.

L and R must have the same type. A mismatch is a compile-time error: the distance would be measured after promotion to the common type, hence in the unit of that type rather than the one under test.

Parameters

L,R	Expressions to compare.
N	Maximum relative distance accepted between L and R, as a ratio: 0.005 is half a percent. abs(L-R) / max(abs(L), abs(R), 1) is what gets compared to it.
...	Optional tag. If equals to REQUIRED, this test will stop the program if it fails.

Example

#define TTS_MAIN // No need for main()
#include <tts/tts.hpp>
 
TTS_CASE("Relative distance")
{
  TTS_RELATIVE_EQUAL(42.f, 42.f, 0);
  TTS_RELATIVE_EQUAL(static_cast<long long>('A'), 80LL, 0.1875);
  TTS_RELATIVE_EQUAL(1., 2., 0.5);
  TTS_RELATIVE_EQUAL(1, 10, 0.9, REQUIRED);
};

TTS_ULP_EQUAL

#define TTS_ULP_EQUAL	(		L,
			R,
			N,
			... )

#include <tts/test/precision.hpp>

Checks if two values are within a given ULP distance.

This comparison is performed by using the proper tts::ulp_distance overload.

L and R must have the same type. A mismatch is a compile-time error: the distance would be measured after promotion to the common type, hence in the unit of that type rather than the one under test.

Parameters

L,R	Expressions to compare.
N	Maximum ULPs accepted between L and R.
...	Optional tag. If equals to REQUIRED, this test will stop the program if it fails.

Example

#define TTS_MAIN // No need for main()
#include <tts/tts.hpp>
 
TTS_CASE("ULP distance")
{
  float a {1};
  float eps  = std::numeric_limits<float>::epsilon();
  float qnan = std::numeric_limits<float>::quiet_NaN();
  float inf  = std::numeric_limits<float>::infinity();
  float minf = -inf;
 
  TTS_ULP_EQUAL(a, a, 0.);
 
  TTS_ULP_EQUAL(a, qnan, inf);
  TTS_ULP_EQUAL(qnan, qnan, 0.);
 
  TTS_ULP_EQUAL(a, inf, inf);
  TTS_ULP_EQUAL(inf, inf, inf);
  TTS_ULP_EQUAL(minf, minf, inf);
 
  TTS_ULP_EQUAL(a, a - eps, 1);
  TTS_ULP_EQUAL(a, a + eps, 0.5);
  TTS_ULP_EQUAL(a, a + 3 * eps, 1.5, REQUIRED);
};

TTS_ULP_RANGE_CHECK

#define TTS_ULP_RANGE_CHECK	(		Producer,
			RefType,
			NewType,
			RefFunc,
			NewFunc,
			Ulpmax )

#include <tts/test/ranges.hpp>

Generate a range based test between two functions.

Evaluates the histogram of ULP difference between two functions run on the same data set and that they lie in a given ULP distance.

Parameters

Producer	Data set generator to use.
RefType	Type to use as reference function input.
NewType	Type to use as challenger function input.
RefFunc	Reference function to compare to.
NewFunc	Challenger function to be compared to the reference one.
Ulpmax	Maximal ULPs acceptable for passing the test.

Example

#define TTS_MAIN // No need for main()
#include <tts/tts.hpp>
 
float ok_x(float x)
{
  return x;
}
float bad_x(float x)
{
  return x + x * 1e-7f;
}
 
TTS_CASE("Test range check")
{
  TTS_ULP_RANGE_CHECK([](auto, auto i, auto c)
                      { return 100.f * static_cast<float>(i) / static_cast<float>(c); },
                      float,
                      float,
                      ok_x,
                      bad_x,
                      2.);
};