1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
// Copyright 2015-2018 Hans Dembinski
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/core/lightweight_test.hpp>
#include <boost/histogram/accumulators/fraction.hpp>
#include <boost/histogram/accumulators/ostream.hpp>
#include <boost/histogram/utility/wilson_interval.hpp>
#include <cmath>
#include <limits>
#include "is_close.hpp"
#include "str.hpp"
#include "throw_exception.hpp"
using namespace boost::histogram;
using namespace std::literals;
template <class T>
void run_tests() {
using f_t = accumulators::fraction<T>;
const double eps = std::numeric_limits<typename f_t::real_type>::epsilon();
{
f_t f;
BOOST_TEST_EQ(f.successes(), static_cast<T>(0));
BOOST_TEST_EQ(f.failures(), static_cast<T>(0));
BOOST_TEST(std::isnan(f.value()));
BOOST_TEST(std::isnan(f.variance()));
const auto ci = f.confidence_interval();
BOOST_TEST(std::isnan(ci.first));
BOOST_TEST(std::isnan(ci.second));
}
{
f_t f;
f(true);
BOOST_TEST_EQ(f.successes(), static_cast<T>(1));
BOOST_TEST_EQ(f.failures(), static_cast<T>(0));
BOOST_TEST_EQ(str(f), "fraction(1, 0)"s);
f(false);
BOOST_TEST_EQ(f.successes(), static_cast<T>(1));
BOOST_TEST_EQ(f.failures(), static_cast<T>(1));
BOOST_TEST_EQ(str(f), "fraction(1, 1)"s);
BOOST_TEST_EQ(str(f, 20), "fraction(1, 1) "s);
}
{
f_t f(3, 1);
BOOST_TEST_EQ(f.successes(), static_cast<T>(3));
BOOST_TEST_EQ(f.failures(), static_cast<T>(1));
BOOST_TEST_EQ(f.value(), 0.75f);
BOOST_TEST_IS_CLOSE(f.variance(), 0.75f * (1.0f - 0.75f) / 4.f, eps);
const auto ci = f.confidence_interval();
const auto expected = utility::wilson_interval<double>()(3, 1);
BOOST_TEST_IS_CLOSE(ci.first, expected.first, eps);
BOOST_TEST_IS_CLOSE(ci.second, expected.second, eps);
}
{
f_t f(0, 1);
BOOST_TEST_EQ(f.successes(), static_cast<T>(0));
BOOST_TEST_EQ(f.failures(), static_cast<T>(1));
BOOST_TEST_EQ(f.value(), 0.f);
BOOST_TEST_EQ(f.variance(), 0.f);
const auto ci = f.confidence_interval();
const auto expected = utility::wilson_interval<double>()(0, 1);
BOOST_TEST_IS_CLOSE(ci.first, expected.first, eps);
BOOST_TEST_IS_CLOSE(ci.second, expected.second, eps);
}
{
f_t f(1, 0);
BOOST_TEST_EQ(f.successes(), static_cast<T>(1));
BOOST_TEST_EQ(f.failures(), static_cast<T>(0));
BOOST_TEST_EQ(f.value(), 1.f);
BOOST_TEST_EQ(f.variance(), 0.f);
const auto ci = f.confidence_interval();
const auto expected = utility::wilson_interval<double>()(1, 0);
BOOST_TEST_IS_CLOSE(ci.first, expected.first, eps);
BOOST_TEST_IS_CLOSE(ci.second, expected.second, eps);
}
{
f_t a(1, 0), b(0, 1);
a += b;
BOOST_TEST_EQ(a, f_t(1, 1));
}
}
int main() {
run_tests<int>();
run_tests<double>();
run_tests<float>();
{
using f_t1 = accumulators::fraction<double>;
using f_t2 = accumulators::fraction<int>;
f_t1 f1(5, 3);
f_t2 f2(f1);
BOOST_TEST_EQ(f2.successes(), 5);
BOOST_TEST_EQ(f2.failures(), 3);
}
return boost::report_errors();
}
|
