1 /*
2 * Copyright (c) 2003, 2017, 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 * @test
26 * @library /test/lib
27 * @build jdk.test.lib.RandomFactory
28 * @run main IeeeRecommendedTests
29 * @bug 4860891 4826732 4780454 4939441 4826652 8078672
30 * @summary Tests for IEEE 754[R] recommended functions and similar methods (use -Dseed=X to set PRNG seed)
31 * @author Joseph D. Darcy
32 * @key randomness
33 */
34
35 import jdk.test.lib.RandomFactory;
36
37 public class IeeeRecommendedTests {
38 private IeeeRecommendedTests(){}
39
40 static final float NaNf = Float.NaN;
41 static final double NaNd = Double.NaN;
42 static final float infinityF = Float.POSITIVE_INFINITY;
43 static final double infinityD = Double.POSITIVE_INFINITY;
44
45 static final float Float_MAX_VALUEmm = 0x1.fffffcP+127f;
46 static final float Float_MAX_SUBNORMAL = 0x0.fffffeP-126f;
47 static final float Float_MAX_SUBNORMALmm = 0x0.fffffcP-126f;
48
49 static final double Double_MAX_VALUEmm = 0x1.ffffffffffffeP+1023;
50 static final double Double_MAX_SUBNORMAL = 0x0.fffffffffffffP-1022;
51 static final double Double_MAX_SUBNORMALmm = 0x0.ffffffffffffeP-1022;
52
53 // Initialize shared random number generator
54 static java.util.Random rand = RandomFactory.getRandom();
55
56 /**
57 * Returns a floating-point power of two in the normal range.
58 */
59 static double powerOfTwoD(int n) {
60 return Double.longBitsToDouble((((long)n + (long)Double.MAX_EXPONENT) <<
61 (DoubleConsts.SIGNIFICAND_WIDTH-1))
62 & DoubleConsts.EXP_BIT_MASK);
63 }
64
65 /**
66 * Returns a floating-point power of two in the normal range.
67 */
68 static float powerOfTwoF(int n) {
69 return Float.intBitsToFloat(((n + Float.MAX_EXPONENT) <<
70 (FloatConsts.SIGNIFICAND_WIDTH-1))
71 & FloatConsts.EXP_BIT_MASK);
72 }
73
74 /* ******************** getExponent tests ****************************** */
75
76 /*
77 * The tests for getExponent should test the special values (NaN, +/-
78 * infinity, etc.), test the endpoints of each binade (set of
79 * floating-point values with the same exponent), and for good
80 * measure, test some random values within each binade. Testing
81 * the endpoints of each binade includes testing both positive and
82 * negative numbers. Subnormal values with different normalized
83 * exponents should be tested too. Both Math and StrictMath
84 * methods should return the same results.
85 */
86
87 /*
88 * Test Math.getExponent and StrictMath.getExponent with +d and -d.
89 */
90 static int testGetExponentCase(float f, int expected) {
91 float minus_f = -f;
92 int failures=0;
93
94 failures+=Tests.test("Math.getExponent(float)", f,
95 Math.getExponent(f), expected);
96 failures+=Tests.test("Math.getExponent(float)", minus_f,
97 Math.getExponent(minus_f), expected);
98
99 failures+=Tests.test("StrictMath.getExponent(float)", f,
100 StrictMath.getExponent(f), expected);
101 failures+=Tests.test("StrictMath.getExponent(float)", minus_f,
102 StrictMath.getExponent(minus_f), expected);
103 return failures;
104 }
105
106 /*
107 * Test Math.getExponent and StrictMath.getExponent with +d and -d.
108 */
109 static int testGetExponentCase(double d, int expected) {
110 double minus_d = -d;
111 int failures=0;
112
113 failures+=Tests.test("Math.getExponent(double)", d,
114 Math.getExponent(d), expected);
115 failures+=Tests.test("Math.getExponent(double)", minus_d,
116 Math.getExponent(minus_d), expected);
117
118 failures+=Tests.test("StrictMath.getExponent(double)", d,
119 StrictMath.getExponent(d), expected);
120 failures+=Tests.test("StrictMath.getExponent(double)", minus_d,
121 StrictMath.getExponent(minus_d), expected);
122 return failures;
123 }
124
125 public static int testFloatGetExponent() {
126 int failures = 0;
127 float [] specialValues = {NaNf,
128 Float.POSITIVE_INFINITY,
129 +0.0f,
130 +1.0f,
131 +2.0f,
132 +16.0f,
133 +Float.MIN_VALUE,
134 +Float_MAX_SUBNORMAL,
135 +Float.MIN_NORMAL,
136 +Float.MAX_VALUE
137 };
138
139 int [] specialResults = {Float.MAX_EXPONENT + 1, // NaN results
140 Float.MAX_EXPONENT + 1, // Infinite results
141 Float.MIN_EXPONENT - 1, // Zero results
142 0,
143 1,
144 4,
145 Float.MIN_EXPONENT - 1,
146 -Float.MAX_EXPONENT,
147 Float.MIN_EXPONENT,
148 Float.MAX_EXPONENT
149 };
150
151 // Special value tests
152 for(int i = 0; i < specialValues.length; i++) {
153 failures += testGetExponentCase(specialValues[i], specialResults[i]);
154 }
155
156
157 // Normal exponent tests
158 for(int i = Float.MIN_EXPONENT; i <= Float.MAX_EXPONENT; i++) {
159 int result;
160
161 // Create power of two
162 float po2 = powerOfTwoF(i);
163
164 failures += testGetExponentCase(po2, i);
165
166 // Generate some random bit patterns for the significand
167 for(int j = 0; j < 10; j++) {
168 int randSignif = rand.nextInt();
169 float randFloat;
170
171 randFloat = Float.intBitsToFloat( // Exponent
172 (Float.floatToIntBits(po2)&
173 (~FloatConsts.SIGNIF_BIT_MASK)) |
174 // Significand
175 (randSignif &
176 FloatConsts.SIGNIF_BIT_MASK) );
177
178 failures += testGetExponentCase(randFloat, i);
179 }
180
181 if (i > Float.MIN_EXPONENT) {
182 float po2minus = Math.nextAfter(po2,
183 Float.NEGATIVE_INFINITY);
184 failures += testGetExponentCase(po2minus, i-1);
185 }
186 }
187
188 // Subnormal exponent tests
189
190 /*
191 * Start with MIN_VALUE, left shift, test high value, low
192 * values, and random in between.
193 *
194 * Use nextAfter to calculate, high value of previous binade,
195 * loop count i will indicate how many random bits, if any are
196 * needed.
197 */
198
199 float top=Float.MIN_VALUE;
200 for( int i = 1;
201 i < FloatConsts.SIGNIFICAND_WIDTH;
202 i++, top *= 2.0f) {
203
204 failures += testGetExponentCase(top,
205 Float.MIN_EXPONENT - 1);
206
207 // Test largest value in next smaller binade
208 if (i >= 3) {// (i == 1) would test 0.0;
209 // (i == 2) would just retest MIN_VALUE
210 testGetExponentCase(Math.nextAfter(top, 0.0f),
211 Float.MIN_EXPONENT - 1);
212
213 if( i >= 10) {
214 // create a bit mask with (i-1) 1's in the low order
215 // bits
216 int mask = ~((~0)<<(i-1));
217 float randFloat = Float.intBitsToFloat( // Exponent
218 Float.floatToIntBits(top) |
219 // Significand
220 (rand.nextInt() & mask ) ) ;
221
222 failures += testGetExponentCase(randFloat,
223 Float.MIN_EXPONENT - 1);
224 }
225 }
226 }
227
228 return failures;
229 }
230
231
232 public static int testDoubleGetExponent() {
233 int failures = 0;
234 double [] specialValues = {NaNd,
235 infinityD,
236 +0.0,
237 +1.0,
238 +2.0,
239 +16.0,
240 +Double.MIN_VALUE,
241 +Double_MAX_SUBNORMAL,
242 +Double.MIN_NORMAL,
243 +Double.MAX_VALUE
244 };
245
246 int [] specialResults = {Double.MAX_EXPONENT + 1, // NaN results
247 Double.MAX_EXPONENT + 1, // Infinite results
248 Double.MIN_EXPONENT - 1, // Zero results
249 0,
250 1,
251 4,
252 Double.MIN_EXPONENT - 1,
253 -Double.MAX_EXPONENT,
254 Double.MIN_EXPONENT,
255 Double.MAX_EXPONENT
256 };
257
258 // Special value tests
259 for(int i = 0; i < specialValues.length; i++) {
260 failures += testGetExponentCase(specialValues[i], specialResults[i]);
261 }
262
263
264 // Normal exponent tests
265 for(int i = Double.MIN_EXPONENT; i <= Double.MAX_EXPONENT; i++) {
266 int result;
267
268 // Create power of two
269 double po2 = powerOfTwoD(i);
270
271 failures += testGetExponentCase(po2, i);
272
273 // Generate some random bit patterns for the significand
274 for(int j = 0; j < 10; j++) {
275 long randSignif = rand.nextLong();
276 double randFloat;
277
278 randFloat = Double.longBitsToDouble( // Exponent
279 (Double.doubleToLongBits(po2)&
280 (~DoubleConsts.SIGNIF_BIT_MASK)) |
281 // Significand
282 (randSignif &
283 DoubleConsts.SIGNIF_BIT_MASK) );
284
285 failures += testGetExponentCase(randFloat, i);
286 }
287
288 if (i > Double.MIN_EXPONENT) {
289 double po2minus = Math.nextAfter(po2,
290 Double.NEGATIVE_INFINITY);
291 failures += testGetExponentCase(po2minus, i-1);
292 }
293 }
294
295 // Subnormal exponent tests
296
297 /*
298 * Start with MIN_VALUE, left shift, test high value, low
299 * values, and random in between.
300 *
301 * Use nextAfter to calculate, high value of previous binade;
302 * loop count i will indicate how many random bits, if any are
303 * needed.
304 */
305
306 double top=Double.MIN_VALUE;
307 for( int i = 1;
308 i < DoubleConsts.SIGNIFICAND_WIDTH;
309 i++, top *= 2.0f) {
310
311 failures += testGetExponentCase(top,
312 Double.MIN_EXPONENT - 1);
313
314 // Test largest value in next smaller binade
315 if (i >= 3) {// (i == 1) would test 0.0;
316 // (i == 2) would just retest MIN_VALUE
317 testGetExponentCase(Math.nextAfter(top, 0.0),
318 Double.MIN_EXPONENT - 1);
319
320 if( i >= 10) {
321 // create a bit mask with (i-1) 1's in the low order
322 // bits
323 long mask = ~((~0L)<<(i-1));
324 double randFloat = Double.longBitsToDouble( // Exponent
325 Double.doubleToLongBits(top) |
326 // Significand
327 (rand.nextLong() & mask ) ) ;
328
329 failures += testGetExponentCase(randFloat,
330 Double.MIN_EXPONENT - 1);
331 }
332 }
333 }
334
335 return failures;
336 }
337
338
339 /* ******************** nextAfter tests ****************************** */
340
341 static int testNextAfterCase(float start, double direction, float expected) {
342 int failures=0;
343 float minus_start = -start;
344 double minus_direction = -direction;
345 float minus_expected = -expected;
346
347 failures+=Tests.test("Math.nextAfter(float,double)", start, direction,
348 Math.nextAfter(start, direction), expected);
349 failures+=Tests.test("Math.nextAfter(float,double)", minus_start, minus_direction,
350 Math.nextAfter(minus_start, minus_direction), minus_expected);
351
352 failures+=Tests.test("StrictMath.nextAfter(float,double)", start, direction,
353 StrictMath.nextAfter(start, direction), expected);
354 failures+=Tests.test("StrictMath.nextAfter(float,double)", minus_start, minus_direction,
355 StrictMath.nextAfter(minus_start, minus_direction), minus_expected);
356 return failures;
357 }
358
359 static int testNextAfterCase(double start, double direction, double expected) {
360 int failures=0;
361
362 double minus_start = -start;
363 double minus_direction = -direction;
364 double minus_expected = -expected;
365
366 failures+=Tests.test("Math.nextAfter(double,double)", start, direction,
367 Math.nextAfter(start, direction), expected);
368 failures+=Tests.test("Math.nextAfter(double,double)", minus_start, minus_direction,
369 Math.nextAfter(minus_start, minus_direction), minus_expected);
370
371 failures+=Tests.test("StrictMath.nextAfter(double,double)", start, direction,
372 StrictMath.nextAfter(start, direction), expected);
373 failures+=Tests.test("StrictMath.nextAfter(double,double)", minus_start, minus_direction,
374 StrictMath.nextAfter(minus_start, minus_direction), minus_expected);
375 return failures;
376 }
377
378 public static int testFloatNextAfter() {
379 int failures=0;
380
381 /*
382 * Each row of the testCases matrix represents one test case
383 * for nexAfter; given the input of the first two columns, the
384 * result in the last column is expected.
385 */
386 float [][] testCases = {
387 {NaNf, NaNf, NaNf},
388 {NaNf, 0.0f, NaNf},
389 {0.0f, NaNf, NaNf},
390 {NaNf, infinityF, NaNf},
391 {infinityF, NaNf, NaNf},
392
393 {infinityF, infinityF, infinityF},
394 {infinityF, -infinityF, Float.MAX_VALUE},
395 {infinityF, 0.0f, Float.MAX_VALUE},
396
397 {Float.MAX_VALUE, infinityF, infinityF},
398 {Float.MAX_VALUE, -infinityF, Float_MAX_VALUEmm},
399 {Float.MAX_VALUE, Float.MAX_VALUE, Float.MAX_VALUE},
400 {Float.MAX_VALUE, 0.0f, Float_MAX_VALUEmm},
401
402 {Float_MAX_VALUEmm, Float.MAX_VALUE, Float.MAX_VALUE},
403 {Float_MAX_VALUEmm, infinityF, Float.MAX_VALUE},
404 {Float_MAX_VALUEmm, Float_MAX_VALUEmm, Float_MAX_VALUEmm},
405
406 {Float.MIN_NORMAL, infinityF, Float.MIN_NORMAL+
407 Float.MIN_VALUE},
408 {Float.MIN_NORMAL, -infinityF, Float_MAX_SUBNORMAL},
409 {Float.MIN_NORMAL, 1.0f, Float.MIN_NORMAL+
410 Float.MIN_VALUE},
411 {Float.MIN_NORMAL, -1.0f, Float_MAX_SUBNORMAL},
412 {Float.MIN_NORMAL, Float.MIN_NORMAL, Float.MIN_NORMAL},
413
414 {Float_MAX_SUBNORMAL, Float.MIN_NORMAL, Float.MIN_NORMAL},
415 {Float_MAX_SUBNORMAL, Float_MAX_SUBNORMAL, Float_MAX_SUBNORMAL},
416 {Float_MAX_SUBNORMAL, 0.0f, Float_MAX_SUBNORMALmm},
417
418 {Float_MAX_SUBNORMALmm, Float_MAX_SUBNORMAL, Float_MAX_SUBNORMAL},
419 {Float_MAX_SUBNORMALmm, 0.0f, Float_MAX_SUBNORMALmm-Float.MIN_VALUE},
420 {Float_MAX_SUBNORMALmm, Float_MAX_SUBNORMALmm, Float_MAX_SUBNORMALmm},
421
422 {Float.MIN_VALUE, 0.0f, 0.0f},
423 {-Float.MIN_VALUE, 0.0f, -0.0f},
424 {Float.MIN_VALUE, Float.MIN_VALUE, Float.MIN_VALUE},
425 {Float.MIN_VALUE, 1.0f, 2*Float.MIN_VALUE},
426
427 // Make sure zero behavior is tested
428 {0.0f, 0.0f, 0.0f},
429 {0.0f, -0.0f, -0.0f},
430 {-0.0f, 0.0f, 0.0f},
431 {-0.0f, -0.0f, -0.0f},
432 {0.0f, infinityF, Float.MIN_VALUE},
433 {0.0f, -infinityF, -Float.MIN_VALUE},
434 {-0.0f, infinityF, Float.MIN_VALUE},
435 {-0.0f, -infinityF, -Float.MIN_VALUE},
436 {0.0f, Float.MIN_VALUE, Float.MIN_VALUE},
437 {0.0f, -Float.MIN_VALUE, -Float.MIN_VALUE},
438 {-0.0f, Float.MIN_VALUE, Float.MIN_VALUE},
439 {-0.0f, -Float.MIN_VALUE, -Float.MIN_VALUE}
440 };
441
442 for(int i = 0; i < testCases.length; i++) {
443 failures += testNextAfterCase(testCases[i][0], testCases[i][1],
444 testCases[i][2]);
445 }
446
447 return failures;
448 }
449
450 public static int testDoubleNextAfter() {
451 int failures =0;
452
453 /*
454 * Each row of the testCases matrix represents one test case
455 * for nexAfter; given the input of the first two columns, the
456 * result in the last column is expected.
457 */
458 double [][] testCases = {
459 {NaNd, NaNd, NaNd},
460 {NaNd, 0.0d, NaNd},
461 {0.0d, NaNd, NaNd},
462 {NaNd, infinityD, NaNd},
463 {infinityD, NaNd, NaNd},
464
465 {infinityD, infinityD, infinityD},
466 {infinityD, -infinityD, Double.MAX_VALUE},
467 {infinityD, 0.0d, Double.MAX_VALUE},
468
469 {Double.MAX_VALUE, infinityD, infinityD},
470 {Double.MAX_VALUE, -infinityD, Double_MAX_VALUEmm},
471 {Double.MAX_VALUE, Double.MAX_VALUE, Double.MAX_VALUE},
472 {Double.MAX_VALUE, 0.0d, Double_MAX_VALUEmm},
473
474 {Double_MAX_VALUEmm, Double.MAX_VALUE, Double.MAX_VALUE},
475 {Double_MAX_VALUEmm, infinityD, Double.MAX_VALUE},
476 {Double_MAX_VALUEmm, Double_MAX_VALUEmm, Double_MAX_VALUEmm},
477
478 {Double.MIN_NORMAL, infinityD, Double.MIN_NORMAL+
479 Double.MIN_VALUE},
480 {Double.MIN_NORMAL, -infinityD, Double_MAX_SUBNORMAL},
481 {Double.MIN_NORMAL, 1.0f, Double.MIN_NORMAL+
482 Double.MIN_VALUE},
483 {Double.MIN_NORMAL, -1.0f, Double_MAX_SUBNORMAL},
484 {Double.MIN_NORMAL, Double.MIN_NORMAL, Double.MIN_NORMAL},
485
486 {Double_MAX_SUBNORMAL, Double.MIN_NORMAL, Double.MIN_NORMAL},
487 {Double_MAX_SUBNORMAL, Double_MAX_SUBNORMAL, Double_MAX_SUBNORMAL},
488 {Double_MAX_SUBNORMAL, 0.0d, Double_MAX_SUBNORMALmm},
489
490 {Double_MAX_SUBNORMALmm, Double_MAX_SUBNORMAL, Double_MAX_SUBNORMAL},
491 {Double_MAX_SUBNORMALmm, 0.0d, Double_MAX_SUBNORMALmm-Double.MIN_VALUE},
492 {Double_MAX_SUBNORMALmm, Double_MAX_SUBNORMALmm, Double_MAX_SUBNORMALmm},
493
494 {Double.MIN_VALUE, 0.0d, 0.0d},
495 {-Double.MIN_VALUE, 0.0d, -0.0d},
496 {Double.MIN_VALUE, Double.MIN_VALUE, Double.MIN_VALUE},
497 {Double.MIN_VALUE, 1.0f, 2*Double.MIN_VALUE},
498
499 // Make sure zero behavior is tested
500 {0.0d, 0.0d, 0.0d},
501 {0.0d, -0.0d, -0.0d},
502 {-0.0d, 0.0d, 0.0d},
503 {-0.0d, -0.0d, -0.0d},
504 {0.0d, infinityD, Double.MIN_VALUE},
505 {0.0d, -infinityD, -Double.MIN_VALUE},
506 {-0.0d, infinityD, Double.MIN_VALUE},
507 {-0.0d, -infinityD, -Double.MIN_VALUE},
508 {0.0d, Double.MIN_VALUE, Double.MIN_VALUE},
509 {0.0d, -Double.MIN_VALUE, -Double.MIN_VALUE},
510 {-0.0d, Double.MIN_VALUE, Double.MIN_VALUE},
511 {-0.0d, -Double.MIN_VALUE, -Double.MIN_VALUE}
512 };
513
514 for(int i = 0; i < testCases.length; i++) {
515 failures += testNextAfterCase(testCases[i][0], testCases[i][1],
516 testCases[i][2]);
517 }
518 return failures;
519 }
520
521 /* ******************** nextUp tests ********************************* */
522
523 public static int testFloatNextUp() {
524 int failures=0;
525
526 /*
527 * Each row of testCases represents one test case for nextUp;
528 * the first column is the input and the second column is the
529 * expected result.
530 */
531 float testCases [][] = {
532 {NaNf, NaNf},
533 {-infinityF, -Float.MAX_VALUE},
534 {-Float.MAX_VALUE, -Float_MAX_VALUEmm},
535 {-Float.MIN_NORMAL, -Float_MAX_SUBNORMAL},
536 {-Float_MAX_SUBNORMAL, -Float_MAX_SUBNORMALmm},
537 {-Float.MIN_VALUE, -0.0f},
538 {-0.0f, Float.MIN_VALUE},
539 {+0.0f, Float.MIN_VALUE},
540 {Float.MIN_VALUE, Float.MIN_VALUE*2},
541 {Float_MAX_SUBNORMALmm, Float_MAX_SUBNORMAL},
542 {Float_MAX_SUBNORMAL, Float.MIN_NORMAL},
543 {Float.MIN_NORMAL, Float.MIN_NORMAL+Float.MIN_VALUE},
544 {Float_MAX_VALUEmm, Float.MAX_VALUE},
545 {Float.MAX_VALUE, infinityF},
546 {infinityF, infinityF}
547 };
548
549 for(int i = 0; i < testCases.length; i++) {
550 failures+=Tests.test("Math.nextUp(float)",
551 testCases[i][0], Math.nextUp(testCases[i][0]), testCases[i][1]);
552
553 failures+=Tests.test("StrictMath.nextUp(float)",
554 testCases[i][0], StrictMath.nextUp(testCases[i][0]), testCases[i][1]);
555 }
556
557 return failures;
558 }
559
560
561 public static int testDoubleNextUp() {
562 int failures=0;
563
564 /*
565 * Each row of testCases represents one test case for nextUp;
566 * the first column is the input and the second column is the
567 * expected result.
568 */
569 double testCases [][] = {
570 {NaNd, NaNd},
571 {-infinityD, -Double.MAX_VALUE},
572 {-Double.MAX_VALUE, -Double_MAX_VALUEmm},
573 {-Double.MIN_NORMAL, -Double_MAX_SUBNORMAL},
574 {-Double_MAX_SUBNORMAL, -Double_MAX_SUBNORMALmm},
575 {-Double.MIN_VALUE, -0.0d},
576 {-0.0d, Double.MIN_VALUE},
577 {+0.0d, Double.MIN_VALUE},
578 {Double.MIN_VALUE, Double.MIN_VALUE*2},
579 {Double_MAX_SUBNORMALmm, Double_MAX_SUBNORMAL},
580 {Double_MAX_SUBNORMAL, Double.MIN_NORMAL},
581 {Double.MIN_NORMAL, Double.MIN_NORMAL+Double.MIN_VALUE},
582 {Double_MAX_VALUEmm, Double.MAX_VALUE},
583 {Double.MAX_VALUE, infinityD},
584 {infinityD, infinityD}
585 };
586
587 for(int i = 0; i < testCases.length; i++) {
588 failures+=Tests.test("Math.nextUp(double)",
589 testCases[i][0], Math.nextUp(testCases[i][0]), testCases[i][1]);
590
591 failures+=Tests.test("StrictMath.nextUp(double)",
592 testCases[i][0], StrictMath.nextUp(testCases[i][0]), testCases[i][1]);
593 }
594
595 return failures;
596 }
597
598 /* ******************** nextDown tests ********************************* */
599
600 public static int testFloatNextDown() {
601 int failures=0;
602
603 /*
604 * Each row of testCases represents one test case for nextDown;
605 * the first column is the input and the second column is the
606 * expected result.
607 */
608 float testCases [][] = {
609 {NaNf, NaNf},
610 {-infinityF, -infinityF},
611 {-Float.MAX_VALUE, -infinityF},
612 {-Float_MAX_VALUEmm, -Float.MAX_VALUE},
613 {-Float_MAX_SUBNORMAL, -Float.MIN_NORMAL},
614 {-Float_MAX_SUBNORMALmm, -Float_MAX_SUBNORMAL},
615 {-0.0f, -Float.MIN_VALUE},
616 {+0.0f, -Float.MIN_VALUE},
617 {Float.MIN_VALUE, 0.0f},
618 {Float.MIN_VALUE*2, Float.MIN_VALUE},
619 {Float_MAX_SUBNORMAL, Float_MAX_SUBNORMALmm},
620 {Float.MIN_NORMAL, Float_MAX_SUBNORMAL},
621 {Float.MIN_NORMAL+
622 Float.MIN_VALUE, Float.MIN_NORMAL},
623 {Float.MAX_VALUE, Float_MAX_VALUEmm},
624 {infinityF, Float.MAX_VALUE},
625 };
626
627 for(int i = 0; i < testCases.length; i++) {
628 failures+=Tests.test("Math.nextDown(float)",
629 testCases[i][0], Math.nextDown(testCases[i][0]), testCases[i][1]);
630
631 failures+=Tests.test("StrictMath.nextDown(float)",
632 testCases[i][0], StrictMath.nextDown(testCases[i][0]), testCases[i][1]);
633 }
634
635 return failures;
636 }
637
638
639 public static int testDoubleNextDown() {
640 int failures=0;
641
642 /*
643 * Each row of testCases represents one test case for nextDown;
644 * the first column is the input and the second column is the
645 * expected result.
646 */
647 double testCases [][] = {
648 {NaNd, NaNd},
649 {-infinityD, -infinityD},
650 {-Double.MAX_VALUE, -infinityD},
651 {-Double_MAX_VALUEmm, -Double.MAX_VALUE},
652 {-Double_MAX_SUBNORMAL, -Double.MIN_NORMAL},
653 {-Double_MAX_SUBNORMALmm, -Double_MAX_SUBNORMAL},
654 {-0.0d, -Double.MIN_VALUE},
655 {+0.0d, -Double.MIN_VALUE},
656 {Double.MIN_VALUE, 0.0d},
657 {Double.MIN_VALUE*2, Double.MIN_VALUE},
658 {Double_MAX_SUBNORMAL, Double_MAX_SUBNORMALmm},
659 {Double.MIN_NORMAL, Double_MAX_SUBNORMAL},
660 {Double.MIN_NORMAL+
661 Double.MIN_VALUE, Double.MIN_NORMAL},
662 {Double.MAX_VALUE, Double_MAX_VALUEmm},
663 {infinityD, Double.MAX_VALUE},
664 };
665
666 for(int i = 0; i < testCases.length; i++) {
667 failures+=Tests.test("Math.nextDown(double)",
668 testCases[i][0], Math.nextDown(testCases[i][0]), testCases[i][1]);
669
670 failures+=Tests.test("StrictMath.nextDown(double)",
671 testCases[i][0], StrictMath.nextDown(testCases[i][0]), testCases[i][1]);
672 }
673
674 return failures;
675 }
676
677
678 /* ********************** boolean tests ****************************** */
679
680 /*
681 * Combined tests for boolean functions, isFinite, isInfinite,
682 * isNaN, isUnordered.
683 */
684
685 public static int testFloatBooleanMethods() {
686 int failures = 0;
687
688 float testCases [] = {
689 NaNf,
690 -infinityF,
691 infinityF,
692 -Float.MAX_VALUE,
693 -3.0f,
694 -1.0f,
695 -Float.MIN_NORMAL,
696 -Float_MAX_SUBNORMALmm,
697 -Float_MAX_SUBNORMAL,
698 -Float.MIN_VALUE,
699 -0.0f,
700 +0.0f,
701 Float.MIN_VALUE,
702 Float_MAX_SUBNORMALmm,
703 Float_MAX_SUBNORMAL,
704 Float.MIN_NORMAL,
705 1.0f,
706 3.0f,
707 Float_MAX_VALUEmm,
708 Float.MAX_VALUE
709 };
710
711 for(int i = 0; i < testCases.length; i++) {
712 // isNaN
713 failures+=Tests.test("Float.isNaN(float)", testCases[i],
714 Float.isNaN(testCases[i]), (i ==0));
715
716 // isFinite
717 failures+=Tests.test("Float.isFinite(float)", testCases[i],
718 Float.isFinite(testCases[i]), (i >= 3));
719
720 // isInfinite
721 failures+=Tests.test("Float.isInfinite(float)", testCases[i],
722 Float.isInfinite(testCases[i]), (i==1 || i==2));
723
724 // isUnorderd
725 for(int j = 0; j < testCases.length; j++) {
726 failures+=Tests.test("Tests.isUnordered(float, float)", testCases[i],testCases[j],
727 Tests.isUnordered(testCases[i],testCases[j]), (i==0 || j==0));
728 }
729 }
730
731 return failures;
732 }
733
734 public static int testDoubleBooleanMethods() {
735 int failures = 0;
736 boolean result = false;
737
738 double testCases [] = {
739 NaNd,
740 -infinityD,
741 infinityD,
742 -Double.MAX_VALUE,
743 -3.0d,
744 -1.0d,
745 -Double.MIN_NORMAL,
746 -Double_MAX_SUBNORMALmm,
747 -Double_MAX_SUBNORMAL,
748 -Double.MIN_VALUE,
749 -0.0d,
750 +0.0d,
751 Double.MIN_VALUE,
752 Double_MAX_SUBNORMALmm,
753 Double_MAX_SUBNORMAL,
754 Double.MIN_NORMAL,
755 1.0d,
756 3.0d,
757 Double_MAX_VALUEmm,
758 Double.MAX_VALUE
759 };
760
761 for(int i = 0; i < testCases.length; i++) {
762 // isNaN
763 failures+=Tests.test("Double.isNaN(double)", testCases[i],
764 Double.isNaN(testCases[i]), (i ==0));
765
766 // isFinite
767 failures+=Tests.test("Double.isFinite(double)", testCases[i],
768 Double.isFinite(testCases[i]), (i >= 3));
769
770 // isInfinite
771 failures+=Tests.test("Double.isInfinite(double)", testCases[i],
772 Double.isInfinite(testCases[i]), (i==1 || i==2));
773
774 // isUnorderd
775 for(int j = 0; j < testCases.length; j++) {
776 failures+=Tests.test("Tests.isUnordered(double, double)", testCases[i],testCases[j],
777 Tests.isUnordered(testCases[i],testCases[j]), (i==0 || j==0));
778 }
779 }
780
781 return failures;
782 }
783
784 /* ******************** copySign tests******************************** */
785
786 public static int testFloatCopySign() {
787 int failures = 0;
788
789 // testCases[0] are logically positive numbers;
790 // testCases[1] are negative numbers.
791 float testCases [][] = {
792 {+0.0f,
793 Float.MIN_VALUE,
794 Float_MAX_SUBNORMALmm,
795 Float_MAX_SUBNORMAL,
796 Float.MIN_NORMAL,
797 1.0f,
798 3.0f,
799 Float_MAX_VALUEmm,
800 Float.MAX_VALUE,
801 infinityF,
802 },
803 {-infinityF,
804 -Float.MAX_VALUE,
805 -3.0f,
806 -1.0f,
807 -Float.MIN_NORMAL,
808 -Float_MAX_SUBNORMALmm,
809 -Float_MAX_SUBNORMAL,
810 -Float.MIN_VALUE,
811 -0.0f}
812 };
813
814 float NaNs[] = {Float.intBitsToFloat(0x7fc00000), // "positive" NaN
815 Float.intBitsToFloat(0xFfc00000)}; // "negative" NaN
816
817 // Tests shared between raw and non-raw versions
818 for(int i = 0; i < 2; i++) {
819 for(int j = 0; j < 2; j++) {
820 for(int m = 0; m < testCases[i].length; m++) {
821 for(int n = 0; n < testCases[j].length; n++) {
822 // copySign(magnitude, sign)
823 failures+=Tests.test("Math.copySign(float,float)",
824 testCases[i][m],testCases[j][n],
825 Math.copySign(testCases[i][m], testCases[j][n]),
826 (j==0?1.0f:-1.0f)*Math.abs(testCases[i][m]) );
827
828 failures+=Tests.test("StrictMath.copySign(float,float)",
829 testCases[i][m],testCases[j][n],
830 StrictMath.copySign(testCases[i][m], testCases[j][n]),
831 (j==0?1.0f:-1.0f)*Math.abs(testCases[i][m]) );
832 }
833 }
834 }
835 }
836
837 // For rawCopySign, NaN may effectively have either sign bit
838 // while for copySign NaNs are treated as if they always have
839 // a zero sign bit (i.e. as positive numbers)
840 for(int i = 0; i < 2; i++) {
841 for(int j = 0; j < NaNs.length; j++) {
842 for(int m = 0; m < testCases[i].length; m++) {
843 // copySign(magnitude, sign)
844
845 failures += (Math.abs(Math.copySign(testCases[i][m], NaNs[j])) ==
846 Math.abs(testCases[i][m])) ? 0:1;
847
848
849 failures+=Tests.test("StrictMath.copySign(float,float)",
850 testCases[i][m], NaNs[j],
851 StrictMath.copySign(testCases[i][m], NaNs[j]),
852 Math.abs(testCases[i][m]) );
853 }
854 }
855 }
856
857 return failures;
858 }
859
860 public static int testDoubleCopySign() {
861 int failures = 0;
862
863 // testCases[0] are logically positive numbers;
864 // testCases[1] are negative numbers.
865 double testCases [][] = {
866 {+0.0d,
867 Double.MIN_VALUE,
868 Double_MAX_SUBNORMALmm,
869 Double_MAX_SUBNORMAL,
870 Double.MIN_NORMAL,
871 1.0d,
872 3.0d,
873 Double_MAX_VALUEmm,
874 Double.MAX_VALUE,
875 infinityD,
876 },
877 {-infinityD,
878 -Double.MAX_VALUE,
879 -3.0d,
880 -1.0d,
881 -Double.MIN_NORMAL,
882 -Double_MAX_SUBNORMALmm,
883 -Double_MAX_SUBNORMAL,
884 -Double.MIN_VALUE,
885 -0.0d}
886 };
887
888 double NaNs[] = {Double.longBitsToDouble(0x7ff8000000000000L), // "positive" NaN
889 Double.longBitsToDouble(0xfff8000000000000L), // "negative" NaN
890 Double.longBitsToDouble(0x7FF0000000000001L),
891 Double.longBitsToDouble(0xFFF0000000000001L),
892 Double.longBitsToDouble(0x7FF8555555555555L),
893 Double.longBitsToDouble(0xFFF8555555555555L),
894 Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL),
895 Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL),
896 Double.longBitsToDouble(0x7FFDeadBeef00000L),
897 Double.longBitsToDouble(0xFFFDeadBeef00000L),
898 Double.longBitsToDouble(0x7FFCafeBabe00000L),
899 Double.longBitsToDouble(0xFFFCafeBabe00000L)};
900
901 // Tests shared between Math and StrictMath versions
902 for(int i = 0; i < 2; i++) {
903 for(int j = 0; j < 2; j++) {
904 for(int m = 0; m < testCases[i].length; m++) {
905 for(int n = 0; n < testCases[j].length; n++) {
906 // copySign(magnitude, sign)
907 failures+=Tests.test("MathcopySign(double,double)",
908 testCases[i][m],testCases[j][n],
909 Math.copySign(testCases[i][m], testCases[j][n]),
910 (j==0?1.0f:-1.0f)*Math.abs(testCases[i][m]) );
911
912 failures+=Tests.test("StrictMath.copySign(double,double)",
913 testCases[i][m],testCases[j][n],
914 StrictMath.copySign(testCases[i][m], testCases[j][n]),
915 (j==0?1.0f:-1.0f)*Math.abs(testCases[i][m]) );
916 }
917 }
918 }
919 }
920
921 // For Math.copySign, NaN may effectively have either sign bit
922 // while for StrictMath.copySign NaNs are treated as if they
923 // always have a zero sign bit (i.e. as positive numbers)
924 for(int i = 0; i < 2; i++) {
925 for(int j = 0; j < NaNs.length; j++) {
926 for(int m = 0; m < testCases[i].length; m++) {
927 // copySign(magnitude, sign)
928
929 failures += (Math.abs(Math.copySign(testCases[i][m], NaNs[j])) ==
930 Math.abs(testCases[i][m])) ? 0:1;
931
932
933 failures+=Tests.test("StrictMath.copySign(double,double)",
934 testCases[i][m], NaNs[j],
935 StrictMath.copySign(testCases[i][m], NaNs[j]),
936 Math.abs(testCases[i][m]) );
937 }
938 }
939 }
940
941
942 return failures;
943 }
944
945 /* ************************ scalb tests ******************************* */
946
947 static int testScalbCase(float value, int scale_factor, float expected) {
948 int failures=0;
949
950 failures+=Tests.test("Math.scalb(float,int)",
951 value, scale_factor,
952 Math.scalb(value, scale_factor), expected);
953
954 failures+=Tests.test("Math.scalb(float,int)",
955 -value, scale_factor,
956 Math.scalb(-value, scale_factor), -expected);
957
958 failures+=Tests.test("StrictMath.scalb(float,int)",
959 value, scale_factor,
960 StrictMath.scalb(value, scale_factor), expected);
961
962 failures+=Tests.test("StrictMath.scalb(float,int)",
963 -value, scale_factor,
964 StrictMath.scalb(-value, scale_factor), -expected);
965 return failures;
966 }
967
968 public static int testFloatScalb() {
969 int failures=0;
970 int MAX_SCALE = Float.MAX_EXPONENT + -Float.MIN_EXPONENT +
971 FloatConsts.SIGNIFICAND_WIDTH + 1;
972
973
974 // Arguments x, where scalb(x,n) is x for any n.
975 float [] identityTestCases = {NaNf,
976 -0.0f,
977 +0.0f,
978 infinityF,
979 -infinityF
980 };
981
982 float [] subnormalTestCases = {
983 Float.MIN_VALUE,
984 3.0f*Float.MIN_VALUE,
985 Float_MAX_SUBNORMALmm,
986 Float_MAX_SUBNORMAL
987 };
988
989 float [] someTestCases = {
990 Float.MIN_VALUE,
991 3.0f*Float.MIN_VALUE,
992 Float_MAX_SUBNORMALmm,
993 Float_MAX_SUBNORMAL,
994 Float.MIN_NORMAL,
995 1.0f,
996 2.0f,
997 3.0f,
998 (float)Math.PI,
999 Float_MAX_VALUEmm,
1000 Float.MAX_VALUE
1001 };
1002
1003 int [] oneMultiplyScalingFactors = {
1004 Float.MIN_EXPONENT,
1005 Float.MIN_EXPONENT+1,
1006 -3,
1007 -2,
1008 -1,
1009 0,
1010 1,
1011 2,
1012 3,
1013 Float.MAX_EXPONENT-1,
1014 Float.MAX_EXPONENT
1015 };
1016
1017 int [] manyScalingFactors = {
1018 Integer.MIN_VALUE,
1019 Integer.MIN_VALUE+1,
1020 -MAX_SCALE -1,
1021 -MAX_SCALE,
1022 -MAX_SCALE+1,
1023
1024 2*Float.MIN_EXPONENT-1, // -253
1025 2*Float.MIN_EXPONENT, // -252
1026 2*Float.MIN_EXPONENT+1, // -251
1027
1028 Float.MIN_EXPONENT - FloatConsts.SIGNIFICAND_WIDTH,
1029 FloatConsts.MIN_SUB_EXPONENT,
1030 -Float.MAX_EXPONENT, // -127
1031 Float.MIN_EXPONENT, // -126
1032
1033 -2,
1034 -1,
1035 0,
1036 1,
1037 2,
1038
1039 Float.MAX_EXPONENT-1, // 126
1040 Float.MAX_EXPONENT, // 127
1041 Float.MAX_EXPONENT+1, // 128
1042
1043 2*Float.MAX_EXPONENT-1, // 253
1044 2*Float.MAX_EXPONENT, // 254
1045 2*Float.MAX_EXPONENT+1, // 255
1046
1047 MAX_SCALE-1,
1048 MAX_SCALE,
1049 MAX_SCALE+1,
1050 Integer.MAX_VALUE-1,
1051 Integer.MAX_VALUE
1052 };
1053
1054 // Test cases where scaling is always a no-op
1055 for(int i=0; i < identityTestCases.length; i++) {
1056 for(int j=0; j < manyScalingFactors.length; j++) {
1057 failures += testScalbCase(identityTestCases[i],
1058 manyScalingFactors[j],
1059 identityTestCases[i]);
1060 }
1061 }
1062
1063 // Test cases where result is 0.0 or infinity due to magnitude
1064 // of the scaling factor
1065 for(int i=0; i < someTestCases.length; i++) {
1066 for(int j=0; j < manyScalingFactors.length; j++) {
1067 int scaleFactor = manyScalingFactors[j];
1068 if (Math.abs(scaleFactor) >= MAX_SCALE) {
1069 float value = someTestCases[i];
1070 failures+=testScalbCase(value,
1071 scaleFactor,
1072 Math.copySign( (scaleFactor>0?infinityF:0.0f), value) );
1073 }
1074 }
1075 }
1076
1077 // Test cases that could be done with one floating-point
1078 // multiply.
1079 for(int i=0; i < someTestCases.length; i++) {
1080 for(int j=0; j < oneMultiplyScalingFactors.length; j++) {
1081 int scaleFactor = oneMultiplyScalingFactors[j];
1082 float value = someTestCases[i];
1083
1084 failures+=testScalbCase(value,
1085 scaleFactor,
1086 value*powerOfTwoF(scaleFactor));
1087 }
1088 }
1089
1090 // Create 2^MAX_EXPONENT
1091 float twoToTheMaxExp = 1.0f; // 2^0
1092 for(int i = 0; i < Float.MAX_EXPONENT; i++)
1093 twoToTheMaxExp *=2.0f;
1094
1095 // Scale-up subnormal values until they all overflow
1096 for(int i=0; i < subnormalTestCases.length; i++) {
1097 float scale = 1.0f; // 2^j
1098 float value = subnormalTestCases[i];
1099
1100 for(int j=Float.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
1101 int scaleFactor = j;
1102
1103 failures+=testScalbCase(value,
1104 scaleFactor,
1105 (Tests.ilogb(value) +j > Float.MAX_EXPONENT ) ?
1106 Math.copySign(infinityF, value) : // overflow
1107 // calculate right answer
1108 twoToTheMaxExp*(twoToTheMaxExp*(scale*value)) );
1109 scale*=2.0f;
1110 }
1111 }
1112
1113 // Scale down a large number until it underflows. By scaling
1114 // down MAX_NORMALmm, the first subnormal result will be exact
1115 // but the next one will round -- all those results can be
1116 // checked by halving a separate value in the loop. Actually,
1117 // we can keep halving and checking until the product is zero
1118 // since:
1119 //
1120 // 1. If the scalb of MAX_VALUEmm is subnormal and *not* exact
1121 // it will round *up*
1122 //
1123 // 2. When rounding first occurs in the expected product, it
1124 // too rounds up, to 2^-MAX_EXPONENT.
1125 //
1126 // Halving expected after rounding happends to give the same
1127 // result as the scalb operation.
1128 float expected = Float_MAX_VALUEmm *0.5f;
1129 for(int i = -1; i > -MAX_SCALE; i--) {
1130 failures+=testScalbCase(Float_MAX_VALUEmm, i, expected);
1131
1132 expected *= 0.5f;
1133 }
1134
1135 // Tricky rounding tests:
1136 // Scale down a large number into subnormal range such that if
1137 // scalb is being implemented with multiple floating-point
1138 // multiplies, the value would round twice if the multiplies
1139 // were done in the wrong order.
1140
1141 float value = 0x8.0000bP-5f;
1142 expected = 0x1.00001p-129f;
1143
1144 for(int i = 0; i < 129; i++) {
1145 failures+=testScalbCase(value,
1146 -127-i,
1147 expected);
1148 value *=2.0f;
1149 }
1150
1151 return failures;
1152 }
1153
1154 static int testScalbCase(double value, int scale_factor, double expected) {
1155 int failures=0;
1156
1157 failures+=Tests.test("Math.scalb(double,int)",
1158 value, scale_factor,
1159 Math.scalb(value, scale_factor), expected);
1160
1161 failures+=Tests.test("Math.scalb(double,int)",
1162 -value, scale_factor,
1163 Math.scalb(-value, scale_factor), -expected);
1164
1165 failures+=Tests.test("StrictMath.scalb(double,int)",
1166 value, scale_factor,
1167 StrictMath.scalb(value, scale_factor), expected);
1168
1169 failures+=Tests.test("StrictMath.scalb(double,int)",
1170 -value, scale_factor,
1171 StrictMath.scalb(-value, scale_factor), -expected);
1172
1173 return failures;
1174 }
1175
1176 public static int testDoubleScalb() {
1177 int failures=0;
1178 int MAX_SCALE = Double.MAX_EXPONENT + -Double.MIN_EXPONENT +
1179 DoubleConsts.SIGNIFICAND_WIDTH + 1;
1180
1181
1182 // Arguments x, where scalb(x,n) is x for any n.
1183 double [] identityTestCases = {NaNd,
1184 -0.0,
1185 +0.0,
1186 infinityD,
1187 };
1188
1189 double [] subnormalTestCases = {
1190 Double.MIN_VALUE,
1191 3.0d*Double.MIN_VALUE,
1192 Double_MAX_SUBNORMALmm,
1193 Double_MAX_SUBNORMAL
1194 };
1195
1196 double [] someTestCases = {
1197 Double.MIN_VALUE,
1198 3.0d*Double.MIN_VALUE,
1199 Double_MAX_SUBNORMALmm,
1200 Double_MAX_SUBNORMAL,
1201 Double.MIN_NORMAL,
1202 1.0d,
1203 2.0d,
1204 3.0d,
1205 Math.PI,
1206 Double_MAX_VALUEmm,
1207 Double.MAX_VALUE
1208 };
1209
1210 int [] oneMultiplyScalingFactors = {
1211 Double.MIN_EXPONENT,
1212 Double.MIN_EXPONENT+1,
1213 -3,
1214 -2,
1215 -1,
1216 0,
1217 1,
1218 2,
1219 3,
1220 Double.MAX_EXPONENT-1,
1221 Double.MAX_EXPONENT
1222 };
1223
1224 int [] manyScalingFactors = {
1225 Integer.MIN_VALUE,
1226 Integer.MIN_VALUE+1,
1227 -MAX_SCALE -1,
1228 -MAX_SCALE,
1229 -MAX_SCALE+1,
1230
1231 2*Double.MIN_EXPONENT-1, // -2045
1232 2*Double.MIN_EXPONENT, // -2044
1233 2*Double.MIN_EXPONENT+1, // -2043
1234
1235 Double.MIN_EXPONENT, // -1022
1236 Double.MIN_EXPONENT - DoubleConsts.SIGNIFICAND_WIDTH,
1237 DoubleConsts.MIN_SUB_EXPONENT,
1238 -Double.MAX_EXPONENT, // -1023
1239 Double.MIN_EXPONENT, // -1022
1240
1241 -2,
1242 -1,
1243 0,
1244 1,
1245 2,
1246
1247 Double.MAX_EXPONENT-1, // 1022
1248 Double.MAX_EXPONENT, // 1023
1249 Double.MAX_EXPONENT+1, // 1024
1250
1251 2*Double.MAX_EXPONENT-1, // 2045
1252 2*Double.MAX_EXPONENT, // 2046
1253 2*Double.MAX_EXPONENT+1, // 2047
1254
1255 MAX_SCALE-1,
1256 MAX_SCALE,
1257 MAX_SCALE+1,
1258 Integer.MAX_VALUE-1,
1259 Integer.MAX_VALUE
1260 };
1261
1262 // Test cases where scaling is always a no-op
1263 for(int i=0; i < identityTestCases.length; i++) {
1264 for(int j=0; j < manyScalingFactors.length; j++) {
1265 failures += testScalbCase(identityTestCases[i],
1266 manyScalingFactors[j],
1267 identityTestCases[i]);
1268 }
1269 }
1270
1271 // Test cases where result is 0.0 or infinity due to magnitude
1272 // of the scaling factor
1273 for(int i=0; i < someTestCases.length; i++) {
1274 for(int j=0; j < manyScalingFactors.length; j++) {
1275 int scaleFactor = manyScalingFactors[j];
1276 if (Math.abs(scaleFactor) >= MAX_SCALE) {
1277 double value = someTestCases[i];
1278 failures+=testScalbCase(value,
1279 scaleFactor,
1280 Math.copySign( (scaleFactor>0?infinityD:0.0), value) );
1281 }
1282 }
1283 }
1284
1285 // Test cases that could be done with one floating-point
1286 // multiply.
1287 for(int i=0; i < someTestCases.length; i++) {
1288 for(int j=0; j < oneMultiplyScalingFactors.length; j++) {
1289 int scaleFactor = oneMultiplyScalingFactors[j];
1290 double value = someTestCases[i];
1291
1292 failures+=testScalbCase(value,
1293 scaleFactor,
1294 value*powerOfTwoD(scaleFactor));
1295 }
1296 }
1297
1298 // Create 2^MAX_EXPONENT
1299 double twoToTheMaxExp = 1.0; // 2^0
1300 for(int i = 0; i < Double.MAX_EXPONENT; i++)
1301 twoToTheMaxExp *=2.0;
1302
1303 // Scale-up subnormal values until they all overflow
1304 for(int i=0; i < subnormalTestCases.length; i++) {
1305 double scale = 1.0; // 2^j
1306 double value = subnormalTestCases[i];
1307
1308 for(int j=Double.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
1309 int scaleFactor = j;
1310
1311 failures+=testScalbCase(value,
1312 scaleFactor,
1313 (Tests.ilogb(value) +j > Double.MAX_EXPONENT ) ?
1314 Math.copySign(infinityD, value) : // overflow
1315 // calculate right answer
1316 twoToTheMaxExp*(twoToTheMaxExp*(scale*value)) );
1317 scale*=2.0;
1318 }
1319 }
1320
1321 // Scale down a large number until it underflows. By scaling
1322 // down MAX_NORMALmm, the first subnormal result will be exact
1323 // but the next one will round -- all those results can be
1324 // checked by halving a separate value in the loop. Actually,
1325 // we can keep halving and checking until the product is zero
1326 // since:
1327 //
1328 // 1. If the scalb of MAX_VALUEmm is subnormal and *not* exact
1329 // it will round *up*
1330 //
1331 // 2. When rounding first occurs in the expected product, it
1332 // too rounds up, to 2^-MAX_EXPONENT.
1333 //
1334 // Halving expected after rounding happends to give the same
1335 // result as the scalb operation.
1336 double expected = Double_MAX_VALUEmm *0.5f;
1337 for(int i = -1; i > -MAX_SCALE; i--) {
1338 failures+=testScalbCase(Double_MAX_VALUEmm, i, expected);
1339
1340 expected *= 0.5;
1341 }
1342
1343 // Tricky rounding tests:
1344 // Scale down a large number into subnormal range such that if
1345 // scalb is being implemented with multiple floating-point
1346 // multiplies, the value would round twice if the multiplies
1347 // were done in the wrong order.
1348
1349 double value = 0x1.000000000000bP-1;
1350 expected = 0x0.2000000000001P-1022;
1351 for(int i = 0; i < Double.MAX_EXPONENT+2; i++) {
1352 failures+=testScalbCase(value,
1353 -1024-i,
1354 expected);
1355 value *=2.0;
1356 }
1357
1358 return failures;
1359 }
1360
1361 /* ************************* ulp tests ******************************* */
1362
1363
1364 /*
1365 * Test Math.ulp and StrictMath.ulp with +d and -d.
1366 */
1367 static int testUlpCase(float f, float expected) {
1368 float minus_f = -f;
1369 int failures=0;
1370
1371 failures+=Tests.test("Math.ulp(float)", f,
1372 Math.ulp(f), expected);
1373 failures+=Tests.test("Math.ulp(float)", minus_f,
1374 Math.ulp(minus_f), expected);
1375 failures+=Tests.test("StrictMath.ulp(float)", f,
1376 StrictMath.ulp(f), expected);
1377 failures+=Tests.test("StrictMath.ulp(float)", minus_f,
1378 StrictMath.ulp(minus_f), expected);
1379 return failures;
1380 }
1381
1382 static int testUlpCase(double d, double expected) {
1383 double minus_d = -d;
1384 int failures=0;
1385
1386 failures+=Tests.test("Math.ulp(double)", d,
1387 Math.ulp(d), expected);
1388 failures+=Tests.test("Math.ulp(double)", minus_d,
1389 Math.ulp(minus_d), expected);
1390 failures+=Tests.test("StrictMath.ulp(double)", d,
1391 StrictMath.ulp(d), expected);
1392 failures+=Tests.test("StrictMath.ulp(double)", minus_d,
1393 StrictMath.ulp(minus_d), expected);
1394 return failures;
1395 }
1396
1397 public static int testFloatUlp() {
1398 int failures = 0;
1399 float [] specialValues = {NaNf,
1400 Float.POSITIVE_INFINITY,
1401 +0.0f,
1402 +1.0f,
1403 +2.0f,
1404 +16.0f,
1405 +Float.MIN_VALUE,
1406 +Float_MAX_SUBNORMAL,
1407 +Float.MIN_NORMAL,
1408 +Float.MAX_VALUE
1409 };
1410
1411 float [] specialResults = {NaNf,
1412 Float.POSITIVE_INFINITY,
1413 Float.MIN_VALUE,
1414 powerOfTwoF(-23),
1415 powerOfTwoF(-22),
1416 powerOfTwoF(-19),
1417 Float.MIN_VALUE,
1418 Float.MIN_VALUE,
1419 Float.MIN_VALUE,
1420 powerOfTwoF(104)
1421 };
1422
1423 // Special value tests
1424 for(int i = 0; i < specialValues.length; i++) {
1425 failures += testUlpCase(specialValues[i], specialResults[i]);
1426 }
1427
1428
1429 // Normal exponent tests
1430 for(int i = Float.MIN_EXPONENT; i <= Float.MAX_EXPONENT; i++) {
1431 float expected;
1432
1433 // Create power of two
1434 float po2 = powerOfTwoF(i);
1435 expected = Math.scalb(1.0f, i - (FloatConsts.SIGNIFICAND_WIDTH-1));
1436
1437 failures += testUlpCase(po2, expected);
1438
1439 // Generate some random bit patterns for the significand
1440 for(int j = 0; j < 10; j++) {
1441 int randSignif = rand.nextInt();
1442 float randFloat;
1443
1444 randFloat = Float.intBitsToFloat( // Exponent
1445 (Float.floatToIntBits(po2)&
1446 (~FloatConsts.SIGNIF_BIT_MASK)) |
1447 // Significand
1448 (randSignif &
1449 FloatConsts.SIGNIF_BIT_MASK) );
1450
1451 failures += testUlpCase(randFloat, expected);
1452 }
1453
1454 if (i > Float.MIN_EXPONENT) {
1455 float po2minus = Math.nextAfter(po2,
1456 Float.NEGATIVE_INFINITY);
1457 failures += testUlpCase(po2minus, expected/2.0f);
1458 }
1459 }
1460
1461 // Subnormal tests
1462
1463 /*
1464 * Start with MIN_VALUE, left shift, test high value, low
1465 * values, and random in between.
1466 *
1467 * Use nextAfter to calculate, high value of previous binade,
1468 * loop count i will indicate how many random bits, if any are
1469 * needed.
1470 */
1471
1472 float top=Float.MIN_VALUE;
1473 for( int i = 1;
1474 i < FloatConsts.SIGNIFICAND_WIDTH;
1475 i++, top *= 2.0f) {
1476
1477 failures += testUlpCase(top, Float.MIN_VALUE);
1478
1479 // Test largest value in next smaller binade
1480 if (i >= 3) {// (i == 1) would test 0.0;
1481 // (i == 2) would just retest MIN_VALUE
1482 testUlpCase(Math.nextAfter(top, 0.0f),
1483 Float.MIN_VALUE);
1484
1485 if( i >= 10) {
1486 // create a bit mask with (i-1) 1's in the low order
1487 // bits
1488 int mask = ~((~0)<<(i-1));
1489 float randFloat = Float.intBitsToFloat( // Exponent
1490 Float.floatToIntBits(top) |
1491 // Significand
1492 (rand.nextInt() & mask ) ) ;
1493
1494 failures += testUlpCase(randFloat, Float.MIN_VALUE);
1495 }
1496 }
1497 }
1498
1499 return failures;
1500 }
1501
1502 public static int testDoubleUlp() {
1503 int failures = 0;
1504 double [] specialValues = {NaNd,
1505 Double.POSITIVE_INFINITY,
1506 +0.0d,
1507 +1.0d,
1508 +2.0d,
1509 +16.0d,
1510 +Double.MIN_VALUE,
1511 +Double_MAX_SUBNORMAL,
1512 +Double.MIN_NORMAL,
1513 +Double.MAX_VALUE
1514 };
1515
1516 double [] specialResults = {NaNf,
1517 Double.POSITIVE_INFINITY,
1518 Double.MIN_VALUE,
1519 powerOfTwoD(-52),
1520 powerOfTwoD(-51),
1521 powerOfTwoD(-48),
1522 Double.MIN_VALUE,
1523 Double.MIN_VALUE,
1524 Double.MIN_VALUE,
1525 powerOfTwoD(971)
1526 };
1527
1528 // Special value tests
1529 for(int i = 0; i < specialValues.length; i++) {
1530 failures += testUlpCase(specialValues[i], specialResults[i]);
1531 }
1532
1533
1534 // Normal exponent tests
1535 for(int i = Double.MIN_EXPONENT; i <= Double.MAX_EXPONENT; i++) {
1536 double expected;
1537
1538 // Create power of two
1539 double po2 = powerOfTwoD(i);
1540 expected = Math.scalb(1.0, i - (DoubleConsts.SIGNIFICAND_WIDTH-1));
1541
1542 failures += testUlpCase(po2, expected);
1543
1544 // Generate some random bit patterns for the significand
1545 for(int j = 0; j < 10; j++) {
1546 long randSignif = rand.nextLong();
1547 double randDouble;
1548
1549 randDouble = Double.longBitsToDouble( // Exponent
1550 (Double.doubleToLongBits(po2)&
1551 (~DoubleConsts.SIGNIF_BIT_MASK)) |
1552 // Significand
1553 (randSignif &
1554 DoubleConsts.SIGNIF_BIT_MASK) );
1555
1556 failures += testUlpCase(randDouble, expected);
1557 }
1558
1559 if (i > Double.MIN_EXPONENT) {
1560 double po2minus = Math.nextAfter(po2,
1561 Double.NEGATIVE_INFINITY);
1562 failures += testUlpCase(po2minus, expected/2.0f);
1563 }
1564 }
1565
1566 // Subnormal tests
1567
1568 /*
1569 * Start with MIN_VALUE, left shift, test high value, low
1570 * values, and random in between.
1571 *
1572 * Use nextAfter to calculate, high value of previous binade,
1573 * loop count i will indicate how many random bits, if any are
1574 * needed.
1575 */
1576
1577 double top=Double.MIN_VALUE;
1578 for( int i = 1;
1579 i < DoubleConsts.SIGNIFICAND_WIDTH;
1580 i++, top *= 2.0f) {
1581
1582 failures += testUlpCase(top, Double.MIN_VALUE);
1583
1584 // Test largest value in next smaller binade
1585 if (i >= 3) {// (i == 1) would test 0.0;
1586 // (i == 2) would just retest MIN_VALUE
1587 testUlpCase(Math.nextAfter(top, 0.0f),
1588 Double.MIN_VALUE);
1589
1590 if( i >= 10) {
1591 // create a bit mask with (i-1) 1's in the low order
1592 // bits
1593 int mask = ~((~0)<<(i-1));
1594 double randDouble = Double.longBitsToDouble( // Exponent
1595 Double.doubleToLongBits(top) |
1596 // Significand
1597 (rand.nextLong() & mask ) ) ;
1598
1599 failures += testUlpCase(randDouble, Double.MIN_VALUE);
1600 }
1601 }
1602 }
1603
1604 return failures;
1605 }
1606
1607 public static int testFloatSignum() {
1608 int failures = 0;
1609 float testCases [][] = {
1610 {NaNf, NaNf},
1611 {-infinityF, -1.0f},
1612 {-Float.MAX_VALUE, -1.0f},
1613 {-Float.MIN_NORMAL, -1.0f},
1614 {-1.0f, -1.0f},
1615 {-2.0f, -1.0f},
1616 {-Float_MAX_SUBNORMAL, -1.0f},
1617 {-Float.MIN_VALUE, -1.0f},
1618 {-0.0f, -0.0f},
1619 {+0.0f, +0.0f},
1620 {Float.MIN_VALUE, 1.0f},
1621 {Float_MAX_SUBNORMALmm, 1.0f},
1622 {Float_MAX_SUBNORMAL, 1.0f},
1623 {Float.MIN_NORMAL, 1.0f},
1624 {1.0f, 1.0f},
1625 {2.0f, 1.0f},
1626 {Float_MAX_VALUEmm, 1.0f},
1627 {Float.MAX_VALUE, 1.0f},
1628 {infinityF, 1.0f}
1629 };
1630
1631 for(int i = 0; i < testCases.length; i++) {
1632 failures+=Tests.test("Math.signum(float)",
1633 testCases[i][0], Math.signum(testCases[i][0]), testCases[i][1]);
1634 failures+=Tests.test("StrictMath.signum(float)",
1635 testCases[i][0], StrictMath.signum(testCases[i][0]), testCases[i][1]);
1636 }
1637
1638 return failures;
1639 }
1640
1641 public static int testDoubleSignum() {
1642 int failures = 0;
1643 double testCases [][] = {
1644 {NaNd, NaNd},
1645 {-infinityD, -1.0},
1646 {-Double.MAX_VALUE, -1.0},
1647 {-Double.MIN_NORMAL, -1.0},
1648 {-1.0, -1.0},
1649 {-2.0, -1.0},
1650 {-Double_MAX_SUBNORMAL, -1.0},
1651 {-Double.MIN_VALUE, -1.0d},
1652 {-0.0d, -0.0d},
1653 {+0.0d, +0.0d},
1654 {Double.MIN_VALUE, 1.0},
1655 {Double_MAX_SUBNORMALmm, 1.0},
1656 {Double_MAX_SUBNORMAL, 1.0},
1657 {Double.MIN_NORMAL, 1.0},
1658 {1.0, 1.0},
1659 {2.0, 1.0},
1660 {Double_MAX_VALUEmm, 1.0},
1661 {Double.MAX_VALUE, 1.0},
1662 {infinityD, 1.0}
1663 };
1664
1665 for(int i = 0; i < testCases.length; i++) {
1666 failures+=Tests.test("Math.signum(double)",
1667 testCases[i][0], Math.signum(testCases[i][0]), testCases[i][1]);
1668 failures+=Tests.test("StrictMath.signum(double)",
1669 testCases[i][0], StrictMath.signum(testCases[i][0]), testCases[i][1]);
1670 }
1671
1672 return failures;
1673 }
1674
1675
1676 public static void main(String argv[]) {
1677 int failures = 0;
1678
1679 failures += testFloatGetExponent();
1680 failures += testDoubleGetExponent();
1681
1682 failures += testFloatNextAfter();
1683 failures += testDoubleNextAfter();
1684
1685 failures += testFloatNextUp();
1686 failures += testDoubleNextUp();
1687
1688 failures += testFloatNextDown();
1689 failures += testDoubleNextDown();
1690
1691 failures += testFloatBooleanMethods();
1692 failures += testDoubleBooleanMethods();
1693
1694 failures += testFloatCopySign();
1695 failures += testDoubleCopySign();
1696
1697 failures += testFloatScalb();
1698 failures += testDoubleScalb();
1699
1700 failures += testFloatUlp();
1701 failures += testDoubleUlp();
1702
1703 failures += testFloatSignum();
1704 failures += testDoubleSignum();
1705
1706 if (failures > 0) {
1707 System.err.println("Testing the recommended functions incurred "
1708 + failures + " failures.");
1709 throw new RuntimeException();
1710 }
1711 }
1712 }