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
|
///////////////////////////////////////////////////////////////////////////////
// Copyright 2015 John Maddock. 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)
#ifndef BOOST_MATH_TEST_MIXED_HPP
#define BOOST_MATH_TEST_MIXED_HPP
#include "test.hpp"
template <class Big, class Small>
void test_floats(const std::integral_constant<bool, true>)
{
Big big_val = boost::math::constants::pi<Big>();
Small small = boost::math::constants::pi<Small>();
Small small2 = boost::math::constants::e<Small>();
Big r;
r = big_val + small;
BOOST_CHECK_EQUAL(r, big_val + Big(small));
r = small + big_val;
BOOST_CHECK_EQUAL(r, big_val + Big(small));
r = small + small;
BOOST_CHECK_EQUAL(r, Small(small + small));
r = big_val - small;
BOOST_CHECK_EQUAL(r, big_val - Big(small));
r = small - big_val;
BOOST_CHECK_EQUAL(r, Big(small) - big_val);
r = small - small2;
BOOST_CHECK_EQUAL(r, Small(small - small2));
r = big_val * small;
BOOST_CHECK_EQUAL(r, big_val * Big(small));
r = small * big_val;
BOOST_CHECK_EQUAL(r, Big(small) * big_val);
r = small * small2;
BOOST_CHECK_EQUAL(r, Small(small * small2));
r = big_val / small;
BOOST_CHECK_EQUAL(r, big_val / Big(small));
r = small / big_val;
BOOST_CHECK_EQUAL(r, Big(small) / big_val);
r = small / small2;
BOOST_CHECK_EQUAL(r, Small(small / small2));
}
template <class Big, class Small>
void test_floats(const std::integral_constant<bool, false>){}
template <class Big, class Small>
void test()
{
Big big_val = 1;
big_val += std::numeric_limits<Big>::epsilon();
Small small_val = 1;
BOOST_CHECK_EQUAL(big_val == small_val, false);
BOOST_CHECK_EQUAL(big_val <= small_val, false);
BOOST_CHECK_EQUAL(big_val >= small_val, true);
BOOST_CHECK_EQUAL(big_val < small_val, false);
BOOST_CHECK_EQUAL(big_val > small_val, true);
BOOST_CHECK_EQUAL(big_val != small_val, true);
BOOST_CHECK_EQUAL(small_val == big_val, false);
BOOST_CHECK_EQUAL(small_val <= big_val, true);
BOOST_CHECK_EQUAL(small_val >= big_val, false);
BOOST_CHECK_EQUAL(small_val < big_val, true);
BOOST_CHECK_EQUAL(small_val > big_val, false);
BOOST_CHECK_EQUAL(small_val != big_val, true);
// Again with expression templates, on one the other, or both args:
BOOST_CHECK_EQUAL(big_val == small_val * 1, false);
BOOST_CHECK_EQUAL(big_val <= small_val * 1, false);
BOOST_CHECK_EQUAL(big_val >= small_val * 1, true);
BOOST_CHECK_EQUAL(big_val < small_val * 1, false);
BOOST_CHECK_EQUAL(big_val > small_val * 1, true);
BOOST_CHECK_EQUAL(big_val != small_val * 1, true);
BOOST_CHECK_EQUAL(small_val * 1 == big_val, false);
BOOST_CHECK_EQUAL(small_val * 1 <= big_val, true);
BOOST_CHECK_EQUAL(small_val * 1 >= big_val, false);
BOOST_CHECK_EQUAL(small_val * 1 < big_val, true);
BOOST_CHECK_EQUAL(small_val * 1 > big_val, false);
BOOST_CHECK_EQUAL(small_val * 1 != big_val, true);
BOOST_CHECK_EQUAL(big_val * 1 == small_val, false);
BOOST_CHECK_EQUAL(big_val * 1 <= small_val, false);
BOOST_CHECK_EQUAL(big_val * 1 >= small_val, true);
BOOST_CHECK_EQUAL(big_val * 1 < small_val, false);
BOOST_CHECK_EQUAL(big_val * 1 > small_val, true);
BOOST_CHECK_EQUAL(big_val * 1 != small_val, true);
BOOST_CHECK_EQUAL(small_val == big_val * 1, false);
BOOST_CHECK_EQUAL(small_val <= big_val * 1, true);
BOOST_CHECK_EQUAL(small_val >= big_val * 1, false);
BOOST_CHECK_EQUAL(small_val < big_val * 1, true);
BOOST_CHECK_EQUAL(small_val > big_val * 1, false);
BOOST_CHECK_EQUAL(small_val != big_val * 1, true);
BOOST_CHECK_EQUAL(big_val * 1 == small_val * 1, false);
BOOST_CHECK_EQUAL(big_val * 1 <= small_val * 1, false);
BOOST_CHECK_EQUAL(big_val * 1 >= small_val * 1, true);
BOOST_CHECK_EQUAL(big_val * 1 < small_val * 1, false);
BOOST_CHECK_EQUAL(big_val * 1 > small_val * 1, true);
BOOST_CHECK_EQUAL(big_val * 1 != small_val * 1, true);
BOOST_CHECK_EQUAL(small_val * 1 == big_val * 1, false);
BOOST_CHECK_EQUAL(small_val * 1 <= big_val * 1, true);
BOOST_CHECK_EQUAL(small_val * 1 >= big_val * 1, false);
BOOST_CHECK_EQUAL(small_val * 1 < big_val * 1, true);
BOOST_CHECK_EQUAL(small_val * 1 > big_val * 1, false);
BOOST_CHECK_EQUAL(small_val * 1 != big_val * 1, true);
BOOST_CHECK_EQUAL(small_val + big_val, Big(small_val) + big_val);
BOOST_CHECK_EQUAL(small_val - big_val, Big(small_val) - big_val);
BOOST_CHECK_EQUAL(small_val * big_val, Big(small_val) * big_val);
BOOST_CHECK_EQUAL(small_val / big_val, Big(small_val) / big_val);
BOOST_CHECK_EQUAL(big_val + small_val, big_val + Big(small_val));
BOOST_CHECK_EQUAL(big_val - small_val, big_val - Big(small_val));
BOOST_CHECK_EQUAL(big_val * small_val, big_val * Big(small_val));
BOOST_CHECK_EQUAL(big_val / small_val, big_val / Big(small_val));
// Again with expression templates, on one the other, or both args:
BOOST_CHECK_EQUAL(small_val + (big_val * 1), Big(small_val) + (big_val * 1));
BOOST_CHECK_EQUAL(small_val - (big_val * 1), Big(small_val) - (big_val * 1));
BOOST_CHECK_EQUAL(small_val * (big_val * 1), Big(small_val) * (big_val * 1));
BOOST_CHECK_EQUAL(small_val / (big_val * 1), Big(small_val) / (big_val * 1));
BOOST_CHECK_EQUAL((big_val * 1) + small_val, (big_val * 1) + Big(small_val));
BOOST_CHECK_EQUAL((big_val * 1) - small_val, (big_val * 1) - Big(small_val));
BOOST_CHECK_EQUAL((big_val * 1) * small_val, (big_val * 1) * Big(small_val));
BOOST_CHECK_EQUAL((big_val * 1) / small_val, (big_val * 1) / Big(small_val));
BOOST_CHECK_EQUAL((small_val * 1) + big_val, Big((small_val * 1)) + big_val);
BOOST_CHECK_EQUAL((small_val * 1) - big_val, Big((small_val * 1)) - big_val);
BOOST_CHECK_EQUAL((small_val * 1) * big_val, Big((small_val * 1)) * big_val);
BOOST_CHECK_EQUAL((small_val * 1) / big_val, Big((small_val * 1)) / big_val);
BOOST_CHECK_EQUAL(big_val + (small_val * 1), big_val + Big((small_val * 1)));
BOOST_CHECK_EQUAL(big_val - (small_val * 1), big_val - Big((small_val * 1)));
BOOST_CHECK_EQUAL(big_val * (small_val * 1), big_val * Big((small_val * 1)));
BOOST_CHECK_EQUAL(big_val / (small_val * 1), big_val / Big((small_val * 1)));
BOOST_CHECK_EQUAL((small_val * 1) + (big_val * 1), Big((small_val * 1)) + (big_val * 1));
BOOST_CHECK_EQUAL((small_val * 1) - (big_val * 1), Big((small_val * 1)) - (big_val * 1));
BOOST_CHECK_EQUAL((small_val * 1) * (big_val * 1), Big((small_val * 1)) * (big_val * 1));
BOOST_CHECK_EQUAL((small_val * 1) / (big_val * 1), Big((small_val * 1)) / (big_val * 1));
BOOST_CHECK_EQUAL((big_val * 1) + (small_val * 1), (big_val * 1) + Big((small_val * 1)));
BOOST_CHECK_EQUAL((big_val * 1) - (small_val * 1), (big_val * 1) - Big((small_val * 1)));
BOOST_CHECK_EQUAL((big_val * 1) * (small_val * 1), (big_val * 1) * Big((small_val * 1)));
BOOST_CHECK_EQUAL((big_val * 1) / (small_val * 1), (big_val * 1) / Big((small_val * 1)));
big_val = 1;
big_val -= std::numeric_limits<Big>::epsilon();
BOOST_CHECK_EQUAL(big_val == small_val, false);
BOOST_CHECK_EQUAL(big_val <= small_val, true);
BOOST_CHECK_EQUAL(big_val >= small_val, false);
BOOST_CHECK_EQUAL(big_val < small_val, true);
BOOST_CHECK_EQUAL(big_val > small_val, false);
BOOST_CHECK_EQUAL(big_val != small_val, true);
BOOST_CHECK_EQUAL(small_val == big_val, false);
BOOST_CHECK_EQUAL(small_val <= big_val, false);
BOOST_CHECK_EQUAL(small_val >= big_val, true);
BOOST_CHECK_EQUAL(small_val < big_val, false);
BOOST_CHECK_EQUAL(small_val > big_val, true);
BOOST_CHECK_EQUAL(small_val != big_val, true);
// Again with expression templates, on one the other, or both args:
BOOST_CHECK_EQUAL(big_val == small_val * 1, false);
BOOST_CHECK_EQUAL(big_val <= small_val * 1, true);
BOOST_CHECK_EQUAL(big_val >= small_val * 1, false);
BOOST_CHECK_EQUAL(big_val < small_val * 1, true);
BOOST_CHECK_EQUAL(big_val > small_val * 1, false);
BOOST_CHECK_EQUAL(big_val != small_val * 1, true);
BOOST_CHECK_EQUAL(small_val * 1 == big_val, false);
BOOST_CHECK_EQUAL(small_val * 1 <= big_val, false);
BOOST_CHECK_EQUAL(small_val * 1 >= big_val, true);
BOOST_CHECK_EQUAL(small_val * 1 < big_val, false);
BOOST_CHECK_EQUAL(small_val * 1 > big_val, true);
BOOST_CHECK_EQUAL(small_val * 1 != big_val, true);
BOOST_CHECK_EQUAL(big_val * 1 == small_val, false);
BOOST_CHECK_EQUAL(big_val * 1 <= small_val, true);
BOOST_CHECK_EQUAL(big_val * 1 >= small_val, false);
BOOST_CHECK_EQUAL(big_val * 1 < small_val, true);
BOOST_CHECK_EQUAL(big_val * 1 > small_val, false);
BOOST_CHECK_EQUAL(big_val * 1 != small_val, true);
BOOST_CHECK_EQUAL(small_val == big_val * 1, false);
BOOST_CHECK_EQUAL(small_val <= big_val * 1, false);
BOOST_CHECK_EQUAL(small_val >= big_val * 1, true);
BOOST_CHECK_EQUAL(small_val < big_val * 1, false);
BOOST_CHECK_EQUAL(small_val > big_val * 1, true);
BOOST_CHECK_EQUAL(small_val != big_val * 1, true);
BOOST_CHECK_EQUAL(big_val * 1 == small_val * 1, false);
BOOST_CHECK_EQUAL(big_val * 1 <= small_val * 1, true);
BOOST_CHECK_EQUAL(big_val * 1 >= small_val * 1, false);
BOOST_CHECK_EQUAL(big_val * 1 < small_val * 1, true);
BOOST_CHECK_EQUAL(big_val * 1 > small_val * 1, false);
BOOST_CHECK_EQUAL(big_val * 1 != small_val * 1, true);
BOOST_CHECK_EQUAL(small_val * 1 == big_val * 1, false);
BOOST_CHECK_EQUAL(small_val * 1 <= big_val * 1, false);
BOOST_CHECK_EQUAL(small_val * 1 >= big_val * 1, true);
BOOST_CHECK_EQUAL(small_val * 1 < big_val * 1, false);
BOOST_CHECK_EQUAL(small_val * 1 > big_val * 1, true);
BOOST_CHECK_EQUAL(small_val * 1 != big_val * 1, true);
BOOST_CHECK_EQUAL(small_val + big_val, Big(small_val) + big_val);
BOOST_CHECK_EQUAL(small_val - big_val, Big(small_val) - big_val);
BOOST_CHECK_EQUAL(small_val * big_val, Big(small_val) * big_val);
BOOST_CHECK_EQUAL(small_val / big_val, Big(small_val) / big_val);
BOOST_CHECK_EQUAL(big_val + small_val, big_val + Big(small_val));
BOOST_CHECK_EQUAL(big_val - small_val, big_val - Big(small_val));
BOOST_CHECK_EQUAL(big_val * small_val, big_val * Big(small_val));
BOOST_CHECK_EQUAL(big_val / small_val, big_val / Big(small_val));
// Again with expression templates, on one the other, or both args:
BOOST_CHECK_EQUAL(small_val + (big_val * 1), Big(small_val) + (big_val * 1));
BOOST_CHECK_EQUAL(small_val - (big_val * 1), Big(small_val) - (big_val * 1));
BOOST_CHECK_EQUAL(small_val * (big_val * 1), Big(small_val) * (big_val * 1));
BOOST_CHECK_EQUAL(small_val / (big_val * 1), Big(small_val) / (big_val * 1));
BOOST_CHECK_EQUAL((big_val * 1) + small_val, (big_val * 1) + Big(small_val));
BOOST_CHECK_EQUAL((big_val * 1) - small_val, (big_val * 1) - Big(small_val));
BOOST_CHECK_EQUAL((big_val * 1) * small_val, (big_val * 1) * Big(small_val));
BOOST_CHECK_EQUAL((big_val * 1) / small_val, (big_val * 1) / Big(small_val));
BOOST_CHECK_EQUAL((small_val * 1) + big_val, Big((small_val * 1)) + big_val);
BOOST_CHECK_EQUAL((small_val * 1) - big_val, Big((small_val * 1)) - big_val);
BOOST_CHECK_EQUAL((small_val * 1) * big_val, Big((small_val * 1)) * big_val);
BOOST_CHECK_EQUAL((small_val * 1) / big_val, Big((small_val * 1)) / big_val);
BOOST_CHECK_EQUAL(big_val + (small_val * 1), big_val + Big((small_val * 1)));
BOOST_CHECK_EQUAL(big_val - (small_val * 1), big_val - Big((small_val * 1)));
BOOST_CHECK_EQUAL(big_val * (small_val * 1), big_val * Big((small_val * 1)));
BOOST_CHECK_EQUAL(big_val / (small_val * 1), big_val / Big((small_val * 1)));
BOOST_CHECK_EQUAL((small_val * 1) + (big_val * 1), Big((small_val * 1)) + (big_val * 1));
BOOST_CHECK_EQUAL((small_val * 1) - (big_val * 1), Big((small_val * 1)) - (big_val * 1));
BOOST_CHECK_EQUAL((small_val * 1) * (big_val * 1), Big((small_val * 1)) * (big_val * 1));
BOOST_CHECK_EQUAL((small_val * 1) / (big_val * 1), Big((small_val * 1)) / (big_val * 1));
BOOST_CHECK_EQUAL((big_val * 1) + (small_val * 1), (big_val * 1) + Big((small_val * 1)));
BOOST_CHECK_EQUAL((big_val * 1) - (small_val * 1), (big_val * 1) - Big((small_val * 1)));
BOOST_CHECK_EQUAL((big_val * 1) * (small_val * 1), (big_val * 1) * Big((small_val * 1)));
BOOST_CHECK_EQUAL((big_val * 1) / (small_val * 1), (big_val * 1) / Big((small_val * 1)));
test_floats<Big, Small>(std::integral_constant<bool, boost::multiprecision::number_category<Big>::value == boost::multiprecision::number_kind_floating_point>());
}
#endif // BOOST_MATH_TEST_MIXED_HPP
|
