Skip to content

Instantly share code, notes, and snippets.

@pranet

pranet/Math_unittest.cc

Created February 28, 2014 09:04
Show Gist options
  • Save pranet/9267745 to your computer and use it in GitHub Desktop.
Save pranet/9267745 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
Math_unittest.cc
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* Written (W) 2013 Thoralf Klein
* Written (W) 2013 Soumyajit De
*/
#include <shogun/lib/common.h>
#include <shogun/lib/SGVector.h>
#include <shogun/mathematics/Math.h>
#include <gtest/gtest.h>
#include <cfloat>
#include <limits>
#define FLOAT32_POSITIVE_INFINITY (std::numeric_limits<float32_t>::infinity())
#define FLOAT32_NEGATIVE_INFINITY (-(std::numeric_limits<float32_t>::infinity() ))
#define FLOAT32_NaN (std::numeric_limits<float32_t>::quiet_NaN() )
#define FLOAT64_POSITIVE_INFINITY (std::numeric_limits<float64_t>::infinity())
#define FLOAT64_NEGATIVE_INFINITY (-(std::numeric_limits<float64_t>::infinity() ))
#define FLOAT64_NaN (std::numeric_limits<float64_t>::quiet_NaN() )
#define FLOATMAX_POSITIVE_INFINITY (std::numeric_limits<floatmax_t>::infinity())
#define FLOATMAX_NEGATIVE_INFINITY (-(std::numeric_limits<floatmax_t>::infinity() ))
#define FLOATMAX_NaN (std::numeric_limits<floatmax_t>::quiet_NaN() )
using namespace shogun;
TEST(CMath, qsort_test)
{
// testing qsort on list of zero elements
CMath::qsort((int32_t *)NULL, 0);
// testing qsort on list of one element
int32_t * v1 = SG_CALLOC(int32_t, 1);
CMath::qsort(v1, 1);
SG_FREE(v1);
}
TEST(CMath, qsort_ptr_test)
{
// testing qsort on list of zero pointers
CMath::qsort((int32_t **)NULL, 0);
// testing qsort on list of one pointer
int32_t ** v1 = SG_CALLOC(int32_t *, 1);
CMath::qsort(v1, 1);
SG_FREE(v1);
}
TEST(CMath, qsort_index_test)
{
// testing qsort_index on list of zero elements
CMath::qsort_index((int32_t *)NULL, (int32_t *)NULL, 0);
// testing qsort_index on list of one element
int32_t * v1 = SG_CALLOC(int32_t, 1);
int32_t * i1 = SG_CALLOC(int32_t, 1);
CMath::qsort_index(v1, i1, 1);
SG_FREE(v1);
SG_FREE(i1);
}
TEST(CMath, qsort_backward_index_test)
{
// testing qsort_backward_index on list of zero elements
CMath::qsort_backward_index((int32_t *)NULL, (int32_t *)NULL, 0);
// testing qsort_backward_index on list of one element
int32_t * v1 = SG_CALLOC(int32_t, 1);
int32_t * i1 = SG_CALLOC(int32_t, 1);
CMath::qsort_backward_index(v1, i1, 1);
SG_FREE(v1);
SG_FREE(i1);
}
TEST(CMath, parallel_qsort_index_test)
{
// testing parallel_qsort_index on list of zero elements
CMath::parallel_qsort_index((int32_t *)NULL, (int32_t *)NULL, 0, 8);
// testing parallel_qsort_index on list of one element
int32_t * v1 = SG_CALLOC(int32_t, 1);
int32_t * i1 = SG_CALLOC(int32_t, 1);
CMath::parallel_qsort_index(v1, i1, 1, 8);
SG_FREE(v1);
SG_FREE(i1);
}
TEST(CMath, float64_tests)
{
// round, ceil, floor
EXPECT_NEAR(CMath::round(7.5), 8.0, 1E-15);
EXPECT_NEAR(CMath::round(7.5-1E-15), 7.0, 1E-15);
EXPECT_NEAR(CMath::floor(8-1E-15), 7.0, 1E-15);
EXPECT_NEAR(CMath::ceil(7+1E-15), 8.0, 1E-15);
float64_t a=5.78123516567856743364;
// x^2, x^(1/2)
EXPECT_NEAR(CMath::sq(a), 33.42268004087848964900, 1E-15);
EXPECT_NEAR(CMath::sqrt(33.42268004087848964900), a, 1E-15);
EXPECT_NEAR(CMath::pow(a, 2), 33.42268004087848964900, 1E-15);
EXPECT_NEAR(CMath::pow(33.42268004087848964900, 0.5), a, 1E-15);
// e^x, log_{b}(x)
EXPECT_NEAR(CMath::exp(a), 324.15933372813628920994, 1E-15);
EXPECT_NEAR(CMath::log2(a), 2.53137775864743908016, 1E-15);
EXPECT_NEAR(CMath::log10(a), 0.76202063570953693095, 1E-15);
// exp and log identities
EXPECT_NEAR(CMath::log(CMath::exp(a)), a, 1E-15);
EXPECT_NEAR(CMath::exp(CMath::log(a)), a, 1E-15);
// trigonometric functions
EXPECT_NEAR(CMath::sin(a), -0.48113603605414501097, 1E-15);
EXPECT_NEAR(CMath::sinh(a), 162.07812441272406545067, 1E-13);
EXPECT_NEAR(CMath::asin(a-5.0), 0.89664205584230471935, 1E-15);
EXPECT_NEAR(CMath::cos(a), 0.87664594609802681813, 1E-15);
EXPECT_NEAR(CMath::cosh(a), 162.08120931541219533756, 1E-15);
EXPECT_NEAR(CMath::acos(a-5.0), 0.67415427095259194967, 1E-15);
EXPECT_NEAR(CMath::tan(a), -0.54883734784344084812, 1E-15);
EXPECT_NEAR(CMath::tanh(a), 0.99998096693194016282, 1E-15);
EXPECT_NEAR(CMath::atan(a), 1.39951769800256187182, 1E-15);
// trigonometric identities
EXPECT_NEAR(CMath::sq(CMath::sin(a))+CMath::sq(CMath::cos(a)),
1.0, 1E-15);
EXPECT_NEAR(CMath::sq(1.0/CMath::cos(a))-CMath::sq(CMath::tan(a)),
1.0, 1E-15);
EXPECT_NEAR(CMath::sq(1.0/CMath::sin(a))-CMath::sq(1.0/CMath::tan(a)),
1.0, 1E-15);
// misc
SGVector<float64_t> vec(10);
for (index_t i=0; i<10; ++i)
{
vec[i]=i%2==0 ? i : 0.0;
}
EXPECT_EQ(CMath::get_num_nonzero(vec.vector, 10), 4);
}
TEST(CMath, linspace_test)
{
// Number of points used to divide the interval
int32_t n = 100;
// Start and end of the interval
float64_t start = 0.0, end = 1.0;
SGVector<float64_t> vec(100);
CMath::linspace(vec.vector, start, end, n);
// The first and last elements are tested outside the loop, because
// linspace sets them directly using the arguments
EXPECT_EQ(vec[0], start);
EXPECT_EQ(vec[n-1], end);
float64_t val = start;
for (index_t i = 1; i < n-1; ++i)
{
val += (end-start)/(n-1);
EXPECT_EQ(vec[i], val);
}
}
TEST(CMath, log_sum_exp)
{
SGVector<float64_t> values(3);
values.range_fill();
EXPECT_NEAR(CMath::log_sum_exp(values), 2.4076059644443801, 1e-15);
}
TEST(CMath, log_mean_exp)
{
SGVector<float64_t> values(3);
values.range_fill();
EXPECT_NEAR(CMath::log_mean_exp(values), 1.3089936757762706, 1e-15);
}
TEST(CMath, strtofloat)
{
float32_t float_result = 0;
EXPECT_TRUE(CMath::strtof("nan", &float_result));
EXPECT_TRUE(CMath::is_nan(float_result));
EXPECT_TRUE(CMath::strtof("inf", &float_result));
EXPECT_TRUE(CMath::is_infinity(float_result));
EXPECT_TRUE(CMath::strtof("-inf", &float_result));
EXPECT_DOUBLE_EQ(-CMath::INFTY, float_result);
EXPECT_TRUE(CMath::strtof("1.2345", &float_result));
EXPECT_FLOAT_EQ(1.2345, float_result);
}
TEST(CMath, strtodouble)
{
float64_t double_result = 0;
EXPECT_TRUE(CMath::strtod("nan", &double_result));
EXPECT_TRUE(CMath::is_nan(double_result));
EXPECT_TRUE(CMath::strtod("inf", &double_result));
EXPECT_TRUE(CMath::is_infinity(double_result));
EXPECT_TRUE(CMath::strtod("-inf", &double_result));
EXPECT_DOUBLE_EQ(-CMath::INFTY, double_result);
EXPECT_TRUE(CMath::strtod("1.234567890123", &double_result));
EXPECT_DOUBLE_EQ(1.234567890123, double_result);
}
TEST(CMath, strtolongdouble)
{
floatmax_t long_double_result = 0;
EXPECT_TRUE(CMath::strtold("nan", &long_double_result));
EXPECT_TRUE(CMath::is_nan(long_double_result));
EXPECT_TRUE(CMath::strtold("inf", &long_double_result));
EXPECT_TRUE(CMath::is_infinity(long_double_result));
EXPECT_TRUE(CMath::strtold("-inf", &long_double_result));
EXPECT_DOUBLE_EQ(-CMath::INFTY, long_double_result);
EXPECT_TRUE(CMath::strtold("1.234567890123", &long_double_result));
EXPECT_DOUBLE_EQ(1.234567890123, long_double_result);
}
TEST(CMath, floatEqualityLargeNumbers)
{
EXPECT_TRUE(CMath::nearlyEqual(1000000.0f, 1000001.0f));
EXPECT_TRUE(CMath::nearlyEqual(1000001.0f, 1000000.0f));
EXPECT_FALSE(CMath::nearlyEqual(10000.0f, 10001.0f));
EXPECT_FALSE(CMath::nearlyEqual(10001.0f, 10000.0f));
}
TEST(CMath, floatEqualityLargeNumbersNegative)
{
EXPECT_TRUE(CMath::nearlyEqual(-1000000.0f, -1000001.0f));
EXPECT_TRUE(CMath::nearlyEqual(-1000001.0f, -1000000.0f));
EXPECT_FALSE(CMath::nearlyEqual(-10000.0f, -10001.0f));
EXPECT_FALSE(CMath::nearlyEqual(-10001.0f, -10000.0f));
}
TEST(CMath, floatEqualityNumbersAround1)
{
EXPECT_TRUE(CMath::nearlyEqual(1.0000001f, 1.0000002f));
EXPECT_TRUE(CMath::nearlyEqual(1.0000002f, 1.0000001f));
EXPECT_FALSE(CMath::nearlyEqual(1.0002f, 1.0001f));
EXPECT_FALSE(CMath::nearlyEqual(1.0001f, 1.0002f));
}
TEST(CMath, floatEqualityNumbersAroundMinus1)
{
EXPECT_TRUE(CMath::nearlyEqual(-1.000001f, -1.000002f));
EXPECT_TRUE(CMath::nearlyEqual(-1.000002f, -1.000001f));
EXPECT_FALSE(CMath::nearlyEqual(-1.0001f, -1.0002f));
EXPECT_FALSE(CMath::nearlyEqual(-1.0002f, -1.0001f));
}
TEST(CMath, floatEqualityNumbersBetween0And1)
{
EXPECT_TRUE(CMath::nearlyEqual(0.000000001000001f, 0.000000001000002f));
EXPECT_TRUE(CMath::nearlyEqual(0.000000001000002f, 0.000000001000001f));
EXPECT_FALSE(CMath::nearlyEqual(0.000000000001002f, 0.000000000001001f));
EXPECT_FALSE(CMath::nearlyEqual(0.000000000001001f, 0.000000000001002f));
}
TEST(CMath, floatEqualityNumbersBetweenMinus1and0)
{
EXPECT_TRUE(CMath::nearlyEqual(-0.000000001000001f, -0.000000001000002f));
EXPECT_TRUE(CMath::nearlyEqual(-0.000000001000002f, -0.000000001000001f));
EXPECT_FALSE(CMath::nearlyEqual(-0.000000000001002f, -0.000000000001001f));
EXPECT_FALSE(CMath::nearlyEqual(-0.000000000001001f, -0.000000000001002f));
}
TEST(CMath, floatEqualityComparisonWith0)
{
EXPECT_TRUE(CMath::nearlyEqual(0.0f, 0.0f));
EXPECT_TRUE(CMath::nearlyEqual(0.0f, -0.0f));
EXPECT_TRUE(CMath::nearlyEqual(-0.0f, -0.0f));
EXPECT_FALSE(CMath::nearlyEqual(0.00000001f, 0.0f));
EXPECT_FALSE(CMath::nearlyEqual(0.0f, 0.00000001f));
EXPECT_FALSE(CMath::nearlyEqual(-0.00000001f, 0.0f));
EXPECT_FALSE(CMath::nearlyEqual(0.0f, -0.00000001f));
EXPECT_TRUE(CMath::nearlyEqual(0.0f, 1e-40f, 0.01f));
EXPECT_TRUE(CMath::nearlyEqual(1e-40f, 0.0f, 0.01f));
EXPECT_FALSE(CMath::nearlyEqual(1e-40f, 0.0f, 0.000001f));
EXPECT_FALSE(CMath::nearlyEqual(0.0f, 1e-40f, 0.000001f));
EXPECT_TRUE(CMath::nearlyEqual(0.0f, -1e-40f, 0.1f));
EXPECT_TRUE(CMath::nearlyEqual(-1e-40f, 0.0f, 0.1f));
EXPECT_FALSE(CMath::nearlyEqual(-1e-40f, 0.0f, 0.00000001f));
EXPECT_FALSE(CMath::nearlyEqual(0.0f, -1e-40f, 0.00000001f));
}
TEST(CMath, float32EqualityComparisonWithInfinity)
{
EXPECT_TRUE(CMath::nearlyEqual(FLOAT32_POSITIVE_INFINITY, FLOAT32_POSITIVE_INFINITY));
EXPECT_TRUE(CMath::nearlyEqual(FLOAT32_NEGATIVE_INFINITY, FLOAT32_NEGATIVE_INFINITY));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_NEGATIVE_INFINITY, FLOAT32_POSITIVE_INFINITY));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_POSITIVE_INFINITY, FLT_MAX));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_NEGATIVE_INFINITY, -FLT_MAX));
}
TEST(CMath, float32EqualityNumbersComparisonWithNan)
{
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_NaN, FLOAT32_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_NaN, 0.0f));
EXPECT_FALSE(CMath::nearlyEqual(-0.0f, FLOAT32_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_NaN, -0.0f));
EXPECT_FALSE(CMath::nearlyEqual(0.0f, FLOAT32_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_NaN, FLOAT32_POSITIVE_INFINITY));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_POSITIVE_INFINITY, FLOAT32_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_NaN, FLOAT32_NEGATIVE_INFINITY));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_NEGATIVE_INFINITY, FLOAT32_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_NaN, FLT_MAX));
EXPECT_FALSE(CMath::nearlyEqual(FLT_MAX, FLOAT32_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_NaN, -FLT_MAX));
EXPECT_FALSE(CMath::nearlyEqual(-FLT_MAX, FLOAT32_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_NaN, FLT_MIN));
EXPECT_FALSE(CMath::nearlyEqual(FLT_MIN, FLOAT32_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT32_NaN, -FLT_MIN));
EXPECT_FALSE(CMath::nearlyEqual(-FLT_MIN, FLOAT32_NaN));
}
TEST(CMath, float32EqualityNumbersOppositeSigns)
{
EXPECT_FALSE(CMath::nearlyEqual(1.000000001f, -1.0f));
EXPECT_FALSE(CMath::nearlyEqual(-1.0f, 1.000000001f));
EXPECT_FALSE(CMath::nearlyEqual(-1.000000001f, 1.0f));
EXPECT_FALSE(CMath::nearlyEqual(1.0f, -1.000000001f));
EXPECT_TRUE(CMath::nearlyEqual(10 * FLT_MIN, 10 * -FLT_MIN));
EXPECT_FALSE(CMath::nearlyEqual(10000 * FLT_MIN, 10000 * -FLT_MIN));
}
TEST(CMath, float32EqualityNumbersAlmost0)
{
EXPECT_TRUE(CMath::nearlyEqual(FLT_MIN, -FLT_MIN));
EXPECT_TRUE(CMath::nearlyEqual(-FLT_MIN, FLT_MIN));
EXPECT_TRUE(CMath::nearlyEqual(FLT_MIN, 0.0f));
EXPECT_TRUE(CMath::nearlyEqual(0.0f, FLT_MIN));
EXPECT_TRUE(CMath::nearlyEqual(-FLT_MIN, 0.0f));
EXPECT_TRUE(CMath::nearlyEqual(0.0f, -FLT_MIN));
EXPECT_FALSE(CMath::nearlyEqual(0.000000001f, -FLT_MIN));
EXPECT_FALSE(CMath::nearlyEqual(FLT_MIN, 0.000000001f));
EXPECT_FALSE(CMath::nearlyEqual(-FLT_MIN, 0.000000001f));
}
TEST(CMath, float64EqualityComparisonWithInfinity)
{
EXPECT_TRUE(CMath::nearlyEqual(FLOAT64_POSITIVE_INFINITY, FLOAT64_POSITIVE_INFINITY));
EXPECT_TRUE(CMath::nearlyEqual(FLOAT64_NEGATIVE_INFINITY, FLOAT64_NEGATIVE_INFINITY));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_NEGATIVE_INFINITY, FLOAT64_POSITIVE_INFINITY));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_POSITIVE_INFINITY, DBL_MAX));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_NEGATIVE_INFINITY, -DBL_MAX));
}
TEST(CMath, float64EqualityNumbersComparisonWithNan)
{
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_NaN, FLOAT64_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_NaN, 0.0));
EXPECT_FALSE(CMath::nearlyEqual(-0.0, FLOAT64_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_NaN, -0.0));
EXPECT_FALSE(CMath::nearlyEqual(0.0, FLOAT64_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_NaN, FLOAT64_POSITIVE_INFINITY));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_POSITIVE_INFINITY, FLOAT64_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_NaN, FLOAT64_NEGATIVE_INFINITY));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_NEGATIVE_INFINITY, FLOAT64_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_NaN, DBL_MAX));
EXPECT_FALSE(CMath::nearlyEqual(DBL_MAX, FLOAT64_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_NaN, -DBL_MAX));
EXPECT_FALSE(CMath::nearlyEqual(-DBL_MAX, FLOAT64_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_NaN, DBL_MIN));
EXPECT_FALSE(CMath::nearlyEqual(DBL_MIN, FLOAT64_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOAT64_NaN, -DBL_MIN));
EXPECT_FALSE(CMath::nearlyEqual(-DBL_MIN, FLOAT64_NaN));
}
TEST(CMath, float64EqualityNumbersOppositeSigns)
{
EXPECT_FALSE(CMath::nearlyEqual(1.000000001, -1.0));
EXPECT_FALSE(CMath::nearlyEqual(-1.0, 1.000000001));
EXPECT_FALSE(CMath::nearlyEqual(-1.000000001, 1.0));
EXPECT_FALSE(CMath::nearlyEqual(1.0, -1.000000001));
EXPECT_TRUE(CMath::nearlyEqual(10 * DBL_MIN, 10 * -DBL_MIN));
EXPECT_FALSE(CMath::nearlyEqual(10000 * DBL_MIN, 10000 * -DBL_MIN));
}
TEST(CMath, float64EqualityNumbersAlmost0)
{
EXPECT_TRUE(CMath::nearlyEqual(DBL_MIN, -DBL_MIN));
EXPECT_TRUE(CMath::nearlyEqual(-DBL_MIN, DBL_MIN));
EXPECT_TRUE(CMath::nearlyEqual(DBL_MIN, 0.0));
EXPECT_TRUE(CMath::nearlyEqual(0.0, DBL_MIN));
EXPECT_TRUE(CMath::nearlyEqual(-DBL_MIN, 0.0));
EXPECT_TRUE(CMath::nearlyEqual(0.0, -DBL_MIN));
EXPECT_FALSE(CMath::nearlyEqual(0.000000001, -DBL_MIN));
EXPECT_FALSE(CMath::nearlyEqual(DBL_MIN, 0.000000001));
EXPECT_FALSE(CMath::nearlyEqual(-DBL_MIN, 0.000000001));
}
TEST(CMath, floatmaxEqualityComparisonWithInfinity)
{
EXPECT_TRUE(CMath::nearlyEqual(FLOATMAX_POSITIVE_INFINITY, FLOATMAX_POSITIVE_INFINITY));
EXPECT_TRUE(CMath::nearlyEqual(FLOATMAX_NEGATIVE_INFINITY, FLOATMAX_NEGATIVE_INFINITY));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_NEGATIVE_INFINITY, FLOATMAX_POSITIVE_INFINITY));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_POSITIVE_INFINITY, LDBL_MAX));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_NEGATIVE_INFINITY, -LDBL_MAX));
}
TEST(CMath, floatmaxEqualityNumbersComparisonWithNan)
{
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_NaN, FLOATMAX_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_NaN, 0.0l));
EXPECT_FALSE(CMath::nearlyEqual(-0.0l, FLOATMAX_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_NaN, -0.0l));
EXPECT_FALSE(CMath::nearlyEqual(0.0l, FLOATMAX_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_NaN, FLOATMAX_POSITIVE_INFINITY));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_POSITIVE_INFINITY, FLOATMAX_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_NaN, FLOATMAX_NEGATIVE_INFINITY));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_NEGATIVE_INFINITY, FLOATMAX_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_NaN, LDBL_MAX));
EXPECT_FALSE(CMath::nearlyEqual(LDBL_MAX, FLOATMAX_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_NaN, -LDBL_MAX));
EXPECT_FALSE(CMath::nearlyEqual(-LDBL_MAX, FLOATMAX_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_NaN, LDBL_MIN));
EXPECT_FALSE(CMath::nearlyEqual(LDBL_MIN, FLOATMAX_NaN));
EXPECT_FALSE(CMath::nearlyEqual(FLOATMAX_NaN, -LDBL_MIN));
EXPECT_FALSE(CMath::nearlyEqual(-LDBL_MIN, FLOATMAX_NaN));
}
TEST(CMath, floatmaxEqualityNumbersOppositeSigns)
{
EXPECT_FALSE(CMath::nearlyEqual(1.000000001l, -1.0l));
EXPECT_FALSE(CMath::nearlyEqual(-1.0l, 1.000000001l));
EXPECT_FALSE(CMath::nearlyEqual(-1.000000001l, 1.0l));
EXPECT_FALSE(CMath::nearlyEqual(1.0l, -1.000000001l));
EXPECT_TRUE(CMath::nearlyEqual(10 * LDBL_MIN, 10 * -LDBL_MIN));
EXPECT_FALSE(CMath::nearlyEqual(10000 * LDBL_MIN, 10000 * -LDBL_MIN));
}
TEST(CMath, floatmaxEqualityNumbersAlmost0)
{
EXPECT_TRUE(CMath::nearlyEqual(LDBL_MIN, -LDBL_MIN));
EXPECT_TRUE(CMath::nearlyEqual(-LDBL_MIN, LDBL_MIN));
EXPECT_TRUE(CMath::nearlyEqual(LDBL_MIN, 0.0l));
EXPECT_TRUE(CMath::nearlyEqual(0.0l, LDBL_MIN));
EXPECT_TRUE(CMath::nearlyEqual(-LDBL_MIN, 0.0l));
EXPECT_TRUE(CMath::nearlyEqual(0.0l, -LDBL_MIN));
EXPECT_FALSE(CMath::nearlyEqual(0.000000001l, -LDBL_MIN));
EXPECT_FALSE(CMath::nearlyEqual(LDBL_MIN, 0.000000001l));
EXPECT_FALSE(CMath::nearlyEqual(-LDBL_MIN, 0.000000001l));
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment