1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.commons.math4.legacy.core.dfp;
19
20 import org.apache.commons.math4.legacy.core.ExtendedFieldElementAbstractTest;
21 import org.apache.commons.math4.core.jdkmath.JdkMath;
22 import org.apache.commons.numbers.core.Precision;
23 import org.junit.After;
24 import org.junit.Assert;
25 import org.junit.Before;
26 import org.junit.Test;
27
28 public class DfpTest extends ExtendedFieldElementAbstractTest<Dfp> {
29
30 private DfpField field;
31 private Dfp pinf;
32 private Dfp ninf;
33 private Dfp nan;
34 private Dfp snan;
35 private Dfp qnan;
36
37 @Override
38 protected Dfp build(final double x) {
39 return field.newDfp(x);
40 }
41
42 @Before
43 public void setUp() {
44
45 field = new DfpField(20);
46 pinf = field.newDfp("1").divide(field.newDfp("0"));
47 ninf = field.newDfp("-1").divide(field.newDfp("0"));
48 nan = field.newDfp("0").divide(field.newDfp("0"));
49 snan = field.newDfp((byte)1, Dfp.SNAN);
50 qnan = field.newDfp((byte)1, Dfp.QNAN);
51 ninf.getField().clearIEEEFlags();
52 }
53
54 @After
55 public void tearDown() {
56 field = null;
57 pinf = null;
58 ninf = null;
59 nan = null;
60 snan = null;
61 qnan = null;
62 }
63
64
65
66
67 private void test(Dfp x, Dfp y, int flags, String desc) {
68 boolean b = x.equals(y);
69
70 if (!x.equals(y) && !x.unequal(y)) {
71 b = x.toString().equals(y.toString());
72 }
73
74 if (x.equals(field.newDfp("0"))) {
75 b = b && (x.toString().equals(y.toString()));
76 }
77
78 b = b && x.getField().getIEEEFlags() == flags;
79
80 if (!b) {
81 Assert.assertTrue(
82 "assertion failed " + desc + " x = " + x.toString() + " flags = " + x.getField().getIEEEFlags(), b);
83 }
84
85 x.getField().clearIEEEFlags();
86 }
87
88 @Test
89 public void testByteConstructor() {
90 Assert.assertEquals("0.", new Dfp(field, (byte) 0).toString());
91 Assert.assertEquals("1.", new Dfp(field, (byte) 1).toString());
92 Assert.assertEquals("-1.", new Dfp(field, (byte) -1).toString());
93 Assert.assertEquals("-128.", new Dfp(field, Byte.MIN_VALUE).toString());
94 Assert.assertEquals("127.", new Dfp(field, Byte.MAX_VALUE).toString());
95 }
96
97 @Test
98 public void testIntConstructor() {
99 Assert.assertEquals("0.", new Dfp(field, 0).toString());
100 Assert.assertEquals("1.", new Dfp(field, 1).toString());
101 Assert.assertEquals("-1.", new Dfp(field, -1).toString());
102 Assert.assertEquals("1234567890.", new Dfp(field, 1234567890).toString());
103 Assert.assertEquals("-1234567890.", new Dfp(field, -1234567890).toString());
104 Assert.assertEquals("-2147483648.", new Dfp(field, Integer.MIN_VALUE).toString());
105 Assert.assertEquals("2147483647.", new Dfp(field, Integer.MAX_VALUE).toString());
106 }
107
108 @Test
109 public void testLongConstructor() {
110 Assert.assertEquals("0.", new Dfp(field, 0L).toString());
111 Assert.assertEquals("1.", new Dfp(field, 1L).toString());
112 Assert.assertEquals("-1.", new Dfp(field, -1L).toString());
113 Assert.assertEquals("1234567890.", new Dfp(field, 1234567890L).toString());
114 Assert.assertEquals("-1234567890.", new Dfp(field, -1234567890L).toString());
115 Assert.assertEquals("-9223372036854775808.", new Dfp(field, Long.MIN_VALUE).toString());
116 Assert.assertEquals("9223372036854775807.", new Dfp(field, Long.MAX_VALUE).toString());
117 }
118
119
120
121
122 @Test
123 public void testAdd() {
124 test(field.newDfp("1").add(field.newDfp("1")),
125 field.newDfp("2"),
126 0, "Add #1");
127
128 test(field.newDfp("1").add(field.newDfp("-1")),
129 field.newDfp("0"),
130 0, "Add #2");
131
132 test(field.newDfp("-1").add(field.newDfp("1")),
133 field.newDfp("0"),
134 0, "Add #3");
135
136 test(field.newDfp("-1").add(field.newDfp("-1")),
137 field.newDfp("-2"),
138 0, "Add #4");
139
140
141
142 test(field.newDfp("1").add(field.newDfp("1e-16")),
143 field.newDfp("1.0000000000000001"),
144 0, "Add #5");
145
146 test(field.newDfp("1").add(field.newDfp("1e-17")),
147 field.newDfp("1"),
148 DfpField.FLAG_INEXACT, "Add #6");
149
150 test(field.newDfp("0.90999999999999999999").add(field.newDfp("0.1")),
151 field.newDfp("1.01"),
152 DfpField.FLAG_INEXACT, "Add #7");
153
154 test(field.newDfp(".10000000000000005000").add(field.newDfp(".9")),
155 field.newDfp("1."),
156 DfpField.FLAG_INEXACT, "Add #8");
157
158 test(field.newDfp(".10000000000000015000").add(field.newDfp(".9")),
159 field.newDfp("1.0000000000000002"),
160 DfpField.FLAG_INEXACT, "Add #9");
161
162 test(field.newDfp(".10000000000000014999").add(field.newDfp(".9")),
163 field.newDfp("1.0000000000000001"),
164 DfpField.FLAG_INEXACT, "Add #10");
165
166 test(field.newDfp(".10000000000000015001").add(field.newDfp(".9")),
167 field.newDfp("1.0000000000000002"),
168 DfpField.FLAG_INEXACT, "Add #11");
169
170 test(field.newDfp(".11111111111111111111").add(field.newDfp("11.1111111111111111")),
171 field.newDfp("11.22222222222222222222"),
172 DfpField.FLAG_INEXACT, "Add #12");
173
174 test(field.newDfp(".11111111111111111111").add(field.newDfp("1111111111111111.1111")),
175 field.newDfp("1111111111111111.2222"),
176 DfpField.FLAG_INEXACT, "Add #13");
177
178 test(field.newDfp(".11111111111111111111").add(field.newDfp("11111111111111111111")),
179 field.newDfp("11111111111111111111"),
180 DfpField.FLAG_INEXACT, "Add #14");
181
182 test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("-1e131052")),
183 field.newDfp("9.9999999999999999998e131071"),
184 0, "Add #15");
185
186 test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("1e131052")),
187 pinf,
188 DfpField.FLAG_OVERFLOW, "Add #16");
189
190 test(field.newDfp("-9.9999999999999999999e131071").add(field.newDfp("-1e131052")),
191 ninf,
192 DfpField.FLAG_OVERFLOW, "Add #17");
193
194 test(field.newDfp("-9.9999999999999999999e131071").add(field.newDfp("1e131052")),
195 field.newDfp("-9.9999999999999999998e131071"),
196 0, "Add #18");
197
198 test(field.newDfp("1e-131072").add(field.newDfp("1e-131072")),
199 field.newDfp("2e-131072"),
200 0, "Add #19");
201
202 test(field.newDfp("1.0000000000000001e-131057").add(field.newDfp("-1e-131057")),
203 field.newDfp("1e-131073"),
204 DfpField.FLAG_UNDERFLOW, "Add #20");
205
206 test(field.newDfp("1.1e-131072").add(field.newDfp("-1e-131072")),
207 field.newDfp("1e-131073"),
208 DfpField.FLAG_UNDERFLOW, "Add #21");
209
210 test(field.newDfp("1.0000000000000001e-131072").add(field.newDfp("-1e-131072")),
211 field.newDfp("1e-131088"),
212 DfpField.FLAG_UNDERFLOW, "Add #22");
213
214 test(field.newDfp("1.0000000000000001e-131078").add(field.newDfp("-1e-131078")),
215 field.newDfp("0"),
216 DfpField.FLAG_UNDERFLOW, "Add #23");
217
218 test(field.newDfp("1.0").add(field.newDfp("-1e-20")),
219 field.newDfp("0.99999999999999999999"),
220 0, "Add #23.1");
221
222 test(field.newDfp("-0.99999999999999999999").add(field.newDfp("1")),
223 field.newDfp("0.00000000000000000001"),
224 0, "Add #23.2");
225
226 test(field.newDfp("1").add(field.newDfp("0")),
227 field.newDfp("1"),
228 0, "Add #24");
229
230 test(field.newDfp("0").add(field.newDfp("0")),
231 field.newDfp("0"),
232 0, "Add #25");
233
234 test(field.newDfp("-0").add(field.newDfp("0")),
235 field.newDfp("0"),
236 0, "Add #26");
237
238 test(field.newDfp("0").add(field.newDfp("-0")),
239 field.newDfp("0"),
240 0, "Add #27");
241
242 test(field.newDfp("-0").add(field.newDfp("-0")),
243 field.newDfp("-0"),
244 0, "Add #28");
245
246 test(field.newDfp("1e-20").add(field.newDfp("0")),
247 field.newDfp("1e-20"),
248 0, "Add #29");
249
250 test(field.newDfp("1e-40").add(field.newDfp("0")),
251 field.newDfp("1e-40"),
252 0, "Add #30");
253
254 test(pinf.add(ninf),
255 nan,
256 DfpField.FLAG_INVALID, "Add #31");
257
258 test(ninf.add(pinf),
259 nan,
260 DfpField.FLAG_INVALID, "Add #32");
261
262 test(ninf.add(ninf),
263 ninf,
264 0, "Add #33");
265
266 test(pinf.add(pinf),
267 pinf,
268 0, "Add #34");
269
270 test(pinf.add(field.newDfp("0")),
271 pinf,
272 0, "Add #35");
273
274 test(pinf.add(field.newDfp("-1e131071")),
275 pinf,
276 0, "Add #36");
277
278 test(pinf.add(field.newDfp("1e131071")),
279 pinf,
280 0, "Add #37");
281
282 test(field.newDfp("0").add(pinf),
283 pinf,
284 0, "Add #38");
285
286 test(field.newDfp("-1e131071").add(pinf),
287 pinf,
288 0, "Add #39");
289
290 test(field.newDfp("1e131071").add(pinf),
291 pinf,
292 0, "Add #40");
293
294 test(ninf.add(field.newDfp("0")),
295 ninf,
296 0, "Add #41");
297
298 test(ninf.add(field.newDfp("-1e131071")),
299 ninf,
300 0, "Add #42");
301
302 test(ninf.add(field.newDfp("1e131071")),
303 ninf,
304 0, "Add #43");
305
306 test(field.newDfp("0").add(ninf),
307 ninf,
308 0, "Add #44");
309
310 test(field.newDfp("-1e131071").add(ninf),
311 ninf,
312 0, "Add #45");
313
314 test(field.newDfp("1e131071").add(ninf),
315 ninf,
316 0, "Add #46");
317
318 test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("5e131051")),
319 pinf,
320 DfpField.FLAG_OVERFLOW, "Add #47");
321
322 test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("4.9999999999999999999e131051")),
323 field.newDfp("9.9999999999999999999e131071"),
324 DfpField.FLAG_INEXACT, "Add #48");
325
326 test(nan.add(field.newDfp("1")),
327 nan,
328 0, "Add #49");
329
330 test(field.newDfp("1").add(nan),
331 nan,
332 0, "Add #50");
333
334 test(field.newDfp("12345678123456781234").add(field.newDfp("0.12345678123456781234")),
335 field.newDfp("12345678123456781234"),
336 DfpField.FLAG_INEXACT, "Add #51");
337
338 test(field.newDfp("12345678123456781234").add(field.newDfp("123.45678123456781234")),
339 field.newDfp("12345678123456781357"),
340 DfpField.FLAG_INEXACT, "Add #52");
341
342 test(field.newDfp("123.45678123456781234").add(field.newDfp("12345678123456781234")),
343 field.newDfp("12345678123456781357"),
344 DfpField.FLAG_INEXACT, "Add #53");
345
346 test(field.newDfp("12345678123456781234").add(field.newDfp(".00001234567812345678")),
347 field.newDfp("12345678123456781234"),
348 DfpField.FLAG_INEXACT, "Add #54");
349
350 test(field.newDfp("12345678123456781234").add(field.newDfp(".00000000123456781234")),
351 field.newDfp("12345678123456781234"),
352 DfpField.FLAG_INEXACT, "Add #55");
353
354 test(field.newDfp("-0").add(field.newDfp("-0")),
355 field.newDfp("-0"),
356 0, "Add #56");
357
358 test(field.newDfp("0").add(field.newDfp("-0")),
359 field.newDfp("0"),
360 0, "Add #57");
361
362 test(field.newDfp("-0").add(field.newDfp("0")),
363 field.newDfp("0"),
364 0, "Add #58");
365
366 test(field.newDfp("0").add(field.newDfp("0")),
367 field.newDfp("0"),
368 0, "Add #59");
369 }
370
371
372
373
374
375
376 private void cmptst(Dfp a, Dfp b, String op, boolean result, double num) {
377 if (op.equals("equal")) {
378 if (a.equals(b) != result) {
379 assertionFailOpNum(op, num);
380 }
381 }
382
383 if (op.equals("unequal")) {
384 if (a.unequal(b) != result) {
385 assertionFailOpNum(op, num);
386 }
387 }
388
389 if (op.equals("lessThan")) {
390 if (a.lessThan(b) != result) {
391 assertionFailOpNum(op, num);
392 }
393 }
394
395 if (op.equals("greaterThan")) {
396 if (a.greaterThan(b) != result) {
397 assertionFailOpNum(op, num);
398 }
399 }
400 }
401
402 @Test
403 public void testCompare() {
404
405
406 field.clearIEEEFlags();
407
408 cmptst(field.newDfp("0"), field.newDfp("0"), "equal", true, 1);
409 cmptst(field.newDfp("0"), field.newDfp("-0"), "equal", true, 2);
410 cmptst(field.newDfp("-0"), field.newDfp("-0"), "equal", true, 3);
411 cmptst(field.newDfp("-0"), field.newDfp("0"), "equal", true, 4);
412
413
414
415 cmptst(field.newDfp("0"), field.newDfp("1"), "equal", false, 5);
416 cmptst(field.newDfp("1"), field.newDfp("0"), "equal", false, 6);
417 cmptst(field.newDfp("-1"), field.newDfp("0"), "equal", false, 7);
418 cmptst(field.newDfp("0"), field.newDfp("-1"), "equal", false, 8);
419 cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "equal", false, 9);
420
421 if (field.getIEEEFlags() != 0) {
422 assertionFailDfpField(field);
423 }
424
425 cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "equal", false, 10);
426
427
428 if (field.getIEEEFlags() != DfpField.FLAG_UNDERFLOW) {
429 assertionFailDfpField(field);
430 }
431
432 field.clearIEEEFlags();
433
434 cmptst(field.newDfp("0"), field.newDfp("1e+131071"), "equal", false, 11);
435
436
437
438 cmptst(field.newDfp("0"), pinf, "equal", false, 12);
439 cmptst(field.newDfp("0"), ninf, "equal", false, 13);
440 cmptst(field.newDfp("-0"), pinf, "equal", false, 14);
441 cmptst(field.newDfp("-0"), ninf, "equal", false, 15);
442 cmptst(pinf, field.newDfp("0"), "equal", false, 16);
443 cmptst(ninf, field.newDfp("0"), "equal", false, 17);
444 cmptst(pinf, field.newDfp("-0"), "equal", false, 18);
445 cmptst(ninf, field.newDfp("-0"), "equal", false, 19);
446 cmptst(ninf, pinf, "equal", false, 19.10);
447 cmptst(pinf, ninf, "equal", false, 19.11);
448 cmptst(pinf, pinf, "equal", true, 19.12);
449 cmptst(ninf, ninf, "equal", true, 19.13);
450
451
452 cmptst(field.newDfp("1"), field.newDfp("1"), "equal", true, 20);
453 cmptst(field.newDfp("1"), field.newDfp("-1"), "equal", false, 21);
454 cmptst(field.newDfp("-1"), field.newDfp("-1"), "equal", true, 22);
455 cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "equal", false, 23);
456
457
458
459 cmptst(field.newDfp("1e20"), field.newDfp("1.0000000000000001"), "equal", false, 24);
460 if (field.getIEEEFlags() != 0) {
461 assertionFailDfpField(field);
462 }
463
464 cmptst(field.newDfp("0.000001"), field.newDfp("1e-6"), "equal", true, 25);
465
466
467
468 cmptst(snan, snan, "equal", false, 27);
469 cmptst(qnan, qnan, "equal", false, 28);
470 cmptst(snan, qnan, "equal", false, 29);
471 cmptst(qnan, snan, "equal", false, 30);
472 cmptst(qnan, field.newDfp("0"), "equal", false, 31);
473 cmptst(snan, field.newDfp("0"), "equal", false, 32);
474 cmptst(field.newDfp("0"), snan, "equal", false, 33);
475 cmptst(field.newDfp("0"), qnan, "equal", false, 34);
476 cmptst(qnan, pinf, "equal", false, 35);
477 cmptst(snan, pinf, "equal", false, 36);
478 cmptst(pinf, snan, "equal", false, 37);
479 cmptst(pinf, qnan, "equal", false, 38);
480 cmptst(qnan, ninf, "equal", false, 39);
481 cmptst(snan, ninf, "equal", false, 40);
482 cmptst(ninf, snan, "equal", false, 41);
483 cmptst(ninf, qnan, "equal", false, 42);
484 cmptst(qnan, field.newDfp("-1"), "equal", false, 43);
485 cmptst(snan, field.newDfp("-1"), "equal", false, 44);
486 cmptst(field.newDfp("-1"), snan, "equal", false, 45);
487 cmptst(field.newDfp("-1"), qnan, "equal", false, 46);
488 cmptst(qnan, field.newDfp("1"), "equal", false, 47);
489 cmptst(snan, field.newDfp("1"), "equal", false, 48);
490 cmptst(field.newDfp("1"), snan, "equal", false, 49);
491 cmptst(field.newDfp("1"), qnan, "equal", false, 50);
492 cmptst(snan.negate(), snan, "equal", false, 51);
493 cmptst(qnan.negate(), qnan, "equal", false, 52);
494
495
496
497
498
499 cmptst(field.newDfp("0"), field.newDfp("0"), "unequal", false, 1);
500 cmptst(field.newDfp("0"), field.newDfp("-0"), "unequal", false, 2);
501 cmptst(field.newDfp("-0"), field.newDfp("-0"), "unequal", false, 3);
502 cmptst(field.newDfp("-0"), field.newDfp("0"), "unequal", false, 4);
503
504
505
506 cmptst(field.newDfp("0"), field.newDfp("1"), "unequal", true, 5);
507 cmptst(field.newDfp("1"), field.newDfp("0"), "unequal", true, 6);
508 cmptst(field.newDfp("-1"), field.newDfp("0"), "unequal", true, 7);
509 cmptst(field.newDfp("0"), field.newDfp("-1"), "unequal", true, 8);
510 cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "unequal", true, 9);
511
512 if (field.getIEEEFlags() != 0) {
513 assertionFailDfpField(field);
514 }
515
516 cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "unequal", true, 10);
517
518
519 if (field.getIEEEFlags() != DfpField.FLAG_UNDERFLOW) {
520 assertionFailDfpField(field);
521 }
522
523 field.clearIEEEFlags();
524
525 cmptst(field.newDfp("0"), field.newDfp("1e+131071"), "unequal", true, 11);
526
527
528
529 cmptst(field.newDfp("0"), pinf, "unequal", true, 12);
530 cmptst(field.newDfp("0"), ninf, "unequal", true, 13);
531 cmptst(field.newDfp("-0"), pinf, "unequal", true, 14);
532 cmptst(field.newDfp("-0"), ninf, "unequal", true, 15);
533 cmptst(pinf, field.newDfp("0"), "unequal", true, 16);
534 cmptst(ninf, field.newDfp("0"), "unequal", true, 17);
535 cmptst(pinf, field.newDfp("-0"), "unequal", true, 18);
536 cmptst(ninf, field.newDfp("-0"), "unequal", true, 19);
537 cmptst(ninf, pinf, "unequal", true, 19.10);
538 cmptst(pinf, ninf, "unequal", true, 19.11);
539 cmptst(pinf, pinf, "unequal", false, 19.12);
540 cmptst(ninf, ninf, "unequal", false, 19.13);
541
542
543 cmptst(field.newDfp("1"), field.newDfp("1"), "unequal", false, 20);
544 cmptst(field.newDfp("1"), field.newDfp("-1"), "unequal", true, 21);
545 cmptst(field.newDfp("-1"), field.newDfp("-1"), "unequal", false, 22);
546 cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "unequal", true, 23);
547
548
549
550 cmptst(field.newDfp("1e20"), field.newDfp("1.0000000000000001"), "unequal", true, 24);
551 if (field.getIEEEFlags() != 0) {
552 assertionFailDfpField(field);
553 }
554
555 cmptst(field.newDfp("0.000001"), field.newDfp("1e-6"), "unequal", false, 25);
556
557
558
559 cmptst(snan, snan, "unequal", false, 27);
560 cmptst(qnan, qnan, "unequal", false, 28);
561 cmptst(snan, qnan, "unequal", false, 29);
562 cmptst(qnan, snan, "unequal", false, 30);
563 cmptst(qnan, field.newDfp("0"), "unequal", false, 31);
564 cmptst(snan, field.newDfp("0"), "unequal", false, 32);
565 cmptst(field.newDfp("0"), snan, "unequal", false, 33);
566 cmptst(field.newDfp("0"), qnan, "unequal", false, 34);
567 cmptst(qnan, pinf, "unequal", false, 35);
568 cmptst(snan, pinf, "unequal", false, 36);
569 cmptst(pinf, snan, "unequal", false, 37);
570 cmptst(pinf, qnan, "unequal", false, 38);
571 cmptst(qnan, ninf, "unequal", false, 39);
572 cmptst(snan, ninf, "unequal", false, 40);
573 cmptst(ninf, snan, "unequal", false, 41);
574 cmptst(ninf, qnan, "unequal", false, 42);
575 cmptst(qnan, field.newDfp("-1"), "unequal", false, 43);
576 cmptst(snan, field.newDfp("-1"), "unequal", false, 44);
577 cmptst(field.newDfp("-1"), snan, "unequal", false, 45);
578 cmptst(field.newDfp("-1"), qnan, "unequal", false, 46);
579 cmptst(qnan, field.newDfp("1"), "unequal", false, 47);
580 cmptst(snan, field.newDfp("1"), "unequal", false, 48);
581 cmptst(field.newDfp("1"), snan, "unequal", false, 49);
582 cmptst(field.newDfp("1"), qnan, "unequal", false, 50);
583 cmptst(snan.negate(), snan, "unequal", false, 51);
584 cmptst(qnan.negate(), qnan, "unequal", false, 52);
585
586 if (field.getIEEEFlags() != 0) {
587 assertionFail("compare unequal flags = " + field.getIEEEFlags());
588 }
589
590
591
592
593
594 cmptst(field.newDfp("0"), field.newDfp("0"), "lessThan", false, 1);
595 cmptst(field.newDfp("0"), field.newDfp("-0"), "lessThan", false, 2);
596 cmptst(field.newDfp("-0"), field.newDfp("-0"), "lessThan", false, 3);
597 cmptst(field.newDfp("-0"), field.newDfp("0"), "lessThan", false, 4);
598
599
600
601 cmptst(field.newDfp("0"), field.newDfp("1"), "lessThan", true, 5);
602 cmptst(field.newDfp("1"), field.newDfp("0"), "lessThan", false, 6);
603 cmptst(field.newDfp("-1"), field.newDfp("0"), "lessThan", true, 7);
604 cmptst(field.newDfp("0"), field.newDfp("-1"), "lessThan", false, 8);
605 cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "lessThan", true, 9);
606
607 if (field.getIEEEFlags() != 0) {
608 assertionFailDfpField(field);
609 }
610
611 cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "lessThan", true, 10);
612
613
614 if (field.getIEEEFlags() != DfpField.FLAG_UNDERFLOW) {
615 assertionFailDfpField(field);
616 }
617 field.clearIEEEFlags();
618
619 cmptst(field.newDfp("0"), field.newDfp("1e+131071"), "lessThan", true, 11);
620
621
622
623 cmptst(field.newDfp("0"), pinf, "lessThan", true, 12);
624 cmptst(field.newDfp("0"), ninf, "lessThan", false, 13);
625 cmptst(field.newDfp("-0"), pinf, "lessThan", true, 14);
626 cmptst(field.newDfp("-0"), ninf, "lessThan", false, 15);
627 cmptst(pinf, field.newDfp("0"), "lessThan", false, 16);
628 cmptst(ninf, field.newDfp("0"), "lessThan", true, 17);
629 cmptst(pinf, field.newDfp("-0"), "lessThan", false, 18);
630 cmptst(ninf, field.newDfp("-0"), "lessThan", true, 19);
631 cmptst(ninf, pinf, "lessThan", true, 19.10);
632 cmptst(pinf, ninf, "lessThan", false, 19.11);
633 cmptst(pinf, pinf, "lessThan", false, 19.12);
634 cmptst(ninf, ninf, "lessThan", false, 19.13);
635
636
637 cmptst(field.newDfp("1"), field.newDfp("1"), "lessThan", false, 20);
638 cmptst(field.newDfp("1"), field.newDfp("-1"), "lessThan", false, 21);
639 cmptst(field.newDfp("-1"), field.newDfp("-1"), "lessThan", false, 22);
640 cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "lessThan", true, 23);
641
642
643
644 cmptst(field.newDfp("1e20"), field.newDfp("1.0000000000000001"), "lessThan", false, 24);
645 if (field.getIEEEFlags() != 0) {
646 assertionFailDfpField(field);
647 }
648
649 cmptst(field.newDfp("0.000001"), field.newDfp("1e-6"), "lessThan", false, 25);
650
651
652 cmptst(snan, snan, "lessThan", false, 27);
653 cmptst(qnan, qnan, "lessThan", false, 28);
654 cmptst(snan, qnan, "lessThan", false, 29);
655 cmptst(qnan, snan, "lessThan", false, 30);
656 cmptst(qnan, field.newDfp("0"), "lessThan", false, 31);
657 cmptst(snan, field.newDfp("0"), "lessThan", false, 32);
658 cmptst(field.newDfp("0"), snan, "lessThan", false, 33);
659 cmptst(field.newDfp("0"), qnan, "lessThan", false, 34);
660 cmptst(qnan, pinf, "lessThan", false, 35);
661 cmptst(snan, pinf, "lessThan", false, 36);
662 cmptst(pinf, snan, "lessThan", false, 37);
663 cmptst(pinf, qnan, "lessThan", false, 38);
664 cmptst(qnan, ninf, "lessThan", false, 39);
665 cmptst(snan, ninf, "lessThan", false, 40);
666 cmptst(ninf, snan, "lessThan", false, 41);
667 cmptst(ninf, qnan, "lessThan", false, 42);
668 cmptst(qnan, field.newDfp("-1"), "lessThan", false, 43);
669 cmptst(snan, field.newDfp("-1"), "lessThan", false, 44);
670 cmptst(field.newDfp("-1"), snan, "lessThan", false, 45);
671 cmptst(field.newDfp("-1"), qnan, "lessThan", false, 46);
672 cmptst(qnan, field.newDfp("1"), "lessThan", false, 47);
673 cmptst(snan, field.newDfp("1"), "lessThan", false, 48);
674 cmptst(field.newDfp("1"), snan, "lessThan", false, 49);
675 cmptst(field.newDfp("1"), qnan, "lessThan", false, 50);
676 cmptst(snan.negate(), snan, "lessThan", false, 51);
677 cmptst(qnan.negate(), qnan, "lessThan", false, 52);
678
679
680 if (field.getIEEEFlags() != DfpField.FLAG_INVALID) {
681 assertionFail("compare lessThan flags = " + field.getIEEEFlags());
682 }
683 field.clearIEEEFlags();
684
685
686
687
688
689 cmptst(field.newDfp("0"), field.newDfp("0"), "greaterThan", false, 1);
690 cmptst(field.newDfp("0"), field.newDfp("-0"), "greaterThan", false, 2);
691 cmptst(field.newDfp("-0"), field.newDfp("-0"), "greaterThan", false, 3);
692 cmptst(field.newDfp("-0"), field.newDfp("0"), "greaterThan", false, 4);
693
694
695
696 cmptst(field.newDfp("0"), field.newDfp("1"), "greaterThan", false, 5);
697 cmptst(field.newDfp("1"), field.newDfp("0"), "greaterThan", true, 6);
698 cmptst(field.newDfp("-1"), field.newDfp("0"), "greaterThan", false, 7);
699 cmptst(field.newDfp("0"), field.newDfp("-1"), "greaterThan", true, 8);
700 cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "greaterThan", false, 9);
701
702 if (field.getIEEEFlags() != 0) {
703 assertionFailDfpField(field);
704 }
705
706 cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "greaterThan", false, 10);
707
708
709 if (field.getIEEEFlags() != DfpField.FLAG_UNDERFLOW) {
710 assertionFailDfpField(field);
711 }
712 field.clearIEEEFlags();
713
714 cmptst(field.newDfp("0"), field.newDfp("1e+131071"), "greaterThan", false, 11);
715
716
717
718 cmptst(field.newDfp("0"), pinf, "greaterThan", false, 12);
719 cmptst(field.newDfp("0"), ninf, "greaterThan", true, 13);
720 cmptst(field.newDfp("-0"), pinf, "greaterThan", false, 14);
721 cmptst(field.newDfp("-0"), ninf, "greaterThan", true, 15);
722 cmptst(pinf, field.newDfp("0"), "greaterThan", true, 16);
723 cmptst(ninf, field.newDfp("0"), "greaterThan", false, 17);
724 cmptst(pinf, field.newDfp("-0"), "greaterThan", true, 18);
725 cmptst(ninf, field.newDfp("-0"), "greaterThan", false, 19);
726 cmptst(ninf, pinf, "greaterThan", false, 19.10);
727 cmptst(pinf, ninf, "greaterThan", true, 19.11);
728 cmptst(pinf, pinf, "greaterThan", false, 19.12);
729 cmptst(ninf, ninf, "greaterThan", false, 19.13);
730
731
732 cmptst(field.newDfp("1"), field.newDfp("1"), "greaterThan", false, 20);
733 cmptst(field.newDfp("1"), field.newDfp("-1"), "greaterThan", true, 21);
734 cmptst(field.newDfp("-1"), field.newDfp("-1"), "greaterThan", false, 22);
735 cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "greaterThan", false, 23);
736
737
738
739 cmptst(field.newDfp("1e20"), field.newDfp("1.0000000000000001"), "greaterThan", true, 24);
740 if (field.getIEEEFlags() != 0) {
741 assertionFailDfpField(field);
742 }
743
744 cmptst(field.newDfp("0.000001"), field.newDfp("1e-6"), "greaterThan", false, 25);
745
746
747 cmptst(snan, snan, "greaterThan", false, 27);
748 cmptst(qnan, qnan, "greaterThan", false, 28);
749 cmptst(snan, qnan, "greaterThan", false, 29);
750 cmptst(qnan, snan, "greaterThan", false, 30);
751 cmptst(qnan, field.newDfp("0"), "greaterThan", false, 31);
752 cmptst(snan, field.newDfp("0"), "greaterThan", false, 32);
753 cmptst(field.newDfp("0"), snan, "greaterThan", false, 33);
754 cmptst(field.newDfp("0"), qnan, "greaterThan", false, 34);
755 cmptst(qnan, pinf, "greaterThan", false, 35);
756 cmptst(snan, pinf, "greaterThan", false, 36);
757 cmptst(pinf, snan, "greaterThan", false, 37);
758 cmptst(pinf, qnan, "greaterThan", false, 38);
759 cmptst(qnan, ninf, "greaterThan", false, 39);
760 cmptst(snan, ninf, "greaterThan", false, 40);
761 cmptst(ninf, snan, "greaterThan", false, 41);
762 cmptst(ninf, qnan, "greaterThan", false, 42);
763 cmptst(qnan, field.newDfp("-1"), "greaterThan", false, 43);
764 cmptst(snan, field.newDfp("-1"), "greaterThan", false, 44);
765 cmptst(field.newDfp("-1"), snan, "greaterThan", false, 45);
766 cmptst(field.newDfp("-1"), qnan, "greaterThan", false, 46);
767 cmptst(qnan, field.newDfp("1"), "greaterThan", false, 47);
768 cmptst(snan, field.newDfp("1"), "greaterThan", false, 48);
769 cmptst(field.newDfp("1"), snan, "greaterThan", false, 49);
770 cmptst(field.newDfp("1"), qnan, "greaterThan", false, 50);
771 cmptst(snan.negate(), snan, "greaterThan", false, 51);
772 cmptst(qnan.negate(), qnan, "greaterThan", false, 52);
773
774
775 if (field.getIEEEFlags() != DfpField.FLAG_INVALID) {
776 assertionFail("compare greaterThan flags = " + field.getIEEEFlags());
777 }
778 field.clearIEEEFlags();
779 }
780
781
782
783
784 @Test
785 public void testMultiply() {
786 test(field.newDfp("1").multiply(field.newDfp("1")),
787 field.newDfp("1"),
788 0, "Multiply #1");
789
790 test(field.newDfp("1").multiply(1),
791 field.newDfp("1"),
792 0, "Multiply #2");
793
794 test(field.newDfp("-1").multiply(field.newDfp("1")),
795 field.newDfp("-1"),
796 0, "Multiply #3");
797
798 test(field.newDfp("-1").multiply(1),
799 field.newDfp("-1"),
800 0, "Multiply #4");
801
802
803 test(field.newDfp("2").multiply(field.newDfp("3")),
804 field.newDfp("6"),
805 0, "Multiply #5");
806
807 test(field.newDfp("2").multiply(3),
808 field.newDfp("6"),
809 0, "Multiply #6");
810
811 test(field.newDfp("-2").multiply(field.newDfp("3")),
812 field.newDfp("-6"),
813 0, "Multiply #7");
814
815 test(field.newDfp("-2").multiply(3),
816 field.newDfp("-6"),
817 0, "Multiply #8");
818
819 test(field.newDfp("2").multiply(field.newDfp("-3")),
820 field.newDfp("-6"),
821 0, "Multiply #9");
822
823 test(field.newDfp("-2").multiply(field.newDfp("-3")),
824 field.newDfp("6"),
825 0, "Multiply #10");
826
827
828
829 test(field.newDfp("-2").multiply(field.newDfp("0")),
830 field.newDfp("-0"),
831 0, "Multiply #11");
832
833 test(field.newDfp("-2").multiply(0),
834 field.newDfp("-0"),
835 0, "Multiply #12");
836
837 test(field.newDfp("2").multiply(field.newDfp("0")),
838 field.newDfp("0"),
839 0, "Multiply #13");
840
841 test(field.newDfp("2").multiply(0),
842 field.newDfp("0"),
843 0, "Multiply #14");
844
845 test(field.newDfp("2").multiply(pinf),
846 pinf,
847 0, "Multiply #15");
848
849 test(field.newDfp("2").multiply(ninf),
850 ninf,
851 0, "Multiply #16");
852
853 test(field.newDfp("-2").multiply(pinf),
854 ninf,
855 0, "Multiply #17");
856
857 test(field.newDfp("-2").multiply(ninf),
858 pinf,
859 0, "Multiply #18");
860
861 test(ninf.multiply(field.newDfp("-2")),
862 pinf,
863 0, "Multiply #18.1");
864
865 test(field.newDfp("5e131071").multiply(2),
866 pinf,
867 DfpField.FLAG_OVERFLOW, "Multiply #19");
868
869 test(field.newDfp("5e131071").multiply(field.newDfp("1.999999999999999")),
870 field.newDfp("9.9999999999999950000e131071"),
871 0, "Multiply #20");
872
873 test(field.newDfp("-5e131071").multiply(2),
874 ninf,
875 DfpField.FLAG_OVERFLOW, "Multiply #22");
876
877 test(field.newDfp("-5e131071").multiply(field.newDfp("1.999999999999999")),
878 field.newDfp("-9.9999999999999950000e131071"),
879 0, "Multiply #23");
880
881 test(field.newDfp("1e-65539").multiply(field.newDfp("1e-65539")),
882 field.newDfp("1e-131078"),
883 DfpField.FLAG_UNDERFLOW, "Multiply #24");
884
885 test(field.newDfp("1").multiply(nan),
886 nan,
887 0, "Multiply #25");
888
889 test(nan.multiply(field.newDfp("1")),
890 nan,
891 0, "Multiply #26");
892
893 test(nan.multiply(pinf),
894 nan,
895 0, "Multiply #27");
896
897 test(pinf.multiply(nan),
898 nan,
899 0, "Multiply #27");
900
901 test(pinf.multiply(field.newDfp("0")),
902 nan,
903 DfpField.FLAG_INVALID, "Multiply #28");
904
905 test(field.newDfp("0").multiply(pinf),
906 nan,
907 DfpField.FLAG_INVALID, "Multiply #29");
908
909 test(pinf.multiply(pinf),
910 pinf,
911 0, "Multiply #30");
912
913 test(ninf.multiply(pinf),
914 ninf,
915 0, "Multiply #31");
916
917 test(pinf.multiply(ninf),
918 ninf,
919 0, "Multiply #32");
920
921 test(ninf.multiply(ninf),
922 pinf,
923 0, "Multiply #33");
924
925 test(pinf.multiply(1),
926 pinf,
927 0, "Multiply #34");
928
929 test(pinf.multiply(0),
930 nan,
931 DfpField.FLAG_INVALID, "Multiply #35");
932
933 test(nan.multiply(1),
934 nan,
935 0, "Multiply #36");
936
937 test(field.newDfp("1").multiply(10000),
938 field.newDfp("10000"),
939 0, "Multiply #37");
940
941 test(field.newDfp("2").multiply(1000000),
942 field.newDfp("2000000"),
943 0, "Multiply #38");
944
945 test(field.newDfp("1").multiply(-1),
946 field.newDfp("-1"),
947 0, "Multiply #39");
948 }
949
950 @Test
951 public void testDivide() {
952 test(field.newDfp("1").divide(nan),
953 nan,
954 0, "Divide #1");
955
956 test(nan.divide(field.newDfp("1")),
957 nan,
958 0, "Divide #2");
959
960 test(pinf.divide(field.newDfp("1")),
961 pinf,
962 0, "Divide #3");
963
964 test(pinf.divide(field.newDfp("-1")),
965 ninf,
966 0, "Divide #4");
967
968 test(pinf.divide(pinf),
969 nan,
970 DfpField.FLAG_INVALID, "Divide #5");
971
972 test(ninf.divide(pinf),
973 nan,
974 DfpField.FLAG_INVALID, "Divide #6");
975
976 test(pinf.divide(ninf),
977 nan,
978 DfpField.FLAG_INVALID, "Divide #7");
979
980 test(ninf.divide(ninf),
981 nan,
982 DfpField.FLAG_INVALID, "Divide #8");
983
984 test(field.newDfp("0").divide(field.newDfp("0")),
985 nan,
986 DfpField.FLAG_DIV_ZERO, "Divide #9");
987
988 test(field.newDfp("1").divide(field.newDfp("0")),
989 pinf,
990 DfpField.FLAG_DIV_ZERO, "Divide #10");
991
992 test(field.newDfp("1").divide(field.newDfp("-0")),
993 ninf,
994 DfpField.FLAG_DIV_ZERO, "Divide #11");
995
996 test(field.newDfp("-1").divide(field.newDfp("0")),
997 ninf,
998 DfpField.FLAG_DIV_ZERO, "Divide #12");
999
1000 test(field.newDfp("-1").divide(field.newDfp("-0")),
1001 pinf,
1002 DfpField.FLAG_DIV_ZERO, "Divide #13");
1003
1004 test(field.newDfp("1").divide(field.newDfp("3")),
1005 field.newDfp("0.33333333333333333333"),
1006 DfpField.FLAG_INEXACT, "Divide #14");
1007
1008 test(field.newDfp("1").divide(field.newDfp("6")),
1009 field.newDfp("0.16666666666666666667"),
1010 DfpField.FLAG_INEXACT, "Divide #15");
1011
1012 test(field.newDfp("10").divide(field.newDfp("6")),
1013 field.newDfp("1.6666666666666667"),
1014 DfpField.FLAG_INEXACT, "Divide #16");
1015
1016 test(field.newDfp("100").divide(field.newDfp("6")),
1017 field.newDfp("16.6666666666666667"),
1018 DfpField.FLAG_INEXACT, "Divide #17");
1019
1020 test(field.newDfp("1000").divide(field.newDfp("6")),
1021 field.newDfp("166.6666666666666667"),
1022 DfpField.FLAG_INEXACT, "Divide #18");
1023
1024 test(field.newDfp("10000").divide(field.newDfp("6")),
1025 field.newDfp("1666.6666666666666667"),
1026 DfpField.FLAG_INEXACT, "Divide #19");
1027
1028 test(field.newDfp("1").divide(field.newDfp("1")),
1029 field.newDfp("1"),
1030 0, "Divide #20");
1031
1032 test(field.newDfp("1").divide(field.newDfp("-1")),
1033 field.newDfp("-1"),
1034 0, "Divide #21");
1035
1036 test(field.newDfp("-1").divide(field.newDfp("1")),
1037 field.newDfp("-1"),
1038 0, "Divide #22");
1039
1040 test(field.newDfp("-1").divide(field.newDfp("-1")),
1041 field.newDfp("1"),
1042 0, "Divide #23");
1043
1044 test(field.newDfp("1e-65539").divide(field.newDfp("1e65539")),
1045 field.newDfp("1e-131078"),
1046 DfpField.FLAG_UNDERFLOW, "Divide #24");
1047
1048 test(field.newDfp("1e65539").divide(field.newDfp("1e-65539")),
1049 pinf,
1050 DfpField.FLAG_OVERFLOW, "Divide #24");
1051
1052 test(field.newDfp("2").divide(field.newDfp("1.5")),
1053 field.newDfp("1.3333333333333333"),
1054 DfpField.FLAG_INEXACT, "Divide #25");
1055
1056 test(field.newDfp("2").divide(pinf),
1057 field.newDfp("0"),
1058 0, "Divide #26");
1059
1060 test(field.newDfp("2").divide(ninf),
1061 field.newDfp("-0"),
1062 0, "Divide #27");
1063
1064 test(field.newDfp("0").divide(field.newDfp("1")),
1065 field.newDfp("0"),
1066 0, "Divide #28");
1067 }
1068
1069 @Test
1070 public void testReciprocal() {
1071 test(nan.reciprocal(),
1072 nan,
1073 0, "Reciprocal #1");
1074
1075 test(field.newDfp("0").reciprocal(),
1076 pinf,
1077 DfpField.FLAG_DIV_ZERO, "Reciprocal #2");
1078
1079 test(field.newDfp("-0").reciprocal(),
1080 ninf,
1081 DfpField.FLAG_DIV_ZERO, "Reciprocal #3");
1082
1083 test(field.newDfp("3").reciprocal(),
1084 field.newDfp("0.33333333333333333333"),
1085 DfpField.FLAG_INEXACT, "Reciprocal #4");
1086
1087 test(field.newDfp("6").reciprocal(),
1088 field.newDfp("0.16666666666666666667"),
1089 DfpField.FLAG_INEXACT, "Reciprocal #5");
1090
1091 test(field.newDfp("1").reciprocal(),
1092 field.newDfp("1"),
1093 0, "Reciprocal #6");
1094
1095 test(field.newDfp("-1").reciprocal(),
1096 field.newDfp("-1"),
1097 0, "Reciprocal #7");
1098
1099 test(pinf.reciprocal(),
1100 field.newDfp("0"),
1101 0, "Reciprocal #8");
1102
1103 test(ninf.reciprocal(),
1104 field.newDfp("-0"),
1105 0, "Reciprocal #9");
1106 }
1107
1108 @Test
1109 public void testDivideInt() {
1110 test(nan.divide(1),
1111 nan,
1112 0, "DivideInt #1");
1113
1114 test(pinf.divide(1),
1115 pinf,
1116 0, "DivideInt #2");
1117
1118 test(field.newDfp("0").divide(0),
1119 nan,
1120 DfpField.FLAG_DIV_ZERO, "DivideInt #3");
1121
1122 test(field.newDfp("1").divide(0),
1123 pinf,
1124 DfpField.FLAG_DIV_ZERO, "DivideInt #4");
1125
1126 test(field.newDfp("-1").divide(0),
1127 ninf,
1128 DfpField.FLAG_DIV_ZERO, "DivideInt #5");
1129
1130 test(field.newDfp("1").divide(3),
1131 field.newDfp("0.33333333333333333333"),
1132 DfpField.FLAG_INEXACT, "DivideInt #6");
1133
1134 test(field.newDfp("1").divide(6),
1135 field.newDfp("0.16666666666666666667"),
1136 DfpField.FLAG_INEXACT, "DivideInt #7");
1137
1138 test(field.newDfp("10").divide(6),
1139 field.newDfp("1.6666666666666667"),
1140 DfpField.FLAG_INEXACT, "DivideInt #8");
1141
1142 test(field.newDfp("100").divide(6),
1143 field.newDfp("16.6666666666666667"),
1144 DfpField.FLAG_INEXACT, "DivideInt #9");
1145
1146 test(field.newDfp("1000").divide(6),
1147 field.newDfp("166.6666666666666667"),
1148 DfpField.FLAG_INEXACT, "DivideInt #10");
1149
1150 test(field.newDfp("10000").divide(6),
1151 field.newDfp("1666.6666666666666667"),
1152 DfpField.FLAG_INEXACT, "DivideInt #20");
1153
1154 test(field.newDfp("1").divide(1),
1155 field.newDfp("1"),
1156 0, "DivideInt #21");
1157
1158 test(field.newDfp("1e-131077").divide(10),
1159 field.newDfp("1e-131078"),
1160 DfpField.FLAG_UNDERFLOW, "DivideInt #22");
1161
1162 test(field.newDfp("0").divide(1),
1163 field.newDfp("0"),
1164 0, "DivideInt #23");
1165
1166 test(field.newDfp("1").divide(10000),
1167 nan,
1168 DfpField.FLAG_INVALID, "DivideInt #24");
1169
1170 test(field.newDfp("1").divide(-1),
1171 nan,
1172 DfpField.FLAG_INVALID, "DivideInt #25");
1173 }
1174
1175 @Test
1176 public void testNextAfter() {
1177 test(field.newDfp("1").nextAfter(pinf),
1178 field.newDfp("1.0000000000000001"),
1179 0, "NextAfter #1");
1180
1181 test(field.newDfp("1.0000000000000001").nextAfter(ninf),
1182 field.newDfp("1"),
1183 0, "NextAfter #1.5");
1184
1185 test(field.newDfp("1").nextAfter(ninf),
1186 field.newDfp("0.99999999999999999999"),
1187 0, "NextAfter #2");
1188
1189 test(field.newDfp("0.99999999999999999999").nextAfter(field.newDfp("2")),
1190 field.newDfp("1"),
1191 0, "NextAfter #3");
1192
1193 test(field.newDfp("-1").nextAfter(ninf),
1194 field.newDfp("-1.0000000000000001"),
1195 0, "NextAfter #4");
1196
1197 test(field.newDfp("-1").nextAfter(pinf),
1198 field.newDfp("-0.99999999999999999999"),
1199 0, "NextAfter #5");
1200
1201 test(field.newDfp("-0.99999999999999999999").nextAfter(field.newDfp("-2")),
1202 field.newDfp("-1"),
1203 0, "NextAfter #6");
1204
1205 test(field.newDfp("2").nextAfter(field.newDfp("2")),
1206 field.newDfp("2"),
1207 0, "NextAfter #7");
1208
1209 test(field.newDfp("0").nextAfter(field.newDfp("0")),
1210 field.newDfp("0"),
1211 0, "NextAfter #8");
1212
1213 test(field.newDfp("-2").nextAfter(field.newDfp("-2")),
1214 field.newDfp("-2"),
1215 0, "NextAfter #9");
1216
1217 test(field.newDfp("0").nextAfter(field.newDfp("1")),
1218 field.newDfp("1e-131092"),
1219 DfpField.FLAG_UNDERFLOW, "NextAfter #10");
1220
1221 test(field.newDfp("0").nextAfter(field.newDfp("-1")),
1222 field.newDfp("-1e-131092"),
1223 DfpField.FLAG_UNDERFLOW, "NextAfter #11");
1224
1225 test(field.newDfp("-1e-131092").nextAfter(pinf),
1226 field.newDfp("-0"),
1227 DfpField.FLAG_UNDERFLOW | DfpField.FLAG_INEXACT, "Next After #12");
1228
1229 test(field.newDfp("1e-131092").nextAfter(ninf),
1230 field.newDfp("0"),
1231 DfpField.FLAG_UNDERFLOW | DfpField.FLAG_INEXACT, "Next After #13");
1232
1233 test(field.newDfp("9.9999999999999999999e131078").nextAfter(pinf),
1234 pinf,
1235 DfpField.FLAG_OVERFLOW | DfpField.FLAG_INEXACT, "Next After #14");
1236 }
1237
1238 @Test
1239 public void testToString() {
1240 Assert.assertEquals("toString #1", "Infinity", pinf.toString());
1241 Assert.assertEquals("toString #2", "-Infinity", ninf.toString());
1242 Assert.assertEquals("toString #3", "NaN", nan.toString());
1243 Assert.assertEquals("toString #4", "NaN", field.newDfp((byte) 1, Dfp.QNAN).toString());
1244 Assert.assertEquals("toString #5", "NaN", field.newDfp((byte) 1, Dfp.SNAN).toString());
1245 Assert.assertEquals("toString #6", "1.2300000000000000e100", field.newDfp("1.23e100").toString());
1246 Assert.assertEquals("toString #7", "-1.2300000000000000e100", field.newDfp("-1.23e100").toString());
1247 Assert.assertEquals("toString #8", "12345678.1234", field.newDfp("12345678.1234").toString());
1248 Assert.assertEquals("toString #9", "0.00001234", field.newDfp("0.00001234").toString());
1249 }
1250
1251 @Override
1252 @Test
1253 public void testRound() {
1254 field.setRoundingMode(DfpField.RoundingMode.ROUND_DOWN);
1255
1256
1257 test(field.newDfp("12345678901234567890").add(field.newDfp("0.9")),
1258 field.newDfp("12345678901234567890"),
1259 DfpField.FLAG_INEXACT, "Round #1");
1260
1261 test(field.newDfp("12345678901234567890").add(field.newDfp("0.99999999")),
1262 field.newDfp("12345678901234567890"),
1263 DfpField.FLAG_INEXACT, "Round #2");
1264
1265 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.99999999")),
1266 field.newDfp("-12345678901234567890"),
1267 DfpField.FLAG_INEXACT, "Round #3");
1268
1269 field.setRoundingMode(DfpField.RoundingMode.ROUND_UP);
1270
1271
1272 test(field.newDfp("12345678901234567890").add(field.newDfp("0.1")),
1273 field.newDfp("12345678901234567891"),
1274 DfpField.FLAG_INEXACT, "Round #4");
1275
1276 test(field.newDfp("12345678901234567890").add(field.newDfp("0.0001")),
1277 field.newDfp("12345678901234567891"),
1278 DfpField.FLAG_INEXACT, "Round #5");
1279
1280 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.1")),
1281 field.newDfp("-12345678901234567891"),
1282 DfpField.FLAG_INEXACT, "Round #6");
1283
1284 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.0001")),
1285 field.newDfp("-12345678901234567891"),
1286 DfpField.FLAG_INEXACT, "Round #7");
1287
1288 field.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_UP);
1289
1290
1291 test(field.newDfp("12345678901234567890").add(field.newDfp("0.4999")),
1292 field.newDfp("12345678901234567890"),
1293 DfpField.FLAG_INEXACT, "Round #8");
1294
1295 test(field.newDfp("12345678901234567890").add(field.newDfp("0.5000")),
1296 field.newDfp("12345678901234567891"),
1297 DfpField.FLAG_INEXACT, "Round #9");
1298
1299 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.4999")),
1300 field.newDfp("-12345678901234567890"),
1301 DfpField.FLAG_INEXACT, "Round #10");
1302
1303 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.5000")),
1304 field.newDfp("-12345678901234567891"),
1305 DfpField.FLAG_INEXACT, "Round #11");
1306
1307 field.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_DOWN);
1308
1309
1310 test(field.newDfp("12345678901234567890").add(field.newDfp("0.5001")),
1311 field.newDfp("12345678901234567891"),
1312 DfpField.FLAG_INEXACT, "Round #12");
1313
1314 test(field.newDfp("12345678901234567890").add(field.newDfp("0.5000")),
1315 field.newDfp("12345678901234567890"),
1316 DfpField.FLAG_INEXACT, "Round #13");
1317
1318 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.5001")),
1319 field.newDfp("-12345678901234567891"),
1320 DfpField.FLAG_INEXACT, "Round #14");
1321
1322 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.5000")),
1323 field.newDfp("-12345678901234567890"),
1324 DfpField.FLAG_INEXACT, "Round #15");
1325
1326 field.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_ODD);
1327
1328
1329 test(field.newDfp("12345678901234567890").add(field.newDfp("0.5000")),
1330 field.newDfp("12345678901234567891"),
1331 DfpField.FLAG_INEXACT, "Round #16");
1332
1333 test(field.newDfp("12345678901234567891").add(field.newDfp("0.5000")),
1334 field.newDfp("12345678901234567891"),
1335 DfpField.FLAG_INEXACT, "Round #17");
1336
1337 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.5000")),
1338 field.newDfp("-12345678901234567891"),
1339 DfpField.FLAG_INEXACT, "Round #18");
1340
1341 test(field.newDfp("-12345678901234567891").add(field.newDfp("-0.5000")),
1342 field.newDfp("-12345678901234567891"),
1343 DfpField.FLAG_INEXACT, "Round #19");
1344
1345 field.setRoundingMode(DfpField.RoundingMode.ROUND_CEIL);
1346
1347
1348 test(field.newDfp("12345678901234567890").add(field.newDfp("0.0001")),
1349 field.newDfp("12345678901234567891"),
1350 DfpField.FLAG_INEXACT, "Round #20");
1351
1352 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.9999")),
1353 field.newDfp("-12345678901234567890"),
1354 DfpField.FLAG_INEXACT, "Round #21");
1355
1356 field.setRoundingMode(DfpField.RoundingMode.ROUND_FLOOR);
1357
1358
1359 test(field.newDfp("12345678901234567890").add(field.newDfp("0.9999")),
1360 field.newDfp("12345678901234567890"),
1361 DfpField.FLAG_INEXACT, "Round #22");
1362
1363 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.0001")),
1364 field.newDfp("-12345678901234567891"),
1365 DfpField.FLAG_INEXACT, "Round #23");
1366
1367 field.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_EVEN);
1368 }
1369
1370 @Override
1371 @Test
1372 public void testCeil() {
1373 test(field.newDfp("1234.0000000000000001").ceil(),
1374 field.newDfp("1235"),
1375 DfpField.FLAG_INEXACT, "Ceil #1");
1376 }
1377
1378 @Override
1379 @Test
1380 public void testFloor() {
1381 test(field.newDfp("1234.9999999999999999").floor(),
1382 field.newDfp("1234"),
1383 DfpField.FLAG_INEXACT, "Floor #1");
1384 }
1385
1386 @Override
1387 @Test
1388 public void testRint() {
1389 test(field.newDfp("1234.50000000001").rint(),
1390 field.newDfp("1235"),
1391 DfpField.FLAG_INEXACT, "Rint #1");
1392
1393 test(field.newDfp("1234.5000").rint(),
1394 field.newDfp("1234"),
1395 DfpField.FLAG_INEXACT, "Rint #2");
1396
1397 test(field.newDfp("1235.5000").rint(),
1398 field.newDfp("1236"),
1399 DfpField.FLAG_INEXACT, "Rint #3");
1400 }
1401
1402 @Test
1403 public void testCopySign() {
1404 test(Dfp.copySign(field.newDfp("1234."), field.newDfp("-1")),
1405 field.newDfp("-1234"),
1406 0, "CopySign #1");
1407
1408 test(Dfp.copySign(field.newDfp("-1234."), field.newDfp("-1")),
1409 field.newDfp("-1234"),
1410 0, "CopySign #2");
1411
1412 test(Dfp.copySign(field.newDfp("-1234."), field.newDfp("1")),
1413 field.newDfp("1234"),
1414 0, "CopySign #3");
1415
1416 test(Dfp.copySign(field.newDfp("1234."), field.newDfp("1")),
1417 field.newDfp("1234"),
1418 0, "CopySign #4");
1419 }
1420
1421 @Test
1422 public void testIntValue() {
1423 Assert.assertEquals("intValue #1", 1234, field.newDfp("1234").intValue());
1424 Assert.assertEquals("intValue #2", -1234, field.newDfp("-1234").intValue());
1425 Assert.assertEquals("intValue #3", 1234, field.newDfp("1234.5").intValue());
1426 Assert.assertEquals("intValue #4", 1235, field.newDfp("1234.500001").intValue());
1427 Assert.assertEquals("intValue #5", 2147483647, field.newDfp("1e1000").intValue());
1428 Assert.assertEquals("intValue #6", -2147483648, field.newDfp("-1e1000").intValue());
1429 }
1430
1431 @Test
1432 public void testLog10K() {
1433 Assert.assertEquals("log10K #1", 1, field.newDfp("123456").log10K());
1434 Assert.assertEquals("log10K #2", 2, field.newDfp("123456789").log10K());
1435 Assert.assertEquals("log10K #3", 0, field.newDfp("2").log10K());
1436 Assert.assertEquals("log10K #3", 0, field.newDfp("1").log10K());
1437 Assert.assertEquals("log10K #4", -1, field.newDfp("0.1").log10K());
1438 }
1439
1440 @Test
1441 public void testPower10K() {
1442 Dfp d = field.newDfp();
1443
1444 test(d.power10K(0), field.newDfp("1"), 0, "Power10 #1");
1445 test(d.power10K(1), field.newDfp("10000"), 0, "Power10 #2");
1446 test(d.power10K(2), field.newDfp("100000000"), 0, "Power10 #3");
1447
1448 test(d.power10K(-1), field.newDfp("0.0001"), 0, "Power10 #4");
1449 test(d.power10K(-2), field.newDfp("0.00000001"), 0, "Power10 #5");
1450 test(d.power10K(-3), field.newDfp("0.000000000001"), 0, "Power10 #6");
1451 }
1452
1453 @Test
1454 public void testLog10() {
1455 Assert.assertEquals("log10 #1", 1, field.newDfp("12").intLog10());
1456 Assert.assertEquals("log10 #2", 2, field.newDfp("123").intLog10());
1457 Assert.assertEquals("log10 #3", 3, field.newDfp("1234").intLog10());
1458 Assert.assertEquals("log10 #4", 4, field.newDfp("12345").intLog10());
1459 Assert.assertEquals("log10 #5", 5, field.newDfp("123456").intLog10());
1460 Assert.assertEquals("log10 #6", 6, field.newDfp("1234567").intLog10());
1461 Assert.assertEquals("log10 #6", 7, field.newDfp("12345678").intLog10());
1462 Assert.assertEquals("log10 #7", 8, field.newDfp("123456789").intLog10());
1463 Assert.assertEquals("log10 #8", 9, field.newDfp("1234567890").intLog10());
1464 Assert.assertEquals("log10 #9", 10, field.newDfp("12345678901").intLog10());
1465 Assert.assertEquals("log10 #10", 11, field.newDfp("123456789012").intLog10());
1466 Assert.assertEquals("log10 #11", 12, field.newDfp("1234567890123").intLog10());
1467
1468 Assert.assertEquals("log10 #12", 0, field.newDfp("2").intLog10());
1469 Assert.assertEquals("log10 #13", 0, field.newDfp("1").intLog10());
1470 Assert.assertEquals("log10 #14", -1, field.newDfp("0.12").intLog10());
1471 Assert.assertEquals("log10 #15", -2, field.newDfp("0.012").intLog10());
1472 }
1473
1474 @Test
1475 public void testPower10() {
1476 Dfp d = field.newDfp();
1477
1478 test(d.power10(0), field.newDfp("1"), 0, "Power10 #1");
1479 test(d.power10(1), field.newDfp("10"), 0, "Power10 #2");
1480 test(d.power10(2), field.newDfp("100"), 0, "Power10 #3");
1481 test(d.power10(3), field.newDfp("1000"), 0, "Power10 #4");
1482 test(d.power10(4), field.newDfp("10000"), 0, "Power10 #5");
1483 test(d.power10(5), field.newDfp("100000"), 0, "Power10 #6");
1484 test(d.power10(6), field.newDfp("1000000"), 0, "Power10 #7");
1485 test(d.power10(7), field.newDfp("10000000"), 0, "Power10 #8");
1486 test(d.power10(8), field.newDfp("100000000"), 0, "Power10 #9");
1487 test(d.power10(9), field.newDfp("1000000000"), 0, "Power10 #10");
1488
1489 test(d.power10(-1), field.newDfp(".1"), 0, "Power10 #11");
1490 test(d.power10(-2), field.newDfp(".01"), 0, "Power10 #12");
1491 test(d.power10(-3), field.newDfp(".001"), 0, "Power10 #13");
1492 test(d.power10(-4), field.newDfp(".0001"), 0, "Power10 #14");
1493 test(d.power10(-5), field.newDfp(".00001"), 0, "Power10 #15");
1494 test(d.power10(-6), field.newDfp(".000001"), 0, "Power10 #16");
1495 test(d.power10(-7), field.newDfp(".0000001"), 0, "Power10 #17");
1496 test(d.power10(-8), field.newDfp(".00000001"), 0, "Power10 #18");
1497 test(d.power10(-9), field.newDfp(".000000001"), 0, "Power10 #19");
1498 test(d.power10(-10), field.newDfp(".0000000001"), 0, "Power10 #20");
1499 }
1500
1501 @Test
1502 public void testRemainder() {
1503 test(field.newDfp("10").remainder(field.newDfp("3")),
1504 field.newDfp("1"),
1505 DfpField.FLAG_INEXACT, "Remainder #1");
1506
1507 test(field.newDfp("9").remainder(field.newDfp("3")),
1508 field.newDfp("0"),
1509 0, "Remainder #2");
1510
1511 test(field.newDfp("-9").remainder(field.newDfp("3")),
1512 field.newDfp("-0"),
1513 0, "Remainder #3");
1514 }
1515
1516 @Override
1517 @Test
1518 public void testSqrt() {
1519 test(field.newDfp("0").sqrt(),
1520 field.newDfp("0"),
1521 0, "Sqrt #1");
1522
1523 test(field.newDfp("-0").sqrt(),
1524 field.newDfp("-0"),
1525 0, "Sqrt #2");
1526
1527 test(field.newDfp("1").sqrt(),
1528 field.newDfp("1"),
1529 0, "Sqrt #3");
1530
1531 test(field.newDfp("2").sqrt(),
1532 field.newDfp("1.4142135623730950"),
1533 DfpField.FLAG_INEXACT, "Sqrt #4");
1534
1535 test(field.newDfp("3").sqrt(),
1536 field.newDfp("1.7320508075688773"),
1537 DfpField.FLAG_INEXACT, "Sqrt #5");
1538
1539 test(field.newDfp("5").sqrt(),
1540 field.newDfp("2.2360679774997897"),
1541 DfpField.FLAG_INEXACT, "Sqrt #6");
1542
1543 test(field.newDfp("500").sqrt(),
1544 field.newDfp("22.3606797749978970"),
1545 DfpField.FLAG_INEXACT, "Sqrt #6.2");
1546
1547 test(field.newDfp("50000").sqrt(),
1548 field.newDfp("223.6067977499789696"),
1549 DfpField.FLAG_INEXACT, "Sqrt #6.3");
1550
1551 test(field.newDfp("-1").sqrt(),
1552 nan,
1553 DfpField.FLAG_INVALID, "Sqrt #7");
1554
1555 test(pinf.sqrt(),
1556 pinf,
1557 0, "Sqrt #8");
1558
1559 test(field.newDfp((byte) 1, Dfp.QNAN).sqrt(),
1560 nan,
1561 0, "Sqrt #9");
1562
1563 test(field.newDfp((byte) 1, Dfp.SNAN).sqrt(),
1564 nan,
1565 DfpField.FLAG_INVALID, "Sqrt #9");
1566 }
1567
1568 @Test
1569 public void testIssue567() {
1570 DfpField localField = new DfpField(100);
1571 Assert.assertEquals(0.0, localField.getZero().toDouble(), Precision.SAFE_MIN);
1572 Assert.assertEquals(0.0, localField.newDfp(0.0).toDouble(), Precision.SAFE_MIN);
1573 Assert.assertEquals(-1, JdkMath.copySign(1, localField.newDfp(-0.0).toDouble()), Precision.EPSILON);
1574 Assert.assertEquals(+1, JdkMath.copySign(1, localField.newDfp(+0.0).toDouble()), Precision.EPSILON);
1575 }
1576
1577 @Test
1578 public void testIsZero() {
1579 Assert.assertTrue(field.getZero().isZero());
1580 Assert.assertTrue(field.getZero().negate().isZero());
1581 Assert.assertTrue(field.newDfp(+0.0).isZero());
1582 Assert.assertTrue(field.newDfp(-0.0).isZero());
1583 Assert.assertFalse(field.newDfp(1.0e-90).isZero());
1584 Assert.assertFalse(nan.isZero());
1585 Assert.assertFalse(nan.negate().isZero());
1586 Assert.assertFalse(pinf.isZero());
1587 Assert.assertFalse(pinf.negate().isZero());
1588 Assert.assertFalse(ninf.isZero());
1589 Assert.assertFalse(ninf.negate().isZero());
1590 }
1591
1592 @Test
1593 public void testSignPredicates() {
1594
1595 Assert.assertTrue(field.getZero().negativeOrNull());
1596 Assert.assertTrue(field.getZero().positiveOrNull());
1597 Assert.assertFalse(field.getZero().strictlyNegative());
1598 Assert.assertFalse(field.getZero().strictlyPositive());
1599
1600 Assert.assertTrue(field.getZero().negate().negativeOrNull());
1601 Assert.assertTrue(field.getZero().negate().positiveOrNull());
1602 Assert.assertFalse(field.getZero().negate().strictlyNegative());
1603 Assert.assertFalse(field.getZero().negate().strictlyPositive());
1604
1605 Assert.assertFalse(field.getOne().negativeOrNull());
1606 Assert.assertTrue(field.getOne().positiveOrNull());
1607 Assert.assertFalse(field.getOne().strictlyNegative());
1608 Assert.assertTrue(field.getOne().strictlyPositive());
1609
1610 Assert.assertTrue(field.getOne().negate().negativeOrNull());
1611 Assert.assertFalse(field.getOne().negate().positiveOrNull());
1612 Assert.assertTrue(field.getOne().negate().strictlyNegative());
1613 Assert.assertFalse(field.getOne().negate().strictlyPositive());
1614
1615 Assert.assertFalse(nan.negativeOrNull());
1616 Assert.assertFalse(nan.positiveOrNull());
1617 Assert.assertFalse(nan.strictlyNegative());
1618 Assert.assertFalse(nan.strictlyPositive());
1619
1620 Assert.assertFalse(nan.negate().negativeOrNull());
1621 Assert.assertFalse(nan.negate().positiveOrNull());
1622 Assert.assertFalse(nan.negate().strictlyNegative());
1623 Assert.assertFalse(nan.negate().strictlyPositive());
1624
1625 Assert.assertFalse(pinf.negativeOrNull());
1626 Assert.assertTrue(pinf.positiveOrNull());
1627 Assert.assertFalse(pinf.strictlyNegative());
1628 Assert.assertTrue(pinf.strictlyPositive());
1629
1630 Assert.assertTrue(pinf.negate().negativeOrNull());
1631 Assert.assertFalse(pinf.negate().positiveOrNull());
1632 Assert.assertTrue(pinf.negate().strictlyNegative());
1633 Assert.assertFalse(pinf.negate().strictlyPositive());
1634
1635 Assert.assertTrue(ninf.negativeOrNull());
1636 Assert.assertFalse(ninf.positiveOrNull());
1637 Assert.assertTrue(ninf.strictlyNegative());
1638 Assert.assertFalse(ninf.strictlyPositive());
1639
1640 Assert.assertFalse(ninf.negate().negativeOrNull());
1641 Assert.assertTrue(ninf.negate().positiveOrNull());
1642 Assert.assertFalse(ninf.negate().strictlyNegative());
1643 Assert.assertTrue(ninf.negate().strictlyPositive());
1644 }
1645
1646 @Test
1647 public void testSpecialConstructors() {
1648 Assert.assertEquals(ninf, field.newDfp(Double.NEGATIVE_INFINITY));
1649 Assert.assertEquals(ninf, field.newDfp("-Infinity"));
1650 Assert.assertEquals(pinf, field.newDfp(Double.POSITIVE_INFINITY));
1651 Assert.assertEquals(pinf, field.newDfp("Infinity"));
1652 Assert.assertTrue(field.newDfp(Double.NaN).isNaN());
1653 Assert.assertTrue(field.newDfp("NaN").isNaN());
1654 }
1655
1656 @Test
1657 public void testEqualsHashcodeContract() {
1658 DfpField var1 = new DfpField(1);
1659 Dfp var6 = var1.newDfp(-0.0d);
1660 Dfp var5 = var1.newDfp(0L);
1661
1662
1663 Assert.assertTrue(var5.equals(var6) ? var5.hashCode() == var6.hashCode() : true);
1664 }
1665
1666 private static void assertionFail(String content) {
1667 Assert.fail("assertion failed: " + content);
1668 }
1669
1670 private static void assertionFailOpNum(String op, double num) {
1671 assertionFail(op + " compare #" + num);
1672 }
1673
1674 private static void assertionFailDfpField(DfpField field) {
1675 assertionFail("compare flags = " + field.getIEEEFlags());
1676 }
1677 }