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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
|
// (C) Copyright Gennadiy Rozental 2001-2008.
// 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)
// See http://www.boost.org/libs/test for the library home page.
//
// File : $RCSfile$
//
// Version : $Revision$
//
// Description : defines algoirthms for comparing 2 floating point values
// ***************************************************************************
#ifndef BOOST_TEST_FLOATING_POINT_COMPARISON_HPP_071894GER
#define BOOST_TEST_FLOATING_POINT_COMPARISON_HPP_071894GER
// Boost.Test
#include <boost/test/detail/global_typedef.hpp>
#include <boost/test/utils/class_properties.hpp>
#include <boost/test/predicate_result.hpp>
// Boost
#include <boost/limits.hpp> // for std::numeric_limits
#include <boost/numeric/conversion/conversion_traits.hpp> // for numeric::conversion_traits
#include <boost/static_assert.hpp>
#include <boost/test/detail/suppress_warnings.hpp>
//____________________________________________________________________________//
namespace boost {
namespace test_tools {
using unit_test::readonly_property;
// ************************************************************************** //
// ************** floating_point_comparison_type ************** //
// ************************************************************************** //
enum floating_point_comparison_type {
FPC_STRONG, // "Very close" - equation 1' in docs, the default
FPC_WEAK // "Close enough" - equation 2' in docs.
};
// ************************************************************************** //
// ************** details ************** //
// ************************************************************************** //
namespace tt_detail {
// FPT is Floating-Point Type: float, double, long double or User-Defined.
template<typename FPT>
inline FPT
fpt_abs( FPT fpv )
{
return fpv < static_cast<FPT>(0) ? -fpv : fpv;
}
//____________________________________________________________________________//
template<typename FPT>
struct fpt_limits {
static FPT min_value()
{
return std::numeric_limits<FPT>::is_specialized
? (std::numeric_limits<FPT>::min)()
: 0;
}
static FPT max_value()
{
return std::numeric_limits<FPT>::is_specialized
? (std::numeric_limits<FPT>::max)()
: static_cast<FPT>(1000000); // for the our purpuses it doesn't really matter what value is returned here
}
};
//____________________________________________________________________________//
// both f1 and f2 are unsigned here
template<typename FPT>
inline FPT
safe_fpt_division( FPT f1, FPT f2 )
{
// Avoid overflow.
if( (f2 < static_cast<FPT>(1)) && (f1 > f2*fpt_limits<FPT>::max_value()) )
return fpt_limits<FPT>::max_value();
// Avoid underflow.
if( (f1 == static_cast<FPT>(0)) ||
((f2 > static_cast<FPT>(1)) && (f1 < f2*fpt_limits<FPT>::min_value())) )
return static_cast<FPT>(0);
return f1/f2;
}
//____________________________________________________________________________//
} // namespace tt_detail
// ************************************************************************** //
// ************** tolerance presentation types ************** //
// ************************************************************************** //
template<typename FPT>
struct percent_tolerance_t {
explicit percent_tolerance_t( FPT v ) : m_value( v ) {}
FPT m_value;
};
//____________________________________________________________________________//
template<typename Out,typename FPT>
Out& operator<<( Out& out, percent_tolerance_t<FPT> t )
{
return out << t.m_value;
}
//____________________________________________________________________________//
template<typename FPT>
inline percent_tolerance_t<FPT>
percent_tolerance( FPT v )
{
return percent_tolerance_t<FPT>( v );
}
//____________________________________________________________________________//
template<typename FPT>
struct fraction_tolerance_t {
explicit fraction_tolerance_t( FPT v ) : m_value( v ) {}
FPT m_value;
};
//____________________________________________________________________________//
template<typename Out,typename FPT>
Out& operator<<( Out& out, fraction_tolerance_t<FPT> t )
{
return out << t.m_value;
}
//____________________________________________________________________________//
template<typename FPT>
inline fraction_tolerance_t<FPT>
fraction_tolerance( FPT v )
{
return fraction_tolerance_t<FPT>( v );
}
//____________________________________________________________________________//
// ************************************************************************** //
// ************** close_at_tolerance ************** //
// ************************************************************************** //
template<typename FPT>
class close_at_tolerance {
public:
// Public typedefs
typedef bool result_type;
// Constructor
template<typename ToleranceBaseType>
explicit close_at_tolerance( percent_tolerance_t<ToleranceBaseType> tolerance,
floating_point_comparison_type fpc_type = FPC_STRONG )
: p_fraction_tolerance( tt_detail::fpt_abs( static_cast<FPT>(0.01)*tolerance.m_value ) )
, p_strong_or_weak( fpc_type == FPC_STRONG )
, m_report_modifier( 100. )
{}
template<typename ToleranceBaseType>
explicit close_at_tolerance( fraction_tolerance_t<ToleranceBaseType> tolerance,
floating_point_comparison_type fpc_type = FPC_STRONG )
: p_fraction_tolerance( tt_detail::fpt_abs( tolerance.m_value ) )
, p_strong_or_weak( fpc_type == FPC_STRONG )
, m_report_modifier( 1. )
{}
predicate_result operator()( FPT left, FPT right ) const
{
FPT diff = tt_detail::fpt_abs( left - right );
FPT d1 = tt_detail::safe_fpt_division( diff, tt_detail::fpt_abs( right ) );
FPT d2 = tt_detail::safe_fpt_division( diff, tt_detail::fpt_abs( left ) );
predicate_result res( p_strong_or_weak
? (d1 <= p_fraction_tolerance.get() && d2 <= p_fraction_tolerance.get())
: (d1 <= p_fraction_tolerance.get() || d2 <= p_fraction_tolerance.get()) );
if( !res )
res.message() << (( d1 <= p_fraction_tolerance.get() ? d2 : d1 ) * m_report_modifier);
return res;
}
// Public properties
readonly_property<FPT> p_fraction_tolerance;
readonly_property<bool> p_strong_or_weak;
private:
// Data members
FPT m_report_modifier;
};
//____________________________________________________________________________//
// ************************************************************************** //
// ************** check_is_close ************** //
// ************************************************************************** //
struct BOOST_TEST_DECL check_is_close_t {
// Public typedefs
typedef bool result_type;
template<typename FPT1, typename FPT2, typename ToleranceBaseType>
predicate_result
operator()( FPT1 left, FPT2 right, percent_tolerance_t<ToleranceBaseType> tolerance,
floating_point_comparison_type fpc_type = FPC_STRONG ) const
{
// deduce "better" type from types of arguments being compared
// if one type is floating and the second integral we use floating type and
// value of integral type is promoted to the floating. The same for float and double
// But we don't want to compare two values of integral types using this tool.
typedef typename numeric::conversion_traits<FPT1,FPT2>::supertype FPT;
BOOST_STATIC_ASSERT( !is_integral<FPT>::value );
close_at_tolerance<FPT> pred( tolerance, fpc_type );
return pred( left, right );
}
template<typename FPT1, typename FPT2, typename ToleranceBaseType>
predicate_result
operator()( FPT1 left, FPT2 right, fraction_tolerance_t<ToleranceBaseType> tolerance,
floating_point_comparison_type fpc_type = FPC_STRONG ) const
{
// same as in a comment above
typedef typename numeric::conversion_traits<FPT1,FPT2>::supertype FPT;
BOOST_STATIC_ASSERT( !is_integral<FPT>::value );
close_at_tolerance<FPT> pred( tolerance, fpc_type );
return pred( left, right );
}
};
namespace {
check_is_close_t const& check_is_close = unit_test::ut_detail::static_constant<check_is_close_t>::value;
}
//____________________________________________________________________________//
// ************************************************************************** //
// ************** check_is_small ************** //
// ************************************************************************** //
struct BOOST_TEST_DECL check_is_small_t {
// Public typedefs
typedef bool result_type;
template<typename FPT>
bool
operator()( FPT fpv, FPT tolerance ) const
{
return tt_detail::fpt_abs( fpv ) < tt_detail::fpt_abs( tolerance );
}
};
namespace {
check_is_small_t const& check_is_small = unit_test::ut_detail::static_constant<check_is_small_t>::value;
}
//____________________________________________________________________________//
} // namespace test_tools
} // namespace boost
//____________________________________________________________________________//
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_FLOATING_POINT_COMAPARISON_HPP_071894GER
|
