Skip to content

N
ngraph
Commit 03bbeb90 authored by gcwenger's avatar gcwenger Committed by Robert Kimball
Browse files
Options

all_close_f error reporting clarification. all_close_f test cases spaced out for… 

all_close_f error reporting clarification. all_close_f test cases spaced out for easier interpretation. (#2247)
parent e9e4f418
Show whitespace changes
Inline Side-by-side
Showing with 154 additions and 96 deletions
test/all_close_f.cpp
View file @ 03bbeb90
......@@ -14,6 +14,7 @@
// limitations under the License.
//*****************************************************************************
#include <algorithm>
#include <bitset>
#include <cmath>
#include <limits>
......@@ -48,7 +49,23 @@ string float_to_bits(float f)
FloatUnion fu{f};
stringstream ss;
ss << bitset<32>(fu.i);
return ss.str();
string unformatted = ss.str();
string formatted;
formatted.reserve(41);
// Sign
formatted.push_back(unformatted[0]);
formatted.append(" ");
// Exponent
formatted.append(unformatted, 1, 8);
formatted.append(" ");
// Mantissa
formatted.append(unformatted, 9, 3);
for (int i = 12; i < 32; i += 4)
{
formatted.push_back(' ');
formatted.append(unformatted, i, 4);
}
return formatted;
}
string double_to_bits(double d)
......@@ -56,16 +73,35 @@ string double_to_bits(double d)
DoubleUnion du{d};
stringstream ss;
ss << bitset<64>(du.i);
return ss.str();
string unformatted = ss.str();
string formatted;
formatted.reserve(80);
// Sign
formatted.push_back(unformatted[0]);
formatted.append(" ");
// Exponent
formatted.append(unformatted, 1, 11);
formatted.push_back(' ');
// Mantissa
for (int i = 12; i < 64; i += 4)
{
formatted.push_back(' ');
formatted.append(unformatted, i, 4);
}
return formatted;
}
float bits_to_float(const string& s)
{
if (s.size() != 32)
string unformatted = s;
unformatted.erase(remove_if(unformatted.begin(), unformatted.end(), ::isspace),
unformatted.end());
if (unformatted.size() != 32)
{
throw ngraph_error("Input length must be 32");
}
bitset<32> bs(s);
bitset<32> bs(unformatted);
FloatUnion fu;
fu.i = static_cast<uint32_t>(bs.to_ulong());
return fu.f;
......@@ -73,11 +109,15 @@ float bits_to_float(const string& s)
double bits_to_double(const string& s)
{
if (s.size() != 64)
string unformatted = s;
unformatted.erase(remove_if(unformatted.begin(), unformatted.end(), ::isspace),
unformatted.end());
if (unformatted.size() != 64)
{
throw ngraph_error("Input length must be 64");
}
bitset<64> bs(s);
bitset<64> bs(unformatted);
DoubleUnion du;
du.i = static_cast<uint64_t>(bs.to_ullong());
return du.d;
......@@ -333,8 +373,10 @@ INSTANTIATE_TEST_CASE_P(
// Targeted bit
// |
// v
// 2 3 4 5 6 (error allowed in 6th bit or later, w/ implicit leading bit)
// s e e e e e e e e m m m m m m m m m m m m m m m m m m m m m m m
// =>| 8 |
// =>| 8 | (8 w/ implicit leading bit)
// ^
// | 2 |<=
//
// [Upper bound]
......@@ -363,26 +405,26 @@ INSTANTIATE_TEST_CASE_P(
TEST(all_close_f, mantissa_8_near_0)
{
// 0.f, the ground-truth value
float expected = bits_to_float("00000000000000000000000000000000");
float expected = bits_to_float("0 00000000 000 0000 0000 0000 0000 0000");
float computed;
// ~3.67342E-40, the exact upper bound
computed = bits_to_float("00000000000001000000000000000000");
computed = bits_to_float("0 00000000 000 0100 0000 0000 0000 0000");
EXPECT_TRUE(test::close_f(expected, computed, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
// ~3.67343E-40, the next representable number bigger than upper bound
computed = bits_to_float("00000000000001000000000000000001");
computed = bits_to_float("0 00000000 000 0100 0000 0000 0000 0001");
EXPECT_FALSE(test::close_f(expected, computed, 8, 2));
EXPECT_FALSE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
// ~-3.67342E-40, the exact lower bound
computed = bits_to_float("10000000000001000000000000000000");
computed = bits_to_float("1 00000000 000 0100 0000 0000 0000 0000");
EXPECT_TRUE(test::close_f(expected, computed, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
// ~-3.67343E-40, the next representable number smaller than lower bound
computed = bits_to_float("10000000000001000000000000000001");
computed = bits_to_float("1 00000000 000 0100 0000 0000 0000 0001");
EXPECT_FALSE(test::close_f(expected, computed, 8, 2));
EXPECT_FALSE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
}
......@@ -394,8 +436,10 @@ TEST(all_close_f, mantissa_8_near_0)
// Targeted bit
// |
// v
// 2 3 4 5 6 (error allowed in 6th bit or later, w/ implicit leading bit)
// s e e e e e e e e m m m m m m m m m m m m m m m m m m m m m m m
// =>| 8 |
// =>| 8 | (8 w/ implicit leading bit)
// ^
// | 2 |<=
//
// [Upper bound]
......@@ -424,26 +468,26 @@ TEST(all_close_f, mantissa_8_near_0)
TEST(all_close_f, mantissa_8_near_n0)
{
// 0.f, the ground-truth value
float expected = bits_to_float("10000000000000000000000000000000");
float expected = bits_to_float("1 00000000 000 0000 0000 0000 0000 0000");
float computed;
// ~3.67342E-40, the exact upper bound
computed = bits_to_float("00000000000001000000000000000000");
computed = bits_to_float("0 00000000 000 0100 0000 0000 0000 0000");
EXPECT_TRUE(test::close_f(expected, computed, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
// ~3.67343E-40, the next representable number bigger than upper bound
computed = bits_to_float("00000000000001000000000000000001");
computed = bits_to_float("0 00000000 000 0100 0000 0000 0000 0001");
EXPECT_FALSE(test::close_f(expected, computed, 8, 2));
EXPECT_FALSE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
// ~-3.67342E-40, the exact lower bound
computed = bits_to_float("10000000000001000000000000000000");
computed = bits_to_float("1 00000000 000 0100 0000 0000 0000 0000");
EXPECT_TRUE(test::close_f(expected, computed, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
// ~-3.67343E-40, the next representable number smaller than lower bound
computed = bits_to_float("10000000000001000000000000000001");
computed = bits_to_float("1 00000000 000 0100 0000 0000 0000 0001");
EXPECT_FALSE(test::close_f(expected, computed, 8, 2));
EXPECT_FALSE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
}
......@@ -455,8 +499,10 @@ TEST(all_close_f, mantissa_8_near_n0)
// Targeted bit
// |
// v
// 2 3 4 5 6 (error allowed in 6th bit or later, w/ implicit leading bit)
// s e e e e e e e e m m m m m m m m m m m m m m m m m m m m m m m
// =>| 8 |
// =>| 8 | (8 w/ implicit leading bit)
// ^
// | 2 |<=
//
// [Upper bound]
......@@ -479,26 +525,26 @@ TEST(all_close_f, mantissa_8_near_n0)
TEST(all_close_f, mantissa_8_near_1)
{
// 1.f, the ground-truth value
float expected = bits_to_float("00111111100000000000000000000000");
float expected = bits_to_float("0 01111111 000 0000 0000 0000 0000 0000");
float computed;
// 1.03125f, the exact upper bound
computed = bits_to_float("00111111100001000000000000000000");
computed = bits_to_float("0 01111111 000 0100 0000 0000 0000 0000");
EXPECT_TRUE(test::close_f(expected, computed, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
// 1.031250119f, the next representable number bigger than upper bound
computed = bits_to_float("00111111100001000000000000000001");
computed = bits_to_float("0 01111111 000 0100 0000 0000 0000 0001");
EXPECT_FALSE(test::close_f(expected, computed, 8, 2));
EXPECT_FALSE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
// 0.984375f, the exact lower bound
computed = bits_to_float("00111111011111000000000000000000");
computed = bits_to_float("0 01111110 111 1100 0000 0000 0000 0000");
EXPECT_TRUE(test::close_f(expected, computed, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
// 0.9843749404f, the next representable number smaller than lower bound
computed = bits_to_float("00111111011110111111111111111111");
computed = bits_to_float("0 01111110 111 1011 1111 1111 1111 1111");
EXPECT_FALSE(test::close_f(expected, computed, 8, 2));
EXPECT_FALSE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
}
......@@ -510,8 +556,10 @@ TEST(all_close_f, mantissa_8_near_1)
// Targeted bit
// |
// v
// 2 3 4 5 6 (error allowed in 6th bit or later, w/ implicit leading bit)
// s e e e e e e e e m m m m m m m m m m m m m m m m m m m m m m m
// =>| 8 |
// =>| 8 | (8 w/ implicit leading bit)
// ^
// | 2 |<=
//
// [Upper bound]
......@@ -534,26 +582,26 @@ TEST(all_close_f, mantissa_8_near_1)
TEST(all_close_f, mantissa_8_near_n1)
{
// -1.f, the ground-truth value
float expected = bits_to_float("10111111100000000000000000000000");
float expected = bits_to_float("1 01111111 000 0000 0000 0000 0000 0000");
float computed;
// -0.984375f, the exact upper bound
computed = bits_to_float("10111111011111000000000000000000");
computed = bits_to_float("1 01111110 111 1100 0000 0000 0000 0000");
EXPECT_TRUE(test::close_f(expected, computed, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
// -0.984374940395355224609375f, the next representable number bigger than upper bound
computed = bits_to_float("10111111011110111111111111111111");
computed = bits_to_float("1 01111110 111 1011 1111 1111 1111 1111");
EXPECT_FALSE(test::close_f(expected, computed, 8, 2));
EXPECT_FALSE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
// -1.03125f, the exact lower bound
computed = bits_to_float("10111111100001000000000000000000");
computed = bits_to_float("1 01111111 000 0100 0000 0000 0000 0000");
EXPECT_TRUE(test::close_f(expected, computed, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
// -1.03125011920928955078125f, the next representable number smaller than lower bound
computed = bits_to_float("10111111100001000000000000000001");
computed = bits_to_float("1 01111111 000 0100 0000 0000 0000 0001");
EXPECT_FALSE(test::close_f(expected, computed, 8, 2));
EXPECT_FALSE(test::all_close_f(vector<float>({expected}), vector<float>({computed}), 8, 2));
}
......@@ -564,8 +612,10 @@ TEST(all_close_f, mantissa_8_near_n1)
// Targeted bit
// |
// v
// 2 3 4 5 6 (error allowed in 6th bit or later, w/ implicit leading bit)
// s e e e e e e e e m m m m m m m m m m m m m m m m m m m m m m m
// =>| 8 |
// =>| 8 | (8 w/ implicit leading bit)
// ^
// | 2 |<=
TEST(all_close_f, mantissa_8_near_0_1_10_100_1000)
{
......@@ -576,11 +626,13 @@ TEST(all_close_f, mantissa_8_near_0_1_10_100_1000)
float smaller_than_lower_bound;
// Bounds around 0: 0 +- 3.67e-40
expected = 0.f; // 00000000000000000000000000000000
upper_bound = 3.67342e-40f; // 00000000000001000000000000000000, approximated
bigger_than_upper_bound = 3.67343e-40f; // 00000000000001000000000000000001, approximated
lower_bound = -3.67342e-40f; // 10000000000001000000000000000000, approximated
smaller_than_lower_bound = 3.67343e-40f; // 10000000000001000000000000000001, approximated
expected = 0.f; // 0 00000000 000 0000 0000 0000 0000 0000
upper_bound = 3.67342e-40f; // 0 00000000 000 0100 0000 0000 0000 0000, approximated
bigger_than_upper_bound =
3.67343e-40f; // 0 00000000 000 0100 0000 0000 0000 0001, approximated
lower_bound = -3.67342e-40f; // 1 00000000 000 0100 0000 0000 0000 0000, approximated
smaller_than_lower_bound =
3.67343e-40f; // 1 00000000 000 0100 0000 0000 0000 0001, approximated
EXPECT_TRUE(test::close_f(expected, upper_bound, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({upper_bound}), 8, 2));
EXPECT_FALSE(test::close_f(expected, bigger_than_upper_bound, 8, 2));
......@@ -593,11 +645,11 @@ TEST(all_close_f, mantissa_8_near_0_1_10_100_1000)
vector<float>({expected}), vector<float>({smaller_than_lower_bound}), 8, 2));
// Bounds around 1: 1 +- 0.03
expected = 1.f; // 00111111100000000000000000000000
upper_bound = 1.03125f; // 00111111100001000000000000000000
bigger_than_upper_bound = 1.031250119f; // 00111111100001000000000000000001
lower_bound = 0.984375f; // 00111111011111000000000000000000
smaller_than_lower_bound = 0.9843749404f; // 00111111011110111111111111111111
expected = 1.f; // 0 01111111 000 0000 0000 0000 0000 0000
upper_bound = 1.03125f; // 0 01111111 000 0100 0000 0000 0000 0000
bigger_than_upper_bound = 1.031250119f; // 0 01111111 000 0100 0000 0000 0000 0001
lower_bound = 0.984375f; // 0 01111110 111 1100 0000 0000 0000 0000
smaller_than_lower_bound = 0.9843749404f; // 0 01111110 111 1011 1111 1111 1111 1111
EXPECT_TRUE(test::close_f(expected, upper_bound, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({upper_bound}), 8, 2));
EXPECT_FALSE(test::close_f(expected, bigger_than_upper_bound, 8, 2));
......@@ -610,11 +662,11 @@ TEST(all_close_f, mantissa_8_near_0_1_10_100_1000)
vector<float>({expected}), vector<float>({smaller_than_lower_bound}), 8, 2));
// Bounds around 10: 10 +- 0.25
expected = 10.f; // 01000001001000000000000000000000
upper_bound = 10.25f; // 01000001001001000000000000000000
bigger_than_upper_bound = 10.25000095367431640625f; // 01000001001001000000000000000001
lower_bound = 9.75f; // 01000001000111000000000000000000
smaller_than_lower_bound = 9.74999904632568359375f; // 01000001000110111111111111111111
expected = 10.f; // 0 10000010 010 0000 0000 0000 0000 0000
upper_bound = 10.25f; // 0 10000010 010 0100 0000 0000 0000 0000
bigger_than_upper_bound = 10.25000095367431640625f; // 0 10000010 010 0100 0000 0000 0000 0001
lower_bound = 9.75f; // 0 10000010 001 1100 0000 0000 0000 0000
smaller_than_lower_bound = 9.74999904632568359375f; // 0 10000010 001 1011 1111 1111 1111 1111
EXPECT_TRUE(test::close_f(expected, upper_bound, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({upper_bound}), 8, 2));
EXPECT_FALSE(test::close_f(expected, bigger_than_upper_bound, 8, 2));
......@@ -627,11 +679,11 @@ TEST(all_close_f, mantissa_8_near_0_1_10_100_1000)
vector<float>({expected}), vector<float>({smaller_than_lower_bound}), 8, 2));
// Bounds around 100: 100 +- 2
expected = 100.f; // 01000010110010000000000000000000
upper_bound = 102.f; // 01000010110011000000000000000000
bigger_than_upper_bound = 102.00000762939453125f; // 01000010110011000000000000000001
lower_bound = 98.0f; // 01000010110001000000000000000000
smaller_than_lower_bound = 97.99999237060546875f; // 01000010110000111111111111111111
expected = 100.f; // 0 10000101 100 1000 0000 0000 0000 0000
upper_bound = 102.f; // 0 10000101 100 1100 0000 0000 0000 0000
bigger_than_upper_bound = 102.00000762939453125f; // 0 10000101 100 1100 0000 0000 0000 0001
lower_bound = 98.0f; // 0 10000101 100 0100 0000 0000 0000 0000
smaller_than_lower_bound = 97.99999237060546875f; // 0 10000101 100 0011 1111 1111 1111 1111
EXPECT_TRUE(test::close_f(expected, upper_bound, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({upper_bound}), 8, 2));
EXPECT_FALSE(test::close_f(expected, bigger_than_upper_bound, 8, 2));
......@@ -644,11 +696,11 @@ TEST(all_close_f, mantissa_8_near_0_1_10_100_1000)
vector<float>({expected}), vector<float>({smaller_than_lower_bound}), 8, 2));
// Bounds around 1000: 1000 +- 16
expected = 1000.f; // 01000100011110100000000000000000
upper_bound = 1016.f; // 01000100011111100000000000000000
bigger_than_upper_bound = 1016.00006103515625f; // 01000100011111100000000000000001
lower_bound = 984.0f; // 01000100011101100000000000000000
smaller_than_lower_bound = 983.99993896484375f; // 01000100011101011111111111111111
expected = 1000.f; // 0 10001000 111 1010 0000 0000 0000 0000
upper_bound = 1016.f; // 0 10001000 111 1110 0000 0000 0000 0000
bigger_than_upper_bound = 1016.00006103515625f; // 0 10001000 111 1110 0000 0000 0000 0001
lower_bound = 984.0f; // 0 10001000 111 0110 0000 0000 0000 0000
smaller_than_lower_bound = 983.99993896484375f; // 0 10001000 111 0101 1111 1111 1111 1111
EXPECT_TRUE(test::close_f(expected, upper_bound, 8, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({upper_bound}), 8, 2));
EXPECT_FALSE(test::close_f(expected, bigger_than_upper_bound, 8, 2));
......@@ -666,9 +718,11 @@ TEST(all_close_f, mantissa_8_near_0_1_10_100_1000)
//
// Targeted bit
// |
// v
// (22 bits must match, w/ implicit leading bit) v
// 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2
// s e e e e e e e e m m m m m m m m m m m m m m m m m m m m m m m
// =>| 24 |
// =>| 24 (w/ implicit leading bit) |
// ^
// | 2 |<=
TEST(all_close_f, mantissa_24_near_0_1_10_100_1000)
{
......@@ -680,10 +734,10 @@ TEST(all_close_f, mantissa_24_near_0_1_10_100_1000)
// Bounds around 0: 0 +- 5.6e-45
expected = 0.f;
upper_bound = bits_to_float("00000000000000000000000000000100");
bigger_than_upper_bound = bits_to_float("00000000000000000000000000000101");
lower_bound = bits_to_float("10000000000000000000000000000100");
smaller_than_lower_bound = bits_to_float("10000000000000000000000000000101");
upper_bound = bits_to_float("0 00000000 000 0000 0000 0000 0000 0100");
bigger_than_upper_bound = bits_to_float("0 00000000 000 0000 0000 0000 0000 0101");
lower_bound = bits_to_float("1 00000000 000 0000 0000 0000 0000 0100");
smaller_than_lower_bound = bits_to_float("1 00000000 000 0000 0000 0000 0000 0101");
EXPECT_TRUE(test::close_f(expected, upper_bound, 24, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({upper_bound}), 24, 2));
EXPECT_FALSE(test::close_f(expected, bigger_than_upper_bound, 24, 2));
......@@ -697,10 +751,10 @@ TEST(all_close_f, mantissa_24_near_0_1_10_100_1000)
// Bounds around 1: 1 +- 4.77e-7
expected = 1.f;
upper_bound = bits_to_float("00111111100000000000000000000100");
bigger_than_upper_bound = bits_to_float("00111111100000000000000000000101");
lower_bound = bits_to_float("00111111011111111111111111111100");
smaller_than_lower_bound = bits_to_float("00111111011111111111111111111011");
upper_bound = bits_to_float("0 01111111 000 0000 0000 0000 0000 0100");
bigger_than_upper_bound = bits_to_float("0 01111111 000 0000 0000 0000 0000 0101");
lower_bound = bits_to_float("0 01111110 111 1111 1111 1111 1111 1100");
smaller_than_lower_bound = bits_to_float("0 01111110 111 1111 1111 1111 1111 1011");
EXPECT_TRUE(test::close_f(expected, upper_bound, 24, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({upper_bound}), 24, 2));
EXPECT_FALSE(test::close_f(expected, bigger_than_upper_bound, 24, 2));
......@@ -714,10 +768,10 @@ TEST(all_close_f, mantissa_24_near_0_1_10_100_1000)
// Bounds around 10: 10 +- 3.81e-6
expected = 10.f;
upper_bound = bits_to_float("01000001001000000000000000000100");
bigger_than_upper_bound = bits_to_float("01000001001000000000000000000101");
lower_bound = bits_to_float("01000001000111111111111111111100");
smaller_than_lower_bound = bits_to_float("01000001000111111111111111111011");
upper_bound = bits_to_float("0 10000010 010 0000 0000 0000 0000 0100");
bigger_than_upper_bound = bits_to_float("0 10000010 010 0000 0000 0000 0000 0101");
lower_bound = bits_to_float("0 10000010 001 1111 1111 1111 1111 1100");
smaller_than_lower_bound = bits_to_float("0 10000010 001 1111 1111 1111 1111 1011");
EXPECT_TRUE(test::close_f(expected, upper_bound, 24, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({upper_bound}), 24, 2));
EXPECT_FALSE(test::close_f(expected, bigger_than_upper_bound, 24, 2));
......@@ -731,10 +785,10 @@ TEST(all_close_f, mantissa_24_near_0_1_10_100_1000)
// Bounds around 100: 100 +- 3.05e-5
expected = 100.f;
upper_bound = bits_to_float("01000010110010000000000000000100");
bigger_than_upper_bound = bits_to_float("01000010110010000000000000000101");
lower_bound = bits_to_float("01000010110001111111111111111100");
smaller_than_lower_bound = bits_to_float("01000010110001111111111111111011");
upper_bound = bits_to_float("0 10000101 100 1000 0000 0000 0000 0100");
bigger_than_upper_bound = bits_to_float("0 10000101 100 1000 0000 0000 0000 0101");
lower_bound = bits_to_float("0 10000101 100 0111 1111 1111 1111 1100");
smaller_than_lower_bound = bits_to_float("0 10000101 100 0111 1111 1111 1111 1011");
EXPECT_TRUE(test::close_f(expected, upper_bound, 24, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({upper_bound}), 24, 2));
EXPECT_FALSE(test::close_f(expected, bigger_than_upper_bound, 24, 2));
......@@ -748,10 +802,10 @@ TEST(all_close_f, mantissa_24_near_0_1_10_100_1000)
// Bounds around 1000: 1000 +- 2.44e-4
expected = 1000.f;
upper_bound = bits_to_float("01000100011110100000000000000100");
bigger_than_upper_bound = bits_to_float("01000100011110100000000000000101");
lower_bound = bits_to_float("01000100011110011111111111111100");
smaller_than_lower_bound = bits_to_float("01000100011110011111111111111011");
upper_bound = bits_to_float("0 10001000 111 1010 0000 0000 0000 0100");
bigger_than_upper_bound = bits_to_float("0 10001000 111 1010 0000 0000 0000 0101");
lower_bound = bits_to_float("0 10001000 111 1001 1111 1111 1111 1100");
smaller_than_lower_bound = bits_to_float("0 10001000 111 1001 1111 1111 1111 1011");
EXPECT_TRUE(test::close_f(expected, upper_bound, 24, 2));
EXPECT_TRUE(test::all_close_f(vector<float>({expected}), vector<float>({upper_bound}), 24, 2));
EXPECT_FALSE(test::close_f(expected, bigger_than_upper_bound, 24, 2));
......
test/util/all_close_f.cpp
View file @ 03bbeb90
......@@ -295,17 +295,19 @@ uint32_t test::matching_mantissa_bits(uint64_t distance)
<< " mantissa bits.\n";
}
msg << "passing criteria: " << (mantissa_bits - tolerance_bits) << " mantissa bits ("
<< mantissa_bits << " mantissa bits w/ " << tolerance_bits << " tolerance bits)\n";
msg << "passing criteria - mismatch allowed @ mantissa bit: "
<< (mantissa_bits - tolerance_bits) << " or later (" << mantissa_bits
<< " mantissa bits w/ " << tolerance_bits << " tolerance bits)\n";
msg << std::setprecision(std::numeric_limits<long double>::digits10 + 1)
<< "tightest match: " << matching_mantissa_bits(min_distance) << " mantissa bits ("
<< a[min_distance_index] << " vs " << b[min_distance_index] << " at [" << min_distance_index
<< "])\n";
<< "tightest match - mismatch occurred @ mantissa bit: "
<< matching_mantissa_bits(min_distance) << " or next bit (" << a[min_distance_index]
<< " vs " << b[min_distance_index] << " at [" << min_distance_index << "])\n";
msg << std::setprecision(std::numeric_limits<long double>::digits10 + 1)
<< "loosest match: " << matching_mantissa_bits(max_distance) << " mantissa bits ("
<< a[max_distance_index] << " vs " << b[max_distance_index] << " at [" << max_distance_index
<< "])\n";
msg << "median match: " << matching_mantissa_bits(median_distance) << " mantissa bits\n";
<< "loosest match - mismatch occurred @ mantissa bit: "
<< matching_mantissa_bits(max_distance) << " or next bit (" << a[max_distance_index]
<< " vs " << b[max_distance_index] << " at [" << max_distance_index << "])\n";
msg << "median match - mismatch occurred @ mantissa bit: "
<< matching_mantissa_bits(median_distance) << " or next bit\n";
::testing::AssertionResult res =
rc ? ::testing::AssertionSuccess() : ::testing::AssertionFailure();
......@@ -383,17 +385,19 @@ uint32_t test::matching_mantissa_bits(uint64_t distance)
<< " mantissa bits.\n";
}
msg << "passing criteria: " << (mantissa_bits - tolerance_bits) << " mantissa bits ("
<< mantissa_bits << " mantissa bits w/ " << tolerance_bits << " tolerance bits)\n";
msg << "passing criteria - mismatch allowed @ mantissa bit: "
<< (mantissa_bits - tolerance_bits) << " or later (" << mantissa_bits
<< " mantissa bits w/ " << tolerance_bits << " tolerance bits)\n";
msg << std::setprecision(std::numeric_limits<long double>::digits10 + 1)
<< "tightest match: " << matching_mantissa_bits(min_distance) << " mantissa bits ("
<< a[min_distance_index] << " vs " << b[min_distance_index] << " at [" << min_distance_index
<< "])\n";
<< "tightest match - mismatch occurred @ mantissa bit: "
<< matching_mantissa_bits(min_distance) << " or next bit (" << a[min_distance_index]
<< " vs " << b[min_distance_index] << " at [" << min_distance_index << "])\n";
msg << std::setprecision(std::numeric_limits<long double>::digits10 + 1)
<< "loosest match: " << matching_mantissa_bits(max_distance) << " mantissa bits ("
<< a[max_distance_index] << " vs " << b[max_distance_index] << " at [" << max_distance_index
<< "])\n";
msg << "median match: " << matching_mantissa_bits(median_distance) << " mantissa bits\n";
<< "loosest match - mismatch occurred @ mantissa bit: "
<< matching_mantissa_bits(max_distance) << " or next bit (" << a[max_distance_index]
<< " vs " << b[max_distance_index] << " at [" << max_distance_index << "])\n";
msg << "median match - mismatch occurred @ mantissa bit: "
<< matching_mantissa_bits(median_distance) << " or next bit\n";
::testing::AssertionResult res =
rc ? ::testing::AssertionSuccess() : ::testing::AssertionFailure();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment