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
|
// test_fuzzy.cc -- test driver for fuzzy<float> and fuzzy<double>
// $Header$
//
// main
// check<fp_t>
// check_binary<fp_t>
// check_unary<fp_t>
// *** template instantiations
#include <stdio.h>
#include <assert.h>
#include "stdc.h"
#include "util.hh"
using namespace AHFinderDirect;
using jtutil::error_exit;
using jtutil::fuzzy;
// prototypes
template <typename fp_t>
void check(const char* print_string,
fp_t x, fp_t y,
char xy_relation,
bool unary_flag,
bool x_is_fuzzy_integer,
int fuzzy_floor_of_x,
int fuzzy_ceiling_of_x);
template <typename fp_t>
void check_binary(fp_t x, fp_t y,
char xy_relation);
template <typename fp_t>
void check_unary(fp_t x,
bool x_is_fuzzy_integer,
int fuzzy_floor_of_x,
int fuzzy_ceiling_of_x);
//******************************************************************************
int main(int argc, const char* const argv[])
{
const bool print_flag = (argc > 1);
const char* double_str = print_flag ? "<double>" : NULL;
const char* float_str = print_flag ? "<float>" : NULL;
for (int ii = -10 ; ii <= +10 ; ++ii)
{
bool unary_flag = ((ii % 2) == 0); // the "correct answers"
// for the unary tests
// assume f and d are integral
float f = 0.5*float(ii);
double d = 0.5*double(ii);
int i = ii / 2;
printf("testing %+-4g +/- various things...\n", d);
// x y relation do unary is_integer floor ceiling
// (x,y) tests? (x) (x) (x)
check<double>(double_str, d - 0.49 , d, '<', unary_flag, false, i-1, i );
check<double>(double_str, d - 0.01 , d, '<', unary_flag, false, i-1, i );
check<double>(double_str, d - 1e-6 , d, '<', unary_flag, false, i-1, i );
check<double>(double_str, d - 1e-10, d, '<', unary_flag, false, i-1, i );
// ... distinct floating point numbers, but within tolerance
assert( d - 1e-14 != d );
check<double>(double_str, d - 1e-14, d, '=', unary_flag, true , i , i );
check<double>(double_str, d , d, '=', unary_flag, true , i , i );
// ... distinct floating point numbers, but within tolerance
assert( d + 1e-14 != d );
check<double>(double_str, d + 1e-14, d, '=', unary_flag, true , i , i );
check<double>(double_str, d + 1e-10, d, '>', unary_flag, false, i , i+1);
check<double>(double_str, d + 1e-6 , d, '>', unary_flag, false, i , i+1);
check<double>(double_str, d + 0.01 , d, '>', unary_flag, false, i , i+1);
check<double>(double_str, d + 0.49 , d, '>', unary_flag, false, i , i+1);
// x y relation do unary is_integer floor ceiling
// (x,y) tests? (x) (x) (x)
check<float> (float_str , f - 0.49 , f, '<', unary_flag, false, i-1, i );
check<float> (float_str , f - 0.01 , f, '<', unary_flag, false, i-1, i );
check<float> (float_str , f - 1e-4 , f, '<', unary_flag, false, i-1, i );
// ... distinct floating point numbers, but within tolerance
assert( f - 1e-6 != f );
check<float> (float_str , f - 1e-6 , f, '=', unary_flag, true , i , i );
// ... not enough precision to see as noninteger
check<float> (float_str , f - 1e-10, f, '=', unary_flag, true , i , i );
check<float> (float_str , f , f, '=', unary_flag, true , i , i );
// ... not enough precision to see as noninteger
check<float> (float_str , f + 1e-10, f, '=', unary_flag, true , i , i );
// ... distinct floating point numbers, but within tolerance
assert( f + 1e-6 != f );
check<float> (float_str , f + 1e-6 , f, '=', unary_flag, true , i , i );
check<float> (float_str , f + 0.01 , f, '>', unary_flag, false, i , i+1);
check<float> (float_str , f + 1e-4 , f, '>', unary_flag, false, i , i+1);
check<float> (float_str , f + 0.49 , f, '>', unary_flag, false, i , i+1);
if (print_flag)
then printf("\n");
}
printf("everything looks ok!\n");
return 0;
}
//******************************************************************************
//
// This function template is a driver to do all the tests for a single
// argument or pair of arguments. It calls check_binary<fp_t>() to do
// the binary-function tests, and optionally calls check_unary<fp_t>()
// to do the unary-function tests.
//
template <typename fp_t>
void check(const char* print_string,
fp_t x, fp_t y,
char xy_relation,
bool unary_flag,
bool x_is_fuzzy_integer, int fuzzy_floor_of_x,
int fuzzy_ceiling_of_x)
{
if (print_string != NULL)
then printf(" testing %s %s: x=%.15f y=%.15f\n",
print_string,
unary_flag ? "op(x,y) + op(x)" : "op(x,y) only ",
double(x), double(y));
check_binary<fp_t>(x, y, xy_relation);
if (unary_flag)
then check_unary(x,
x_is_fuzzy_integer, fuzzy_floor_of_x, fuzzy_ceiling_of_x);
}
//******************************************************************************
//
// This function template tests the binary relations
// fuzzy<fp_t>::EQ()
// fuzzy<fp_t>::NE()
// fuzzy<fp_t>::LT()
// fuzzy<fp_t>::GT()
// fuzzy<fp_t>::LE()
// fuzzy<fp_t>::GE()
// for a single argument.
//
// The xy_relation argument must be one of '<', '=', or '>', indicating
// the desired fuzzy relationship between the two arguments. The function
// infers the correct values of the binary functions from this.
//
template <typename fp_t>
void check_binary(fp_t x, fp_t y,
char xy_relation)
{
//
// basic properties which should always hold
//
// trichotomy (we have exactly one of <, =, >
assert( fuzzy<fp_t>::LT(x,y) + fuzzy<fp_t>::EQ(x,y) + fuzzy<fp_t>::GT(x,y)
== 1 );
// consistency of EQ() with NE()
assert( fuzzy<fp_t>::NE(x,y) == ! fuzzy<fp_t>::EQ(x,y) );
// consistency of LE() with LT() and EQ(), GE() with GT() and EQ()
assert( fuzzy<fp_t>::LE(x,y)
== (fuzzy<fp_t>::LT(x,y) || fuzzy<fp_t>::EQ(x,y)) );
assert( fuzzy<fp_t>::GE(x,y)
== (fuzzy<fp_t>::GT(x,y) || fuzzy<fp_t>::EQ(x,y)) );
//
// now check desired ordering relation
// ... by virtue of the previous tests, we need only check LT(), EQ(), and GT()
// ... in fact, by virtue of trichotomy (already tested), we really
// only need to assert() the true one for each case, but the slight
// redundancy of checking all of them seems nicer in this context
//
switch (xy_relation)
{
case '<':
assert( fuzzy<fp_t>::LT(x,y) == true );
assert( fuzzy<fp_t>::EQ(x,y) == false );
assert( fuzzy<fp_t>::GT(x,y) == false );
break;
case '=':
assert( fuzzy<fp_t>::LT(x,y) == false );
assert( fuzzy<fp_t>::EQ(x,y) == true );
assert( fuzzy<fp_t>::GT(x,y) == false );
break;
case '>':
assert( fuzzy<fp_t>::LT(x,y) == false );
assert( fuzzy<fp_t>::EQ(x,y) == false );
assert( fuzzy<fp_t>::GT(x,y) == true );
break;
default:
error_exit(PANIC_EXIT,
"***** check_binary<fp_t>: bad xy_relation=(int)'%c'\n"
" (this should never happen!)\n"
,
int(xy_relation)); /*NOTREACHED*/
}
}
//******************************************************************************
//
// This function template tests the unary functions
// fuzzy<fp_t>::is_integer()
// fuzzy<fp_t>::floor()
// fuzzy<fp_t>::ceiling()
// for a single argument.
//
template <typename fp_t>
void check_unary(fp_t x,
// remaining arguments are the correct results of...
bool x_is_fuzzy_integer, // fuzzy<fp_t>::is_integer(x)
int fuzzy_floor_of_x, // fuzzy<fp_t>::floor(x)
int fuzzy_ceiling_of_x) // fuzzy<fp_t>::ceiling(x)
{
assert( fuzzy<fp_t>::is_integer(x) == x_is_fuzzy_integer );
assert( fuzzy<fp_t>::floor(x) == fuzzy_floor_of_x );
assert( fuzzy<fp_t>::ceiling(x) == fuzzy_ceiling_of_x );
}
//******************************************************************************
//
// template instantiations for <float> and <double>
//
template void check<float>(const char*,
float, float,
char, bool, bool, int, int);
template void check<double>(const char*,
double, double,
char, bool, bool, int, int);
template void check_binary<float>(float, float, char);
template void check_binary<double>(double, double, char);
template void check_unary<float>(float, bool, int, int);
template void check_unary<double>(double, bool, int, int);
|
