libm_test.cpp File Reference

#include <vector>
#include <complex>
#include <cmath>
#include <random>
#include <float.h>
#include "gtest/gtest.h"
#include "../libm.h"

Include dependency graph for libm_test.cpp:

Macros
#define	MY_EXPECT_DOUBLE_EQ(ds1, ds2)
#define	MY_EXPECT_COMPLEX_DOUBLE_EQ(ds1, ds2)
#define	SINGLE_PARAM_FLOAT64_MATH_RANDOM_TEST_TEMPLATE(TNAME, FNAME, LENGTH, LOW, HIGH)
#define	SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(TNAME, FNAME, VALUE)
#define	SINGLE_PARAM_FLOAT64_MATH_CORNER_TEST_TEMPLATE(FNAME)

Functions
	TEST (base_libm, sincos_random)
	TEST (base_libm, sincos_spec)
	TEST (base_libm, cexp_random)
	TEST (base_libm, cexp_spec)

Macro Definition Documentation

MY_EXPECT_COMPLEX_DOUBLE_EQ

#define MY_EXPECT_COMPLEX_DOUBLE_EQ	(		ds1,
			ds2
	)

Value:

    MY_EXPECT_DOUBLE_EQ(ds1.real(), ds2.real());                                \
    MY_EXPECT_DOUBLE_EQ(ds1.imag(), ds2.imag());                                \

MY_EXPECT_DOUBLE_EQ

#define MY_EXPECT_DOUBLE_EQ	(		ds1,
			ds2
	)

Value:

do {                                                                            \
    if (std::isnan(ds1) && std::isnan(ds2) &&                                   \
        std::signbit(ds1) == std::signbit(ds2))                                 \
        EXPECT_EQ(1, 1);                                                        \
    else EXPECT_DOUBLE_EQ(ds1, ds2);                                            \
} while (0)

SINGLE_PARAM_FLOAT64_MATH_CORNER_TEST_TEMPLATE

#define SINGLE_PARAM_FLOAT64_MATH_CORNER_TEST_TEMPLATE

(

FNAME

)

Value:

SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _nz, FNAME, -0.0);        \
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _pz, FNAME, +0.0);        \
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _ninf, FNAME, -INFINITY); \
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _pinf, FNAME, +INFINITY); \
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _nnan, FNAME, -NAN);      \
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _pnan, FNAME, +NAN);      \
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _nmin, FNAME, -DBL_MIN);  \
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _nmax, FNAME, -DBL_MAX);  \
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _pmin, FNAME, +DBL_MIN);  \
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _pmax, FNAME, +DBL_MAX);  \
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _nmin2, FNAME, -DBL_MIN * DBL_MIN);\
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _nmax2, FNAME, -DBL_MAX * DBL_MAX);\
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _pmin2, FNAME, +DBL_MIN * DBL_MIN);\
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _pmax2, FNAME, +DBL_MAX * DBL_MAX);\
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _nlarge, FNAME, -DBL_MAX / M_PI);\
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _plarge, FNAME, +DBL_MAX / M_PI);\
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _nlarge2, FNAME, -105414350.0 * 2.0);\
SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE(FNAME ## _plarge2, FNAME, +105414350.0 * 2.0);\

SINGLE_PARAM_FLOAT64_MATH_RANDOM_TEST_TEMPLATE

#define SINGLE_PARAM_FLOAT64_MATH_RANDOM_TEST_TEMPLATE	(		TNAME,
			FNAME,
			LENGTH,
			LOW,
			HIGH
	)

Value:

TEST(base_libm, TNAME) {                                                        \
    int len = (LENGTH);                                                         \
    std::vector<double> da(len);                                                \
    std::vector<double> ds1(len);                                               \
    std::vector<double> ds2(len);                                               \
    std::uniform_real_distribution<double> rnd(LOW, HIGH);                      \
    std::default_random_engine eng;                                             \
    for (int i = 0; i < len; ++i)                                               \
        da[i] = rnd(eng);                                                       \
    for (int i = 0; i < len; ++i) {                                             \
        ds1[i] = std::FNAME(da[i]);                                             \
        ds2[i] = ModuleBase::libm::FNAME(da[i]);                                \
    }                                                                           \
    for (int i = 0; i < len; i++)                                               \
        MY_EXPECT_DOUBLE_EQ(ds1[i], ds2[i]);                                       \
}                                                                               \

SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE

#define SINGLE_PARAM_FLOAT64_MATH_SPEC_TEST_TEMPLATE	(		TNAME,
			FNAME,
			VALUE
	)

Value:

TEST(base_libm, TNAME) {                                                        \
    double ds1 = std::FNAME(VALUE);                                             \
    double ds2 = ModuleBase::libm::FNAME(VALUE);                                \
    MY_EXPECT_DOUBLE_EQ(ds1, ds2);                                              \
}                                                                               \

Function Documentation

TEST() [1/4]

TEST	(	base_libm	,
		cexp_random
	)

Here is the call graph for this function:

TEST() [2/4]

TEST	(	base_libm	,
		cexp_spec
	)

Here is the call graph for this function:

TEST() [3/4]

TEST	(	base_libm	,
		sincos_random
	)

Here is the call graph for this function:

TEST() [4/4]

TEST	(	base_libm	,
		sincos_spec
	)

Here is the call graph for this function: