1 /*
2 * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * Shared static test methods for numerical tests. Sharing these
26 * helper test methods avoids repeated functions in the various test
27 * programs. The test methods return 1 for a test failure and 0 for
28 * success. The order of arguments to the test methods is generally
29 * the test name, followed by the test arguments, the computed result,
30 * and finally the expected result.
31 */
32
33 public class Tests {
34 private Tests(){}; // do not instantiate
35
36 public static String toHexString(float f) {
37 if (!Float.isNaN(f))
38 return Float.toHexString(f);
39 else
40 return "NaN(0x" + Integer.toHexString(Float.floatToRawIntBits(f)) + ")";
41 }
42
43 public static String toHexString(double d) {
44 if (!Double.isNaN(d))
45 return Double.toHexString(d);
46 else
47 return "NaN(0x" + Long.toHexString(Double.doubleToRawLongBits(d)) + ")";
48 }
49
50 /**
51 * Return the floating-point value next larger in magnitude.
52 */
53 public static double nextOut(double d) {
54 if (d > 0.0)
55 return Math.nextUp(d);
56 else
57 return -Math.nextUp(-d);
58 }
59
60 /**
61 * Returns unbiased exponent of a {@code float}; for
62 * subnormal values, the number is treated as if it were
63 * normalized. That is for all finite, non-zero, positive numbers
64 * <i>x</i>, <code>scalb(<i>x</i>, -ilogb(<i>x</i>))</code> is
65 * always in the range [1, 2).
66 * <p>
67 * Special cases:
68 * <ul>
69 * <li> If the argument is NaN, then the result is 2<sup>30</sup>.
70 * <li> If the argument is infinite, then the result is 2<sup>28</sup>.
71 * <li> If the argument is zero, then the result is -(2<sup>28</sup>).
72 * </ul>
73 *
74 * @param f floating-point number whose exponent is to be extracted
75 * @return unbiased exponent of the argument.
76 */
77 public static int ilogb(double d) {
78 int exponent = Math.getExponent(d);
79
80 switch (exponent) {
81 case Double.MAX_EXPONENT+1: // NaN or infinity
82 if( Double.isNaN(d) )
83 return (1<<30); // 2^30
84 else // infinite value
85 return (1<<28); // 2^28
86
87 case Double.MIN_EXPONENT-1: // zero or subnormal
88 if(d == 0.0) {
89 return -(1<<28); // -(2^28)
90 }
91 else {
92 long transducer = Double.doubleToRawLongBits(d);
93
94 /*
95 * To avoid causing slow arithmetic on subnormals,
96 * the scaling to determine when d's significand
97 * is normalized is done in integer arithmetic.
98 * (there must be at least one "1" bit in the
99 * significand since zero has been screened out.
100 */
101
102 // isolate significand bits
103 transducer &= DoubleConsts.SIGNIF_BIT_MASK;
104 assert(transducer != 0L);
105
106 // This loop is simple and functional. We might be
107 // able to do something more clever that was faster;
108 // e.g. number of leading zero detection on
109 // (transducer << (# exponent and sign bits).
110 while (transducer <
111 (1L << (DoubleConsts.SIGNIFICAND_WIDTH - 1))) {
112 transducer *= 2;
113 exponent--;
114 }
115 exponent++;
116 assert( exponent >=
117 Double.MIN_EXPONENT - (DoubleConsts.SIGNIFICAND_WIDTH-1) &&
118 exponent < Double.MIN_EXPONENT);
119 return exponent;
120 }
121
122 default:
123 assert( exponent >= Double.MIN_EXPONENT &&
124 exponent <= Double.MAX_EXPONENT);
125 return exponent;
126 }
127 }
128
129 /**
130 * Returns unbiased exponent of a {@code float}; for
131 * subnormal values, the number is treated as if it were
132 * normalized. That is for all finite, non-zero, positive numbers
133 * <i>x</i>, <code>scalb(<i>x</i>, -ilogb(<i>x</i>))</code> is
134 * always in the range [1, 2).
135 * <p>
136 * Special cases:
137 * <ul>
138 * <li> If the argument is NaN, then the result is 2<sup>30</sup>.
139 * <li> If the argument is infinite, then the result is 2<sup>28</sup>.
140 * <li> If the argument is zero, then the result is -(2<sup>28</sup>).
141 * </ul>
142 *
143 * @param f floating-point number whose exponent is to be extracted
144 * @return unbiased exponent of the argument.
145 */
146 public static int ilogb(float f) {
147 int exponent = Math.getExponent(f);
148
149 switch (exponent) {
150 case Float.MAX_EXPONENT+1: // NaN or infinity
151 if( Float.isNaN(f) )
152 return (1<<30); // 2^30
153 else // infinite value
154 return (1<<28); // 2^28
155
156 case Float.MIN_EXPONENT-1: // zero or subnormal
157 if(f == 0.0f) {
158 return -(1<<28); // -(2^28)
159 }
160 else {
161 int transducer = Float.floatToRawIntBits(f);
162
163 /*
164 * To avoid causing slow arithmetic on subnormals,
165 * the scaling to determine when f's significand
166 * is normalized is done in integer arithmetic.
167 * (there must be at least one "1" bit in the
168 * significand since zero has been screened out.
169 */
170
171 // isolate significand bits
172 transducer &= FloatConsts.SIGNIF_BIT_MASK;
173 assert(transducer != 0);
174
175 // This loop is simple and functional. We might be
176 // able to do something more clever that was faster;
177 // e.g. number of leading zero detection on
178 // (transducer << (# exponent and sign bits).
179 while (transducer <
180 (1 << (FloatConsts.SIGNIFICAND_WIDTH - 1))) {
181 transducer *= 2;
182 exponent--;
183 }
184 exponent++;
185 assert( exponent >=
186 Float.MIN_EXPONENT - (FloatConsts.SIGNIFICAND_WIDTH-1) &&
187 exponent < Float.MIN_EXPONENT);
188 return exponent;
189 }
190
191 default:
192 assert( exponent >= Float.MIN_EXPONENT &&
193 exponent <= Float.MAX_EXPONENT);
194 return exponent;
195 }
196 }
197
198 /**
199 * Returns {@code true} if the unordered relation holds
200 * between the two arguments. When two floating-point values are
201 * unordered, one value is neither less than, equal to, nor
202 * greater than the other. For the unordered relation to be true,
203 * at least one argument must be a {@code NaN}.
204 *
205 * @param arg1 the first argument
206 * @param arg2 the second argument
207 * @return {@code true} if at least one argument is a NaN,
208 * {@code false} otherwise.
209 */
210 public static boolean isUnordered(float arg1, float arg2) {
211 return Float.isNaN(arg1) || Float.isNaN(arg2);
212 }
213
214 /**
215 * Returns {@code true} if the unordered relation holds
216 * between the two arguments. When two floating-point values are
217 * unordered, one value is neither less than, equal to, nor
218 * greater than the other. For the unordered relation to be true,
219 * at least one argument must be a {@code NaN}.
220 *
221 * @param arg1 the first argument
222 * @param arg2 the second argument
223 * @return {@code true} if at least one argument is a NaN,
224 * {@code false} otherwise.
225 */
226 public static boolean isUnordered(double arg1, double arg2) {
227 return Double.isNaN(arg1) || Double.isNaN(arg2);
228 }
229
230 public static int test(String testName, float input,
231 boolean result, boolean expected) {
232 if (expected != result) {
233 System.err.println("Failure for " + testName + ":\n" +
234 "\tFor input " + input + "\t(" + toHexString(input) + ")\n" +
235 "\texpected " + expected + "\n" +
236 "\tgot " + result + ").");
237 return 1;
238 }
239 else
240 return 0;
241 }
242
243 public static int test(String testName, double input,
244 boolean result, boolean expected) {
245 if (expected != result) {
246 System.err.println("Failure for " + testName + ":\n" +
247 "\tFor input " + input + "\t(" + toHexString(input) + ")\n" +
248 "\texpected " + expected + "\n" +
249 "\tgot " + result + ").");
250 return 1;
251 }
252 else
253 return 0;
254 }
255
256 public static int test(String testName, float input1, float input2,
257 boolean result, boolean expected) {
258 if (expected != result) {
259 System.err.println("Failure for " + testName + ":\n" +
260 "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and "
261 + input2 + "\t(" + toHexString(input2) + ")\n" +
262 "\texpected " + expected + "\n" +
263 "\tgot " + result + ").");
264 return 1;
265 }
266 return 0;
267 }
268
269 public static int test(String testName, double input1, double input2,
270 boolean result, boolean expected) {
271 if (expected != result) {
272 System.err.println("Failure for " + testName + ":\n" +
273 "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and "
274 + input2 + "\t(" + toHexString(input2) + ")\n" +
275 "\texpected " + expected + "\n" +
276 "\tgot " + result + ").");
277 return 1;
278 }
279 return 0;
280 }
281
282 public static int test(String testName, float input,
283 int result, int expected) {
284 if (expected != result) {
285 System.err.println("Failure for " + testName + ":\n" +
286 "\tFor input " + input + "\t(" + toHexString(input) + ")\n" +
287 "\texpected " + expected + "\n" +
288 "\tgot " + result + ").");
289 return 1;
290 }
291 return 0;
292 }
293
294 public static int test(String testName, double input,
295 int result, int expected) {
296 if (expected != result) {
297 System.err.println("Failure for " + testName + ":\n" +
298 "\tFor input " + input + "\t(" + toHexString(input) + ")\n" +
299 "\texpected " + expected + "\n" +
300 "\tgot " + result + ").");
301 return 1;
302 }
303 else
304 return 0;
305 }
306
307 public static int test(String testName, float input,
308 float result, float expected) {
309 if (Float.compare(expected, result) != 0 ) {
310 System.err.println("Failure for " + testName + ":\n" +
311 "\tFor input " + input + "\t(" + toHexString(input) + ")\n" +
312 "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" +
313 "\tgot " + result + "\t(" + toHexString(result) + ").");
314 return 1;
315 }
316 else
317 return 0;
318 }
319
320
321 public static int test(String testName, double input,
322 double result, double expected) {
323 if (Double.compare(expected, result ) != 0) {
324 System.err.println("Failure for " + testName + ":\n" +
325 "\tFor input " + input + "\t(" + toHexString(input) + ")\n" +
326 "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" +
327 "\tgot " + result + "\t(" + toHexString(result) + ").");
328 return 1;
329 }
330 else
331 return 0;
332 }
333
334 public static int test(String testName,
335 float input1, double input2,
336 float result, float expected) {
337 if (Float.compare(expected, result ) != 0) {
338 System.err.println("Failure for " + testName + ":\n" +
339 "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and "
340 + input2 + "\t(" + toHexString(input2) + ")\n" +
341 "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" +
342 "\tgot " + result + "\t(" + toHexString(result) + ").");
343 return 1;
344 }
345 else
346 return 0;
347 }
348
349 public static int test(String testName,
350 double input1, double input2,
351 double result, double expected) {
352 if (Double.compare(expected, result ) != 0) {
353 System.err.println("Failure for " + testName + ":\n" +
354 "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and "
355 + input2 + "\t(" + toHexString(input2) + ")\n" +
356 "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" +
357 "\tgot " + result + "\t(" + toHexString(result) + ").");
358 return 1;
359 }
360 else
361 return 0;
362 }
363
364 public static int test(String testName,
365 float input1, int input2,
366 float result, float expected) {
367 if (Float.compare(expected, result ) != 0) {
368 System.err.println("Failure for " + testName + ":\n" +
369 "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and "
370 + input2 + "\n" +
371 "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" +
372 "\tgot " + result + "\t(" + toHexString(result) + ").");
373 return 1;
374 }
375 else
376 return 0;
377 }
378
379 public static int test(String testName,
380 double input1, int input2,
381 double result, double expected) {
382 if (Double.compare(expected, result ) != 0) {
383 System.err.println("Failure for " + testName + ":\n" +
384 "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and "
385 + input2 + "\n" +
386 "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" +
387 "\tgot " + result + "\t(" + toHexString(result) + ").");
388 return 1;
389 }
390 else
391 return 0;
392 }
393
394 public static int test(String testName,
395 float input1, float input2, float input3,
396 float result, float expected) {
397 if (Float.compare(expected, result ) != 0) {
398 System.err.println("Failure for " + testName + ":\n" +
399 "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and "
400 + input2 + "\t(" + toHexString(input2) + ") and"
401 + input3 + "\t(" + toHexString(input3) + ")\n" +
402 "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" +
403 "\tgot " + result + "\t(" + toHexString(result) + ").");
404 return 1;
405 }
406 else
407 return 0;
408 }
409
410 public static int test(String testName,
411 double input1, double input2, double input3,
412 double result, double expected) {
413 if (Double.compare(expected, result ) != 0) {
414 System.err.println("Failure for " + testName + ":\n" +
415 "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and "
416 + input2 + "\t(" + toHexString(input2) + ") and"
417 + input3 + "\t(" + toHexString(input3) + ")\n" +
418 "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" +
419 "\tgot " + result + "\t(" + toHexString(result) + ").");
420 return 1;
421 }
422 else
423 return 0;
424 }
425
426 static int testUlpCore(double result, double expected, double ulps) {
427 // We assume we won't be unlucky and have an inexact expected
428 // be nextDown(2^i) when 2^i would be the correctly rounded
429 // answer. This would cause the ulp size to be half as large
430 // as it should be, doubling the measured error).
431
432 if (Double.compare(expected, result) == 0) {
433 return 0; // result and expected are equivalent
434 } else {
435 if( ulps == 0.0) {
436 // Equivalent results required but not found
437 return 1;
438 } else {
439 double difference = expected - result;
440 if (isUnordered(expected, result) ||
441 Double.isNaN(difference) ||
442 // fail if greater than or unordered
443 !(Math.abs( difference/Math.ulp(expected) ) <= Math.abs(ulps)) ) {
444 return 1;
445 }
446 else
447 return 0;
448 }
449 }
450 }
451
452 // One input argument.
453 public static int testUlpDiff(String testName, double input,
454 double result, double expected, double ulps) {
455 int code = testUlpCore(result, expected, ulps);
456 if (code == 1) {
457 System.err.println("Failure for " + testName + ":\n" +
458 "\tFor input " + input + "\t(" + toHexString(input) + ")\n" +
459 "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" +
460 "\tgot " + result + "\t(" + toHexString(result) + ");\n" +
461 "\tdifference greater than ulp tolerance " + ulps);
462 }
463 return code;
464 }
465
466 // Two input arguments.
467 public static int testUlpDiff(String testName, double input1, double input2,
468 double result, double expected, double ulps) {
469 int code = testUlpCore(result, expected, ulps);
470 if (code == 1) {
471 System.err.println("Failure for " + testName + ":\n" +
472 "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and "
473 + input2 + "\t(" + toHexString(input2) + ")\n" +
474 "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" +
475 "\tgot " + result + "\t(" + toHexString(result) + ");\n" +
476 "\tdifference greater than ulp tolerance " + ulps);
477 }
478 return code;
479 }
480
481 // For a successful test, the result must be within the ulp bound of
482 // expected AND the result must have absolute value less than or
483 // equal to absBound.
484 public static int testUlpDiffWithAbsBound(String testName, double input,
485 double result, double expected,
486 double ulps, double absBound) {
487 int code = 0; // return code value
488
489 if (!(StrictMath.abs(result) <= StrictMath.abs(absBound)) &&
490 !Double.isNaN(expected)) {
491 code = 1;
492 } else
493 code = testUlpCore(result, expected, ulps);
494
495 if (code == 1) {
496 System.err.println("Failure for " + testName + ":\n" +
497 "\tFor input " + input + "\t(" + toHexString(input) + ")\n" +
498 "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" +
499 "\tgot " + result + "\t(" + toHexString(result) + ");\n" +
500 "\tdifference greater than ulp tolerance " + ulps +
501 " or the result has larger magnitude than " + absBound);
502 }
503 return code;
504 }
505
506 // For a successful test, the result must be within the ulp bound of
507 // expected AND the result must have absolute value greater than
508 // or equal to the lowerBound.
509 public static int testUlpDiffWithLowerBound(String testName, double input,
510 double result, double expected,
511 double ulps, double lowerBound) {
512 int code = 0; // return code value
513
514 if (!(result >= lowerBound) && !Double.isNaN(expected)) {
515 code = 1;
516 } else
517 code = testUlpCore(result, expected, ulps);
518
519 if (code == 1) {
520 System.err.println("Failure for " + testName +
521 ":\n" +
522 "\tFor input " + input + "\t(" + toHexString(input) + ")" +
523 "\n\texpected " + expected + "\t(" + toHexString(expected) + ")" +
524 "\n\tgot " + result + "\t(" + toHexString(result) + ");" +
525 "\ndifference greater than ulp tolerance " + ulps +
526 " or result not greater than or equal to the bound " + lowerBound);
527 }
528 return code;
529 }
530
531 public static int testTolerance(String testName, double input,
532 double result, double expected, double tolerance) {
533 if (Double.compare(expected, result ) != 0) {
534 double difference = expected - result;
535 if (isUnordered(expected, result) ||
536 Double.isNaN(difference) ||
537 // fail if greater than or unordered
538 !(Math.abs((difference)/expected) <= StrictMath.pow(10, -tolerance)) ) {
539 System.err.println("Failure for " + testName + ":\n" +
540 "\tFor input " + input + "\t(" + toHexString(input) + ")\n" +
541 "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" +
542 "\tgot " + result + "\t(" + toHexString(result) + ");\n" +
543 "\tdifference greater than tolerance 10^-" + tolerance);
544 return 1;
545 }
546 return 0;
547 }
548 else
549 return 0;
550 }
551
552 // For a successful test, the result must be within the upper and
553 // lower bounds.
554 public static int testBounds(String testName, double input, double result,
555 double bound1, double bound2) {
556 if ((result >= bound1 && result <= bound2) ||
557 (result <= bound1 && result >= bound2))
558 return 0;
559 else {
560 double lowerBound = Math.min(bound1, bound2);
561 double upperBound = Math.max(bound1, bound2);
562 System.err.println("Failure for " + testName + ":\n" +
563 "\tFor input " + input + "\t(" + toHexString(input) + ")\n" +
564 "\tgot " + result + "\t(" + toHexString(result) + ");\n" +
565 "\toutside of range\n" +
566 "\t[" + lowerBound + "\t(" + toHexString(lowerBound) + "), " +
567 upperBound + "\t(" + toHexString(upperBound) + ")]");
568 return 1;
569 }
570 }
571 }