File: test_mixed.hpp

package info (click to toggle)
boost1.62 1.62.0%2Bdfsg-4
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 686,420 kB
  • sloc: cpp: 2,609,004; xml: 972,558; ansic: 53,674; python: 32,437; sh: 8,829; asm: 3,071; cs: 2,121; makefile: 964; perl: 859; yacc: 472; php: 132; ruby: 94; f90: 55; sql: 13; csh: 6
file content (191 lines) | stat: -rw-r--r-- 11,282 bytes parent folder | download | duplicates (3) 
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
 
///////////////////////////////////////////////////////////////////////////////
//  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()
{
   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)));
}

#endif // BOOST_MATH_TEST_MIXED_HPP