1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 package org.hipparchus.dfp;
24
25 import org.hipparchus.CalculusFieldElementAbstractTest;
26 import org.hipparchus.util.Binary64Field;
27 import org.hipparchus.util.FastMath;
28 import org.hipparchus.util.Precision;
29 import org.junit.jupiter.api.AfterEach;
30 import org.junit.jupiter.api.BeforeEach;
31 import org.junit.jupiter.api.Test;
32
33 import java.util.HashMap;
34 import java.util.Map;
35
36 import static org.junit.jupiter.api.Assertions.assertEquals;
37 import static org.junit.jupiter.api.Assertions.assertFalse;
38 import static org.junit.jupiter.api.Assertions.assertNotEquals;
39 import static org.junit.jupiter.api.Assertions.assertSame;
40 import static org.junit.jupiter.api.Assertions.assertTrue;
41 import static org.junit.jupiter.api.Assertions.fail;
42
43 class DfpTest extends CalculusFieldElementAbstractTest<Dfp> {
44
45 @Override
46 protected Dfp build(final double x) {
47 return field.newDfp(x);
48 }
49
50 private DfpField field;
51 private Dfp pinf;
52 private Dfp ninf;
53 private Dfp nan;
54 private Dfp snan;
55 private Dfp qnan;
56
57 @BeforeEach
58 void setUp() {
59
60 field = new DfpField(20);
61 pinf = field.newDfp("1").divide(field.newDfp("0"));
62 ninf = field.newDfp("-1").divide(field.newDfp("0"));
63 nan = field.newDfp("0").divide(field.newDfp("0"));
64 snan = field.newDfp((byte)1, Dfp.SNAN);
65 qnan = field.newDfp((byte)1, Dfp.QNAN);
66 ninf.getField().clearIEEEFlags();
67 }
68
69 @AfterEach
70 void tearDown() {
71 field = null;
72 pinf = null;
73 ninf = null;
74 nan = null;
75 snan = null;
76 qnan = null;
77 }
78
79
80
81
82 private void test(Dfp x, Dfp y, int flags, String desc)
83 {
84 boolean b = x.equals(y);
85
86 if (!x.equals(y) && !x.unequal(y))
87 b = (x.toString().equals(y.toString()));
88
89 if (x.equals(field.newDfp("0")))
90 b = (b && (x.toString().equals(y.toString())));
91
92 b = (b && x.getField().getIEEEFlags() == flags);
93
94 if (!b)
95 assertTrue(b, "assersion failed "+desc+" x = "+x.toString()+" flags = "+x.getField().getIEEEFlags());
96
97 x.getField().clearIEEEFlags();
98 }
99
100 @Test
101 void testByteConstructor() {
102 assertEquals("0.", new Dfp(field, (byte) 0).toString());
103 assertEquals("1.", new Dfp(field, (byte) 1).toString());
104 assertEquals("-1.", new Dfp(field, (byte) -1).toString());
105 assertEquals("-128.", new Dfp(field, Byte.MIN_VALUE).toString());
106 assertEquals("127.", new Dfp(field, Byte.MAX_VALUE).toString());
107 }
108
109 @Test
110 void testIntConstructor() {
111 assertEquals("0.", new Dfp(field, 0).toString());
112 assertEquals("1.", new Dfp(field, 1).toString());
113 assertEquals("-1.", new Dfp(field, -1).toString());
114 assertEquals("1234567890.", new Dfp(field, 1234567890).toString());
115 assertEquals("-1234567890.", new Dfp(field, -1234567890).toString());
116 assertEquals("-2147483648.", new Dfp(field, Integer.MIN_VALUE).toString());
117 assertEquals("2147483647.", new Dfp(field, Integer.MAX_VALUE).toString());
118 }
119
120 @Test
121 void testLongConstructor() {
122 assertEquals("0.", new Dfp(field, 0l).toString());
123 assertEquals("1.", new Dfp(field, 1l).toString());
124 assertEquals("-1.", new Dfp(field, -1l).toString());
125 assertEquals("1234567890.", new Dfp(field, 1234567890l).toString());
126 assertEquals("-1234567890.", new Dfp(field, -1234567890l).toString());
127 assertEquals("-9223372036854775808.", new Dfp(field, Long.MIN_VALUE).toString());
128 assertEquals("9223372036854775807.", new Dfp(field, Long.MAX_VALUE).toString());
129 }
130
131
132
133
134 @Test
135 void testAdd()
136 {
137 test(field.newDfp("1").add(field.newDfp("1")),
138 field.newDfp("2"),
139 0, "Add #1");
140
141 test(field.newDfp("1").add(field.newDfp("-1")),
142 field.newDfp("0"),
143 0, "Add #2");
144
145 test(field.newDfp("-1").add(field.newDfp("1")),
146 field.newDfp("0"),
147 0, "Add #3");
148
149 test(field.newDfp("-1").add(field.newDfp("-1")),
150 field.newDfp("-2"),
151 0, "Add #4");
152
153
154
155 test(field.newDfp("1").add(field.newDfp("1e-16")),
156 field.newDfp("1.0000000000000001"),
157 0, "Add #5");
158
159 test(field.newDfp("1").add(field.newDfp("1e-17")),
160 field.newDfp("1"),
161 DfpField.FLAG_INEXACT, "Add #6");
162
163 test(field.newDfp("0.90999999999999999999").add(field.newDfp("0.1")),
164 field.newDfp("1.01"),
165 DfpField.FLAG_INEXACT, "Add #7");
166
167 test(field.newDfp(".10000000000000005000").add(field.newDfp(".9")),
168 field.newDfp("1."),
169 DfpField.FLAG_INEXACT, "Add #8");
170
171 test(field.newDfp(".10000000000000015000").add(field.newDfp(".9")),
172 field.newDfp("1.0000000000000002"),
173 DfpField.FLAG_INEXACT, "Add #9");
174
175 test(field.newDfp(".10000000000000014999").add(field.newDfp(".9")),
176 field.newDfp("1.0000000000000001"),
177 DfpField.FLAG_INEXACT, "Add #10");
178
179 test(field.newDfp(".10000000000000015001").add(field.newDfp(".9")),
180 field.newDfp("1.0000000000000002"),
181 DfpField.FLAG_INEXACT, "Add #11");
182
183 test(field.newDfp(".11111111111111111111").add(field.newDfp("11.1111111111111111")),
184 field.newDfp("11.22222222222222222222"),
185 DfpField.FLAG_INEXACT, "Add #12");
186
187 test(field.newDfp(".11111111111111111111").add(field.newDfp("1111111111111111.1111")),
188 field.newDfp("1111111111111111.2222"),
189 DfpField.FLAG_INEXACT, "Add #13");
190
191 test(field.newDfp(".11111111111111111111").add(field.newDfp("11111111111111111111")),
192 field.newDfp("11111111111111111111"),
193 DfpField.FLAG_INEXACT, "Add #14");
194
195 test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("-1e131052")),
196 field.newDfp("9.9999999999999999998e131071"),
197 0, "Add #15");
198
199 test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("1e131052")),
200 pinf,
201 DfpField.FLAG_OVERFLOW, "Add #16");
202
203 test(field.newDfp("-9.9999999999999999999e131071").add(field.newDfp("-1e131052")),
204 ninf,
205 DfpField.FLAG_OVERFLOW, "Add #17");
206
207 test(field.newDfp("-9.9999999999999999999e131071").add(field.newDfp("1e131052")),
208 field.newDfp("-9.9999999999999999998e131071"),
209 0, "Add #18");
210
211 test(field.newDfp("1e-131072").add(field.newDfp("1e-131072")),
212 field.newDfp("2e-131072"),
213 0, "Add #19");
214
215 test(field.newDfp("1.0000000000000001e-131057").add(field.newDfp("-1e-131057")),
216 field.newDfp("1e-131073"),
217 DfpField.FLAG_UNDERFLOW, "Add #20");
218
219 test(field.newDfp("1.1e-131072").add(field.newDfp("-1e-131072")),
220 field.newDfp("1e-131073"),
221 DfpField.FLAG_UNDERFLOW, "Add #21");
222
223 test(field.newDfp("1.0000000000000001e-131072").add(field.newDfp("-1e-131072")),
224 field.newDfp("1e-131088"),
225 DfpField.FLAG_UNDERFLOW, "Add #22");
226
227 test(field.newDfp("1.0000000000000001e-131078").add(field.newDfp("-1e-131078")),
228 field.newDfp("0"),
229 DfpField.FLAG_UNDERFLOW, "Add #23");
230
231 test(field.newDfp("1.0").add(field.newDfp("-1e-20")),
232 field.newDfp("0.99999999999999999999"),
233 0, "Add #23.1");
234
235 test(field.newDfp("-0.99999999999999999999").add(field.newDfp("1")),
236 field.newDfp("0.00000000000000000001"),
237 0, "Add #23.2");
238
239 test(field.newDfp("1").add(field.newDfp("0")),
240 field.newDfp("1"),
241 0, "Add #24");
242
243 test(field.newDfp("0").add(field.newDfp("0")),
244 field.newDfp("0"),
245 0, "Add #25");
246
247 test(field.newDfp("-0").add(field.newDfp("0")),
248 field.newDfp("0"),
249 0, "Add #26");
250
251 test(field.newDfp("0").add(field.newDfp("-0")),
252 field.newDfp("0"),
253 0, "Add #27");
254
255 test(field.newDfp("-0").add(field.newDfp("-0")),
256 field.newDfp("-0"),
257 0, "Add #28");
258
259 test(field.newDfp("1e-20").add(field.newDfp("0")),
260 field.newDfp("1e-20"),
261 0, "Add #29");
262
263 test(field.newDfp("1e-40").add(field.newDfp("0")),
264 field.newDfp("1e-40"),
265 0, "Add #30");
266
267 test(pinf.add(ninf),
268 nan,
269 DfpField.FLAG_INVALID, "Add #31");
270
271 test(ninf.add(pinf),
272 nan,
273 DfpField.FLAG_INVALID, "Add #32");
274
275 test(ninf.add(ninf),
276 ninf,
277 0, "Add #33");
278
279 test(pinf.add(pinf),
280 pinf,
281 0, "Add #34");
282
283 test(pinf.add(field.newDfp("0")),
284 pinf,
285 0, "Add #35");
286
287 test(pinf.add(field.newDfp("-1e131071")),
288 pinf,
289 0, "Add #36");
290
291 test(pinf.add(field.newDfp("1e131071")),
292 pinf,
293 0, "Add #37");
294
295 test(field.newDfp("0").add(pinf),
296 pinf,
297 0, "Add #38");
298
299 test(field.newDfp("-1e131071").add(pinf),
300 pinf,
301 0, "Add #39");
302
303 test(field.newDfp("1e131071").add(pinf),
304 pinf,
305 0, "Add #40");
306
307 test(ninf.add(field.newDfp("0")),
308 ninf,
309 0, "Add #41");
310
311 test(ninf.add(field.newDfp("-1e131071")),
312 ninf,
313 0, "Add #42");
314
315 test(ninf.add(field.newDfp("1e131071")),
316 ninf,
317 0, "Add #43");
318
319 test(field.newDfp("0").add(ninf),
320 ninf,
321 0, "Add #44");
322
323 test(field.newDfp("-1e131071").add(ninf),
324 ninf,
325 0, "Add #45");
326
327 test(field.newDfp("1e131071").add(ninf),
328 ninf,
329 0, "Add #46");
330
331 test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("5e131051")),
332 pinf,
333 DfpField.FLAG_OVERFLOW, "Add #47");
334
335 test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("4.9999999999999999999e131051")),
336 field.newDfp("9.9999999999999999999e131071"),
337 DfpField.FLAG_INEXACT, "Add #48");
338
339 test(nan.add(field.newDfp("1")),
340 nan,
341 0, "Add #49");
342
343 test(field.newDfp("1").add(nan),
344 nan,
345 0, "Add #50");
346
347 test(field.newDfp("12345678123456781234").add(field.newDfp("0.12345678123456781234")),
348 field.newDfp("12345678123456781234"),
349 DfpField.FLAG_INEXACT, "Add #51");
350
351 test(field.newDfp("12345678123456781234").add(field.newDfp("123.45678123456781234")),
352 field.newDfp("12345678123456781357"),
353 DfpField.FLAG_INEXACT, "Add #52");
354
355 test(field.newDfp("123.45678123456781234").add(field.newDfp("12345678123456781234")),
356 field.newDfp("12345678123456781357"),
357 DfpField.FLAG_INEXACT, "Add #53");
358
359 test(field.newDfp("12345678123456781234").add(field.newDfp(".00001234567812345678")),
360 field.newDfp("12345678123456781234"),
361 DfpField.FLAG_INEXACT, "Add #54");
362
363 test(field.newDfp("12345678123456781234").add(field.newDfp(".00000000123456781234")),
364 field.newDfp("12345678123456781234"),
365 DfpField.FLAG_INEXACT, "Add #55");
366
367 test(field.newDfp("-0").add(field.newDfp("-0")),
368 field.newDfp("-0"),
369 0, "Add #56");
370
371 test(field.newDfp("0").add(field.newDfp("-0")),
372 field.newDfp("0"),
373 0, "Add #57");
374
375 test(field.newDfp("-0").add(field.newDfp("0")),
376 field.newDfp("0"),
377 0, "Add #58");
378
379 test(field.newDfp("0").add(field.newDfp("0")),
380 field.newDfp("0"),
381 0, "Add #59");
382 }
383
384
385
386
387
388
389 private void cmptst(Dfp a, Dfp b, String op, boolean result, double num)
390 {
391 if (op == "equal")
392 if (a.equals(b) != result)
393 fail("assersion failed. "+op+" compare #"+num);
394
395 if (op == "unequal")
396 if (a.unequal(b) != result)
397 fail("assersion failed. "+op+" compare #"+num);
398
399 if (op == "lessThan")
400 if (a.lessThan(b) != result)
401 fail("assersion failed. "+op+" compare #"+num);
402
403 if (op == "greaterThan")
404 if (a.greaterThan(b) != result)
405 fail("assersion failed. "+op+" compare #"+num);
406 }
407
408 @Test
409 void testCompare()
410 {
411
412
413 field.clearIEEEFlags();
414
415 cmptst(field.newDfp("0"), field.newDfp("0"), "equal", true, 1);
416 cmptst(field.newDfp("0"), field.newDfp("-0"), "equal", true, 2);
417 cmptst(field.newDfp("-0"), field.newDfp("-0"), "equal", true, 3);
418 cmptst(field.newDfp("-0"), field.newDfp("0"), "equal", true, 4);
419
420
421
422 cmptst(field.newDfp("0"), field.newDfp("1"), "equal", false, 5);
423 cmptst(field.newDfp("1"), field.newDfp("0"), "equal", false, 6);
424 cmptst(field.newDfp("-1"), field.newDfp("0"), "equal", false, 7);
425 cmptst(field.newDfp("0"), field.newDfp("-1"), "equal", false, 8);
426 cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "equal", false, 9);
427
428 if (field.getIEEEFlags() != 0)
429 fail("assersion failed. compare flags = "+field.getIEEEFlags());
430
431 cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "equal", false, 10);
432
433
434 if (field.getIEEEFlags() != DfpField.FLAG_UNDERFLOW)
435 fail("assersion failed. compare flags = "+field.getIEEEFlags());
436
437 field.clearIEEEFlags();
438
439 cmptst(field.newDfp("0"), field.newDfp("1e+131071"), "equal", false, 11);
440
441
442
443 cmptst(field.newDfp("0"), pinf, "equal", false, 12);
444 cmptst(field.newDfp("0"), ninf, "equal", false, 13);
445 cmptst(field.newDfp("-0"), pinf, "equal", false, 14);
446 cmptst(field.newDfp("-0"), ninf, "equal", false, 15);
447 cmptst(pinf, field.newDfp("0"), "equal", false, 16);
448 cmptst(ninf, field.newDfp("0"), "equal", false, 17);
449 cmptst(pinf, field.newDfp("-0"), "equal", false, 18);
450 cmptst(ninf, field.newDfp("-0"), "equal", false, 19);
451 cmptst(ninf, pinf, "equal", false, 19.10);
452 cmptst(pinf, ninf, "equal", false, 19.11);
453 cmptst(pinf, pinf, "equal", true, 19.12);
454 cmptst(ninf, ninf, "equal", true, 19.13);
455
456
457 cmptst(field.newDfp("1"), field.newDfp("1"), "equal", true, 20);
458 cmptst(field.newDfp("1"), field.newDfp("-1"), "equal", false, 21);
459 cmptst(field.newDfp("-1"), field.newDfp("-1"), "equal", true, 22);
460 cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "equal", false, 23);
461
462
463
464 cmptst(field.newDfp("1e20"), field.newDfp("1.0000000000000001"), "equal", false, 24);
465 if (field.getIEEEFlags() != 0)
466 fail("assersion failed. compare flags = "+field.getIEEEFlags());
467
468 cmptst(field.newDfp("0.000001"), field.newDfp("1e-6"), "equal", true, 25);
469
470
471
472 cmptst(snan, snan, "equal", false, 27);
473 cmptst(qnan, qnan, "equal", false, 28);
474 cmptst(snan, qnan, "equal", false, 29);
475 cmptst(qnan, snan, "equal", false, 30);
476 cmptst(qnan, field.newDfp("0"), "equal", false, 31);
477 cmptst(snan, field.newDfp("0"), "equal", false, 32);
478 cmptst(field.newDfp("0"), snan, "equal", false, 33);
479 cmptst(field.newDfp("0"), qnan, "equal", false, 34);
480 cmptst(qnan, pinf, "equal", false, 35);
481 cmptst(snan, pinf, "equal", false, 36);
482 cmptst(pinf, snan, "equal", false, 37);
483 cmptst(pinf, qnan, "equal", false, 38);
484 cmptst(qnan, ninf, "equal", false, 39);
485 cmptst(snan, ninf, "equal", false, 40);
486 cmptst(ninf, snan, "equal", false, 41);
487 cmptst(ninf, qnan, "equal", false, 42);
488 cmptst(qnan, field.newDfp("-1"), "equal", false, 43);
489 cmptst(snan, field.newDfp("-1"), "equal", false, 44);
490 cmptst(field.newDfp("-1"), snan, "equal", false, 45);
491 cmptst(field.newDfp("-1"), qnan, "equal", false, 46);
492 cmptst(qnan, field.newDfp("1"), "equal", false, 47);
493 cmptst(snan, field.newDfp("1"), "equal", false, 48);
494 cmptst(field.newDfp("1"), snan, "equal", false, 49);
495 cmptst(field.newDfp("1"), qnan, "equal", false, 50);
496 cmptst(snan.negate(), snan, "equal", false, 51);
497 cmptst(qnan.negate(), qnan, "equal", false, 52);
498
499
500
501
502
503 cmptst(field.newDfp("0"), field.newDfp("0"), "unequal", false, 1);
504 cmptst(field.newDfp("0"), field.newDfp("-0"), "unequal", false, 2);
505 cmptst(field.newDfp("-0"), field.newDfp("-0"), "unequal", false, 3);
506 cmptst(field.newDfp("-0"), field.newDfp("0"), "unequal", false, 4);
507
508
509
510 cmptst(field.newDfp("0"), field.newDfp("1"), "unequal", true, 5);
511 cmptst(field.newDfp("1"), field.newDfp("0"), "unequal", true, 6);
512 cmptst(field.newDfp("-1"), field.newDfp("0"), "unequal", true, 7);
513 cmptst(field.newDfp("0"), field.newDfp("-1"), "unequal", true, 8);
514 cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "unequal", true, 9);
515
516 if (field.getIEEEFlags() != 0)
517 fail("assersion failed. compare flags = "+field.getIEEEFlags());
518
519 cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "unequal", true, 10);
520
521
522 if (field.getIEEEFlags() != DfpField.FLAG_UNDERFLOW)
523 fail("assersion failed. compare flags = "+field.getIEEEFlags());
524
525 field.clearIEEEFlags();
526
527 cmptst(field.newDfp("0"), field.newDfp("1e+131071"), "unequal", true, 11);
528
529
530
531 cmptst(field.newDfp("0"), pinf, "unequal", true, 12);
532 cmptst(field.newDfp("0"), ninf, "unequal", true, 13);
533 cmptst(field.newDfp("-0"), pinf, "unequal", true, 14);
534 cmptst(field.newDfp("-0"), ninf, "unequal", true, 15);
535 cmptst(pinf, field.newDfp("0"), "unequal", true, 16);
536 cmptst(ninf, field.newDfp("0"), "unequal", true, 17);
537 cmptst(pinf, field.newDfp("-0"), "unequal", true, 18);
538 cmptst(ninf, field.newDfp("-0"), "unequal", true, 19);
539 cmptst(ninf, pinf, "unequal", true, 19.10);
540 cmptst(pinf, ninf, "unequal", true, 19.11);
541 cmptst(pinf, pinf, "unequal", false, 19.12);
542 cmptst(ninf, ninf, "unequal", false, 19.13);
543
544
545 cmptst(field.newDfp("1"), field.newDfp("1"), "unequal", false, 20);
546 cmptst(field.newDfp("1"), field.newDfp("-1"), "unequal", true, 21);
547 cmptst(field.newDfp("-1"), field.newDfp("-1"), "unequal", false, 22);
548 cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "unequal", true, 23);
549
550
551
552 cmptst(field.newDfp("1e20"), field.newDfp("1.0000000000000001"), "unequal", true, 24);
553 if (field.getIEEEFlags() != 0)
554 fail("assersion failed. compare flags = "+field.getIEEEFlags());
555
556 cmptst(field.newDfp("0.000001"), field.newDfp("1e-6"), "unequal", false, 25);
557
558
559
560 cmptst(snan, snan, "unequal", false, 27);
561 cmptst(qnan, qnan, "unequal", false, 28);
562 cmptst(snan, qnan, "unequal", false, 29);
563 cmptst(qnan, snan, "unequal", false, 30);
564 cmptst(qnan, field.newDfp("0"), "unequal", false, 31);
565 cmptst(snan, field.newDfp("0"), "unequal", false, 32);
566 cmptst(field.newDfp("0"), snan, "unequal", false, 33);
567 cmptst(field.newDfp("0"), qnan, "unequal", false, 34);
568 cmptst(qnan, pinf, "unequal", false, 35);
569 cmptst(snan, pinf, "unequal", false, 36);
570 cmptst(pinf, snan, "unequal", false, 37);
571 cmptst(pinf, qnan, "unequal", false, 38);
572 cmptst(qnan, ninf, "unequal", false, 39);
573 cmptst(snan, ninf, "unequal", false, 40);
574 cmptst(ninf, snan, "unequal", false, 41);
575 cmptst(ninf, qnan, "unequal", false, 42);
576 cmptst(qnan, field.newDfp("-1"), "unequal", false, 43);
577 cmptst(snan, field.newDfp("-1"), "unequal", false, 44);
578 cmptst(field.newDfp("-1"), snan, "unequal", false, 45);
579 cmptst(field.newDfp("-1"), qnan, "unequal", false, 46);
580 cmptst(qnan, field.newDfp("1"), "unequal", false, 47);
581 cmptst(snan, field.newDfp("1"), "unequal", false, 48);
582 cmptst(field.newDfp("1"), snan, "unequal", false, 49);
583 cmptst(field.newDfp("1"), qnan, "unequal", false, 50);
584 cmptst(snan.negate(), snan, "unequal", false, 51);
585 cmptst(qnan.negate(), qnan, "unequal", false, 52);
586
587 if (field.getIEEEFlags() != 0)
588 fail("assersion failed. compare unequal flags = "+field.getIEEEFlags());
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 fail("assersion failed. compare flags = "+field.getIEEEFlags());
609
610 cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "lessThan", true, 10);
611
612
613 if (field.getIEEEFlags() != DfpField.FLAG_UNDERFLOW)
614 fail("assersion failed. compare flags = "+field.getIEEEFlags());
615 field.clearIEEEFlags();
616
617 cmptst(field.newDfp("0"), field.newDfp("1e+131071"), "lessThan", true, 11);
618
619
620
621 cmptst(field.newDfp("0"), pinf, "lessThan", true, 12);
622 cmptst(field.newDfp("0"), ninf, "lessThan", false, 13);
623 cmptst(field.newDfp("-0"), pinf, "lessThan", true, 14);
624 cmptst(field.newDfp("-0"), ninf, "lessThan", false, 15);
625 cmptst(pinf, field.newDfp("0"), "lessThan", false, 16);
626 cmptst(ninf, field.newDfp("0"), "lessThan", true, 17);
627 cmptst(pinf, field.newDfp("-0"), "lessThan", false, 18);
628 cmptst(ninf, field.newDfp("-0"), "lessThan", true, 19);
629 cmptst(ninf, pinf, "lessThan", true, 19.10);
630 cmptst(pinf, ninf, "lessThan", false, 19.11);
631 cmptst(pinf, pinf, "lessThan", false, 19.12);
632 cmptst(ninf, ninf, "lessThan", false, 19.13);
633
634
635 cmptst(field.newDfp("1"), field.newDfp("1"), "lessThan", false, 20);
636 cmptst(field.newDfp("1"), field.newDfp("-1"), "lessThan", false, 21);
637 cmptst(field.newDfp("-1"), field.newDfp("-1"), "lessThan", false, 22);
638 cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "lessThan", true, 23);
639
640
641
642 cmptst(field.newDfp("1e20"), field.newDfp("1.0000000000000001"), "lessThan", false, 24);
643 if (field.getIEEEFlags() != 0)
644 fail("assersion failed. compare flags = "+field.getIEEEFlags());
645
646 cmptst(field.newDfp("0.000001"), field.newDfp("1e-6"), "lessThan", false, 25);
647
648
649 cmptst(snan, snan, "lessThan", false, 27);
650 cmptst(qnan, qnan, "lessThan", false, 28);
651 cmptst(snan, qnan, "lessThan", false, 29);
652 cmptst(qnan, snan, "lessThan", false, 30);
653 cmptst(qnan, field.newDfp("0"), "lessThan", false, 31);
654 cmptst(snan, field.newDfp("0"), "lessThan", false, 32);
655 cmptst(field.newDfp("0"), snan, "lessThan", false, 33);
656 cmptst(field.newDfp("0"), qnan, "lessThan", false, 34);
657 cmptst(qnan, pinf, "lessThan", false, 35);
658 cmptst(snan, pinf, "lessThan", false, 36);
659 cmptst(pinf, snan, "lessThan", false, 37);
660 cmptst(pinf, qnan, "lessThan", false, 38);
661 cmptst(qnan, ninf, "lessThan", false, 39);
662 cmptst(snan, ninf, "lessThan", false, 40);
663 cmptst(ninf, snan, "lessThan", false, 41);
664 cmptst(ninf, qnan, "lessThan", false, 42);
665 cmptst(qnan, field.newDfp("-1"), "lessThan", false, 43);
666 cmptst(snan, field.newDfp("-1"), "lessThan", false, 44);
667 cmptst(field.newDfp("-1"), snan, "lessThan", false, 45);
668 cmptst(field.newDfp("-1"), qnan, "lessThan", false, 46);
669 cmptst(qnan, field.newDfp("1"), "lessThan", false, 47);
670 cmptst(snan, field.newDfp("1"), "lessThan", false, 48);
671 cmptst(field.newDfp("1"), snan, "lessThan", false, 49);
672 cmptst(field.newDfp("1"), qnan, "lessThan", false, 50);
673 cmptst(snan.negate(), snan, "lessThan", false, 51);
674 cmptst(qnan.negate(), qnan, "lessThan", false, 52);
675
676
677 if (field.getIEEEFlags() != DfpField.FLAG_INVALID)
678 fail("assersion failed. compare lessThan flags = "+field.getIEEEFlags());
679 field.clearIEEEFlags();
680
681
682
683
684
685 cmptst(field.newDfp("0"), field.newDfp("0"), "greaterThan", false, 1);
686 cmptst(field.newDfp("0"), field.newDfp("-0"), "greaterThan", false, 2);
687 cmptst(field.newDfp("-0"), field.newDfp("-0"), "greaterThan", false, 3);
688 cmptst(field.newDfp("-0"), field.newDfp("0"), "greaterThan", false, 4);
689
690
691
692 cmptst(field.newDfp("0"), field.newDfp("1"), "greaterThan", false, 5);
693 cmptst(field.newDfp("1"), field.newDfp("0"), "greaterThan", true, 6);
694 cmptst(field.newDfp("-1"), field.newDfp("0"), "greaterThan", false, 7);
695 cmptst(field.newDfp("0"), field.newDfp("-1"), "greaterThan", true, 8);
696 cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "greaterThan", false, 9);
697
698 if (field.getIEEEFlags() != 0)
699 fail("assersion failed. compare flags = "+field.getIEEEFlags());
700
701 cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "greaterThan", false, 10);
702
703
704 if (field.getIEEEFlags() != DfpField.FLAG_UNDERFLOW)
705 fail("assersion failed. compare flags = "+field.getIEEEFlags());
706 field.clearIEEEFlags();
707
708 cmptst(field.newDfp("0"), field.newDfp("1e+131071"), "greaterThan", false, 11);
709
710
711
712 cmptst(field.newDfp("0"), pinf, "greaterThan", false, 12);
713 cmptst(field.newDfp("0"), ninf, "greaterThan", true, 13);
714 cmptst(field.newDfp("-0"), pinf, "greaterThan", false, 14);
715 cmptst(field.newDfp("-0"), ninf, "greaterThan", true, 15);
716 cmptst(pinf, field.newDfp("0"), "greaterThan", true, 16);
717 cmptst(ninf, field.newDfp("0"), "greaterThan", false, 17);
718 cmptst(pinf, field.newDfp("-0"), "greaterThan", true, 18);
719 cmptst(ninf, field.newDfp("-0"), "greaterThan", false, 19);
720 cmptst(ninf, pinf, "greaterThan", false, 19.10);
721 cmptst(pinf, ninf, "greaterThan", true, 19.11);
722 cmptst(pinf, pinf, "greaterThan", false, 19.12);
723 cmptst(ninf, ninf, "greaterThan", false, 19.13);
724
725
726 cmptst(field.newDfp("1"), field.newDfp("1"), "greaterThan", false, 20);
727 cmptst(field.newDfp("1"), field.newDfp("-1"), "greaterThan", true, 21);
728 cmptst(field.newDfp("-1"), field.newDfp("-1"), "greaterThan", false, 22);
729 cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "greaterThan", false, 23);
730
731
732
733 cmptst(field.newDfp("1e20"), field.newDfp("1.0000000000000001"), "greaterThan", true, 24);
734 if (field.getIEEEFlags() != 0)
735 fail("assersion failed. compare flags = "+field.getIEEEFlags());
736
737 cmptst(field.newDfp("0.000001"), field.newDfp("1e-6"), "greaterThan", false, 25);
738
739
740 cmptst(snan, snan, "greaterThan", false, 27);
741 cmptst(qnan, qnan, "greaterThan", false, 28);
742 cmptst(snan, qnan, "greaterThan", false, 29);
743 cmptst(qnan, snan, "greaterThan", false, 30);
744 cmptst(qnan, field.newDfp("0"), "greaterThan", false, 31);
745 cmptst(snan, field.newDfp("0"), "greaterThan", false, 32);
746 cmptst(field.newDfp("0"), snan, "greaterThan", false, 33);
747 cmptst(field.newDfp("0"), qnan, "greaterThan", false, 34);
748 cmptst(qnan, pinf, "greaterThan", false, 35);
749 cmptst(snan, pinf, "greaterThan", false, 36);
750 cmptst(pinf, snan, "greaterThan", false, 37);
751 cmptst(pinf, qnan, "greaterThan", false, 38);
752 cmptst(qnan, ninf, "greaterThan", false, 39);
753 cmptst(snan, ninf, "greaterThan", false, 40);
754 cmptst(ninf, snan, "greaterThan", false, 41);
755 cmptst(ninf, qnan, "greaterThan", false, 42);
756 cmptst(qnan, field.newDfp("-1"), "greaterThan", false, 43);
757 cmptst(snan, field.newDfp("-1"), "greaterThan", false, 44);
758 cmptst(field.newDfp("-1"), snan, "greaterThan", false, 45);
759 cmptst(field.newDfp("-1"), qnan, "greaterThan", false, 46);
760 cmptst(qnan, field.newDfp("1"), "greaterThan", false, 47);
761 cmptst(snan, field.newDfp("1"), "greaterThan", false, 48);
762 cmptst(field.newDfp("1"), snan, "greaterThan", false, 49);
763 cmptst(field.newDfp("1"), qnan, "greaterThan", false, 50);
764 cmptst(snan.negate(), snan, "greaterThan", false, 51);
765 cmptst(qnan.negate(), qnan, "greaterThan", false, 52);
766
767
768 if (field.getIEEEFlags() != DfpField.FLAG_INVALID)
769 fail("assersion failed. compare greaterThan flags = "+field.getIEEEFlags());
770 field.clearIEEEFlags();
771 }
772
773
774
775
776 @Test
777 void testMultiply()
778 {
779 test(field.newDfp("1").multiply(field.newDfp("1")),
780 field.newDfp("1"),
781 0, "Multiply #1");
782
783 test(field.newDfp("1").multiply(1),
784 field.newDfp("1"),
785 0, "Multiply #2");
786
787 test(field.newDfp("-1").multiply(field.newDfp("1")),
788 field.newDfp("-1"),
789 0, "Multiply #3");
790
791 test(field.newDfp("-1").multiply(1),
792 field.newDfp("-1"),
793 0, "Multiply #4");
794
795
796 test(field.newDfp("2").multiply(field.newDfp("3")),
797 field.newDfp("6"),
798 0, "Multiply #5");
799
800 test(field.newDfp("2").multiply(3),
801 field.newDfp("6"),
802 0, "Multiply #6");
803
804 test(field.newDfp("-2").multiply(field.newDfp("3")),
805 field.newDfp("-6"),
806 0, "Multiply #7");
807
808 test(field.newDfp("-2").multiply(3),
809 field.newDfp("-6"),
810 0, "Multiply #8");
811
812 test(field.newDfp("2").multiply(field.newDfp("-3")),
813 field.newDfp("-6"),
814 0, "Multiply #9");
815
816 test(field.newDfp("-2").multiply(field.newDfp("-3")),
817 field.newDfp("6"),
818 0, "Multiply #10");
819
820
821
822 test(field.newDfp("-2").multiply(field.newDfp("0")),
823 field.newDfp("-0"),
824 0, "Multiply #11");
825
826 test(field.newDfp("-2").multiply(0),
827 field.newDfp("-0"),
828 0, "Multiply #12");
829
830 test(field.newDfp("2").multiply(field.newDfp("0")),
831 field.newDfp("0"),
832 0, "Multiply #13");
833
834 test(field.newDfp("2").multiply(0),
835 field.newDfp("0"),
836 0, "Multiply #14");
837
838 test(field.newDfp("2").multiply(pinf),
839 pinf,
840 0, "Multiply #15");
841
842 test(field.newDfp("2").multiply(ninf),
843 ninf,
844 0, "Multiply #16");
845
846 test(field.newDfp("-2").multiply(pinf),
847 ninf,
848 0, "Multiply #17");
849
850 test(field.newDfp("-2").multiply(ninf),
851 pinf,
852 0, "Multiply #18");
853
854 test(ninf.multiply(field.newDfp("-2")),
855 pinf,
856 0, "Multiply #18.1");
857
858 test(field.newDfp("5e131071").multiply(2),
859 pinf,
860 DfpField.FLAG_OVERFLOW, "Multiply #19");
861
862 test(field.newDfp("5e131071").multiply(field.newDfp("1.999999999999999")),
863 field.newDfp("9.9999999999999950000e131071"),
864 0, "Multiply #20");
865
866 test(field.newDfp("-5e131071").multiply(2),
867 ninf,
868 DfpField.FLAG_OVERFLOW, "Multiply #22");
869
870 test(field.newDfp("-5e131071").multiply(field.newDfp("1.999999999999999")),
871 field.newDfp("-9.9999999999999950000e131071"),
872 0, "Multiply #23");
873
874 test(field.newDfp("1e-65539").multiply(field.newDfp("1e-65539")),
875 field.newDfp("1e-131078"),
876 DfpField.FLAG_UNDERFLOW, "Multiply #24");
877
878 test(field.newDfp("1").multiply(nan),
879 nan,
880 0, "Multiply #25");
881
882 test(nan.multiply(field.newDfp("1")),
883 nan,
884 0, "Multiply #26");
885
886 test(nan.multiply(pinf),
887 nan,
888 0, "Multiply #27");
889
890 test(pinf.multiply(nan),
891 nan,
892 0, "Multiply #27");
893
894 test(pinf.multiply(field.newDfp("0")),
895 nan,
896 DfpField.FLAG_INVALID, "Multiply #28");
897
898 test(field.newDfp("0").multiply(pinf),
899 nan,
900 DfpField.FLAG_INVALID, "Multiply #29");
901
902 test(pinf.multiply(pinf),
903 pinf,
904 0, "Multiply #30");
905
906 test(ninf.multiply(pinf),
907 ninf,
908 0, "Multiply #31");
909
910 test(pinf.multiply(ninf),
911 ninf,
912 0, "Multiply #32");
913
914 test(ninf.multiply(ninf),
915 pinf,
916 0, "Multiply #33");
917
918 test(pinf.multiply(1),
919 pinf,
920 0, "Multiply #34");
921
922 test(pinf.multiply(0),
923 nan,
924 DfpField.FLAG_INVALID, "Multiply #35");
925
926 test(nan.multiply(1),
927 nan,
928 0, "Multiply #36");
929
930 test(field.newDfp("1").multiply(10000),
931 field.newDfp("10000"),
932 0, "Multiply #37");
933
934 test(field.newDfp("2").multiply(1000000),
935 field.newDfp("2000000"),
936 0, "Multiply #38");
937
938 test(field.newDfp("1").multiply(-1),
939 field.newDfp("-1"),
940 0, "Multiply #39");
941 }
942
943 @Test
944 void testDivide()
945 {
946 test(field.newDfp("1").divide(nan),
947 nan,
948 0, "Divide #1");
949
950 test(nan.divide(field.newDfp("1")),
951 nan,
952 0, "Divide #2");
953
954 test(pinf.divide(field.newDfp("1")),
955 pinf,
956 0, "Divide #3");
957
958 test(pinf.divide(field.newDfp("-1")),
959 ninf,
960 0, "Divide #4");
961
962 test(pinf.divide(pinf),
963 nan,
964 DfpField.FLAG_INVALID, "Divide #5");
965
966 test(ninf.divide(pinf),
967 nan,
968 DfpField.FLAG_INVALID, "Divide #6");
969
970 test(pinf.divide(ninf),
971 nan,
972 DfpField.FLAG_INVALID, "Divide #7");
973
974 test(ninf.divide(ninf),
975 nan,
976 DfpField.FLAG_INVALID, "Divide #8");
977
978 test(field.newDfp("0").divide(field.newDfp("0")),
979 nan,
980 DfpField.FLAG_DIV_ZERO, "Divide #9");
981
982 test(field.newDfp("1").divide(field.newDfp("0")),
983 pinf,
984 DfpField.FLAG_DIV_ZERO, "Divide #10");
985
986 test(field.newDfp("1").divide(field.newDfp("-0")),
987 ninf,
988 DfpField.FLAG_DIV_ZERO, "Divide #11");
989
990 test(field.newDfp("-1").divide(field.newDfp("0")),
991 ninf,
992 DfpField.FLAG_DIV_ZERO, "Divide #12");
993
994 test(field.newDfp("-1").divide(field.newDfp("-0")),
995 pinf,
996 DfpField.FLAG_DIV_ZERO, "Divide #13");
997
998 test(field.newDfp("1").divide(field.newDfp("3")),
999 field.newDfp("0.33333333333333333333"),
1000 DfpField.FLAG_INEXACT, "Divide #14");
1001
1002 test(field.newDfp("1").divide(field.newDfp("6")),
1003 field.newDfp("0.16666666666666666667"),
1004 DfpField.FLAG_INEXACT, "Divide #15");
1005
1006 test(field.newDfp("10").divide(field.newDfp("6")),
1007 field.newDfp("1.6666666666666667"),
1008 DfpField.FLAG_INEXACT, "Divide #16");
1009
1010 test(field.newDfp("100").divide(field.newDfp("6")),
1011 field.newDfp("16.6666666666666667"),
1012 DfpField.FLAG_INEXACT, "Divide #17");
1013
1014 test(field.newDfp("1000").divide(field.newDfp("6")),
1015 field.newDfp("166.6666666666666667"),
1016 DfpField.FLAG_INEXACT, "Divide #18");
1017
1018 test(field.newDfp("10000").divide(field.newDfp("6")),
1019 field.newDfp("1666.6666666666666667"),
1020 DfpField.FLAG_INEXACT, "Divide #19");
1021
1022 test(field.newDfp("1").divide(field.newDfp("1")),
1023 field.newDfp("1"),
1024 0, "Divide #20");
1025
1026 test(field.newDfp("1").divide(field.newDfp("-1")),
1027 field.newDfp("-1"),
1028 0, "Divide #21");
1029
1030 test(field.newDfp("-1").divide(field.newDfp("1")),
1031 field.newDfp("-1"),
1032 0, "Divide #22");
1033
1034 test(field.newDfp("-1").divide(field.newDfp("-1")),
1035 field.newDfp("1"),
1036 0, "Divide #23");
1037
1038 test(field.newDfp("1e-65539").divide(field.newDfp("1e65539")),
1039 field.newDfp("1e-131078"),
1040 DfpField.FLAG_UNDERFLOW, "Divide #24");
1041
1042 test(field.newDfp("1e65539").divide(field.newDfp("1e-65539")),
1043 pinf,
1044 DfpField.FLAG_OVERFLOW, "Divide #24");
1045
1046 test(field.newDfp("2").divide(field.newDfp("1.5")),
1047 field.newDfp("1.3333333333333333"),
1048 DfpField.FLAG_INEXACT, "Divide #25");
1049
1050 test(field.newDfp("2").divide(pinf),
1051 field.newDfp("0"),
1052 0, "Divide #26");
1053
1054 test(field.newDfp("2").divide(ninf),
1055 field.newDfp("-0"),
1056 0, "Divide #27");
1057
1058 test(field.newDfp("0").divide(field.newDfp("1")),
1059 field.newDfp("0"),
1060 0, "Divide #28");
1061 }
1062
1063 @Test
1064 void testReciprocal()
1065 {
1066 test(nan.reciprocal(),
1067 nan,
1068 0, "Reciprocal #1");
1069
1070 test(field.newDfp("0").reciprocal(),
1071 pinf,
1072 DfpField.FLAG_DIV_ZERO, "Reciprocal #2");
1073
1074 test(field.newDfp("-0").reciprocal(),
1075 ninf,
1076 DfpField.FLAG_DIV_ZERO, "Reciprocal #3");
1077
1078 test(field.newDfp("3").reciprocal(),
1079 field.newDfp("0.33333333333333333333"),
1080 DfpField.FLAG_INEXACT, "Reciprocal #4");
1081
1082 test(field.newDfp("6").reciprocal(),
1083 field.newDfp("0.16666666666666666667"),
1084 DfpField.FLAG_INEXACT, "Reciprocal #5");
1085
1086 test(field.newDfp("1").reciprocal(),
1087 field.newDfp("1"),
1088 0, "Reciprocal #6");
1089
1090 test(field.newDfp("-1").reciprocal(),
1091 field.newDfp("-1"),
1092 0, "Reciprocal #7");
1093
1094 test(pinf.reciprocal(),
1095 field.newDfp("0"),
1096 0, "Reciprocal #8");
1097
1098 test(ninf.reciprocal(),
1099 field.newDfp("-0"),
1100 0, "Reciprocal #9");
1101 }
1102
1103 @Test
1104 void testDivideInt()
1105 {
1106 test(nan.divide(1),
1107 nan,
1108 0, "DivideInt #1");
1109
1110 test(pinf.divide(1),
1111 pinf,
1112 0, "DivideInt #2");
1113
1114 test(field.newDfp("0").divide(0),
1115 nan,
1116 DfpField.FLAG_DIV_ZERO, "DivideInt #3");
1117
1118 test(field.newDfp("1").divide(0),
1119 pinf,
1120 DfpField.FLAG_DIV_ZERO, "DivideInt #4");
1121
1122 test(field.newDfp("-1").divide(0),
1123 ninf,
1124 DfpField.FLAG_DIV_ZERO, "DivideInt #5");
1125
1126 test(field.newDfp("1").divide(3),
1127 field.newDfp("0.33333333333333333333"),
1128 DfpField.FLAG_INEXACT, "DivideInt #6");
1129
1130 test(field.newDfp("1").divide(6),
1131 field.newDfp("0.16666666666666666667"),
1132 DfpField.FLAG_INEXACT, "DivideInt #7");
1133
1134 test(field.newDfp("10").divide(6),
1135 field.newDfp("1.6666666666666667"),
1136 DfpField.FLAG_INEXACT, "DivideInt #8");
1137
1138 test(field.newDfp("100").divide(6),
1139 field.newDfp("16.6666666666666667"),
1140 DfpField.FLAG_INEXACT, "DivideInt #9");
1141
1142 test(field.newDfp("1000").divide(6),
1143 field.newDfp("166.6666666666666667"),
1144 DfpField.FLAG_INEXACT, "DivideInt #10");
1145
1146 test(field.newDfp("10000").divide(6),
1147 field.newDfp("1666.6666666666666667"),
1148 DfpField.FLAG_INEXACT, "DivideInt #20");
1149
1150 test(field.newDfp("1").divide(1),
1151 field.newDfp("1"),
1152 0, "DivideInt #21");
1153
1154 test(field.newDfp("1e-131077").divide(10),
1155 field.newDfp("1e-131078"),
1156 DfpField.FLAG_UNDERFLOW, "DivideInt #22");
1157
1158 test(field.newDfp("0").divide(1),
1159 field.newDfp("0"),
1160 0, "DivideInt #23");
1161
1162 test(field.newDfp("1").divide(10000),
1163 nan,
1164 DfpField.FLAG_INVALID, "DivideInt #24");
1165
1166 test(field.newDfp("1").divide(-1),
1167 nan,
1168 DfpField.FLAG_INVALID, "DivideInt #25");
1169 }
1170
1171 @Test
1172 void testNextAfter()
1173 {
1174 test(field.newDfp("1").nextAfter(pinf),
1175 field.newDfp("1.0000000000000001"),
1176 0, "NextAfter #1");
1177
1178 test(field.newDfp("1.0000000000000001").nextAfter(ninf),
1179 field.newDfp("1"),
1180 0, "NextAfter #1.5");
1181
1182 test(field.newDfp("1").nextAfter(ninf),
1183 field.newDfp("0.99999999999999999999"),
1184 0, "NextAfter #2");
1185
1186 test(field.newDfp("0.99999999999999999999").nextAfter(field.newDfp("2")),
1187 field.newDfp("1"),
1188 0, "NextAfter #3");
1189
1190 test(field.newDfp("-1").nextAfter(ninf),
1191 field.newDfp("-1.0000000000000001"),
1192 0, "NextAfter #4");
1193
1194 test(field.newDfp("-1").nextAfter(pinf),
1195 field.newDfp("-0.99999999999999999999"),
1196 0, "NextAfter #5");
1197
1198 test(field.newDfp("-0.99999999999999999999").nextAfter(field.newDfp("-2")),
1199 field.newDfp("-1"),
1200 0, "NextAfter #6");
1201
1202 test(field.newDfp("2").nextAfter(field.newDfp("2")),
1203 field.newDfp("2"),
1204 0, "NextAfter #7");
1205
1206 test(field.newDfp("0").nextAfter(field.newDfp("0")),
1207 field.newDfp("0"),
1208 0, "NextAfter #8");
1209
1210 test(field.newDfp("-2").nextAfter(field.newDfp("-2")),
1211 field.newDfp("-2"),
1212 0, "NextAfter #9");
1213
1214 test(field.newDfp("0").nextAfter(field.newDfp("1")),
1215 field.newDfp("1e-131092"),
1216 DfpField.FLAG_UNDERFLOW, "NextAfter #10");
1217
1218 test(field.newDfp("0").nextAfter(field.newDfp("-1")),
1219 field.newDfp("-1e-131092"),
1220 DfpField.FLAG_UNDERFLOW, "NextAfter #11");
1221
1222 test(field.newDfp("-1e-131092").nextAfter(pinf),
1223 field.newDfp("-0"),
1224 DfpField.FLAG_UNDERFLOW|DfpField.FLAG_INEXACT, "Next After #12");
1225
1226 test(field.newDfp("1e-131092").nextAfter(ninf),
1227 field.newDfp("0"),
1228 DfpField.FLAG_UNDERFLOW|DfpField.FLAG_INEXACT, "Next After #13");
1229
1230 test(field.newDfp("9.9999999999999999999e131078").nextAfter(pinf),
1231 pinf,
1232 DfpField.FLAG_OVERFLOW|DfpField.FLAG_INEXACT, "Next After #14");
1233 }
1234
1235 @Test
1236 void testToString()
1237 {
1238 assertEquals("Infinity", pinf.toString(), "toString #1");
1239 assertEquals("-Infinity", ninf.toString(), "toString #2");
1240 assertEquals("NaN", nan.toString(), "toString #3");
1241 assertEquals("NaN", field.newDfp((byte) 1, Dfp.QNAN).toString(), "toString #4");
1242 assertEquals("NaN", field.newDfp((byte) 1, Dfp.SNAN).toString(), "toString #5");
1243 assertEquals("1.2300000000000000e100", field.newDfp("1.23e100").toString(), "toString #6");
1244 assertEquals("-1.2300000000000000e100", field.newDfp("-1.23e100").toString(), "toString #7");
1245 assertEquals("12345678.1234", field.newDfp("12345678.1234").toString(), "toString #8");
1246 assertEquals("0.00001234", field.newDfp("0.00001234").toString(), "toString #9");
1247 }
1248
1249 @Override
1250 @Test
1251 public void testRound()
1252 {
1253 field.setRoundingMode(DfpField.RoundingMode.ROUND_DOWN);
1254
1255
1256 test(field.newDfp("12345678901234567890").add(field.newDfp("0.9")),
1257 field.newDfp("12345678901234567890"),
1258 DfpField.FLAG_INEXACT, "Round #1");
1259
1260 test(field.newDfp("12345678901234567890").add(field.newDfp("0.99999999")),
1261 field.newDfp("12345678901234567890"),
1262 DfpField.FLAG_INEXACT, "Round #2");
1263
1264 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.99999999")),
1265 field.newDfp("-12345678901234567890"),
1266 DfpField.FLAG_INEXACT, "Round #3");
1267
1268 field.setRoundingMode(DfpField.RoundingMode.ROUND_UP);
1269
1270
1271 test(field.newDfp("12345678901234567890").add(field.newDfp("0.1")),
1272 field.newDfp("12345678901234567891"),
1273 DfpField.FLAG_INEXACT, "Round #4");
1274
1275 test(field.newDfp("12345678901234567890").add(field.newDfp("0.0001")),
1276 field.newDfp("12345678901234567891"),
1277 DfpField.FLAG_INEXACT, "Round #5");
1278
1279 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.1")),
1280 field.newDfp("-12345678901234567891"),
1281 DfpField.FLAG_INEXACT, "Round #6");
1282
1283 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.0001")),
1284 field.newDfp("-12345678901234567891"),
1285 DfpField.FLAG_INEXACT, "Round #7");
1286
1287 field.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_UP);
1288
1289
1290 test(field.newDfp("12345678901234567890").add(field.newDfp("0.4999")),
1291 field.newDfp("12345678901234567890"),
1292 DfpField.FLAG_INEXACT, "Round #8");
1293
1294 test(field.newDfp("12345678901234567890").add(field.newDfp("0.5000")),
1295 field.newDfp("12345678901234567891"),
1296 DfpField.FLAG_INEXACT, "Round #9");
1297
1298 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.4999")),
1299 field.newDfp("-12345678901234567890"),
1300 DfpField.FLAG_INEXACT, "Round #10");
1301
1302 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.5000")),
1303 field.newDfp("-12345678901234567891"),
1304 DfpField.FLAG_INEXACT, "Round #11");
1305
1306 field.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_DOWN);
1307
1308
1309 test(field.newDfp("12345678901234567890").add(field.newDfp("0.5001")),
1310 field.newDfp("12345678901234567891"),
1311 DfpField.FLAG_INEXACT, "Round #12");
1312
1313 test(field.newDfp("12345678901234567890").add(field.newDfp("0.5000")),
1314 field.newDfp("12345678901234567890"),
1315 DfpField.FLAG_INEXACT, "Round #13");
1316
1317 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.5001")),
1318 field.newDfp("-12345678901234567891"),
1319 DfpField.FLAG_INEXACT, "Round #14");
1320
1321 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.5000")),
1322 field.newDfp("-12345678901234567890"),
1323 DfpField.FLAG_INEXACT, "Round #15");
1324
1325 field.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_ODD);
1326
1327
1328 test(field.newDfp("12345678901234567890").add(field.newDfp("0.5000")),
1329 field.newDfp("12345678901234567891"),
1330 DfpField.FLAG_INEXACT, "Round #16");
1331
1332 test(field.newDfp("12345678901234567891").add(field.newDfp("0.5000")),
1333 field.newDfp("12345678901234567891"),
1334 DfpField.FLAG_INEXACT, "Round #17");
1335
1336 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.5000")),
1337 field.newDfp("-12345678901234567891"),
1338 DfpField.FLAG_INEXACT, "Round #18");
1339
1340 test(field.newDfp("-12345678901234567891").add(field.newDfp("-0.5000")),
1341 field.newDfp("-12345678901234567891"),
1342 DfpField.FLAG_INEXACT, "Round #19");
1343
1344 field.setRoundingMode(DfpField.RoundingMode.ROUND_CEIL);
1345
1346
1347 test(field.newDfp("12345678901234567890").add(field.newDfp("0.0001")),
1348 field.newDfp("12345678901234567891"),
1349 DfpField.FLAG_INEXACT, "Round #20");
1350
1351 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.9999")),
1352 field.newDfp("-12345678901234567890"),
1353 DfpField.FLAG_INEXACT, "Round #21");
1354
1355 field.setRoundingMode(DfpField.RoundingMode.ROUND_FLOOR);
1356
1357
1358 test(field.newDfp("12345678901234567890").add(field.newDfp("0.9999")),
1359 field.newDfp("12345678901234567890"),
1360 DfpField.FLAG_INEXACT, "Round #22");
1361
1362 test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.0001")),
1363 field.newDfp("-12345678901234567891"),
1364 DfpField.FLAG_INEXACT, "Round #23");
1365
1366 field.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_EVEN);
1367 }
1368
1369 @Override
1370 @Test
1371 public void testCeil()
1372 {
1373 test(field.newDfp("1234.0000000000000001").ceil(),
1374 field.newDfp("1235"),
1375 DfpField.FLAG_INEXACT, "Ceil #1");
1376 }
1377
1378 @Test
1379 void testCeilSmallNegative()
1380 {
1381 test(field.newDfp("-0.00009999").ceil(),
1382 field.newDfp("0"),
1383 DfpField.FLAG_INEXACT, "Ceil small positive");
1384 }
1385
1386 @Test
1387 void testCeilSmallPositive()
1388 {
1389 test(field.newDfp("+0.00009999").ceil(),
1390 field.newDfp("+1"),
1391 DfpField.FLAG_INEXACT, "Ceil small positive");
1392 }
1393
1394 @Override
1395 @Test
1396 public void testFloor()
1397 {
1398 test(field.newDfp("1234.9999999999999999").floor(),
1399 field.newDfp("1234"),
1400 DfpField.FLAG_INEXACT, "Floor #1");
1401 }
1402
1403 @Test
1404 void testFloorSmallNegative()
1405 {
1406 test(field.newDfp("-0.00009999").floor(),
1407 field.newDfp("-1"),
1408 DfpField.FLAG_INEXACT, "Floor small negative");
1409 }
1410
1411 @Test
1412 void testFloorSmallPositive()
1413 {
1414 test(field.newDfp("+0.00009999").floor(),
1415 field.newDfp("0"),
1416 DfpField.FLAG_INEXACT, "Floor small positive");
1417 }
1418
1419 @Override
1420 @Test
1421 public void testRint()
1422 {
1423 test(field.newDfp("1234.50000000001").rint(),
1424 field.newDfp("1235"),
1425 DfpField.FLAG_INEXACT, "Rint #1");
1426
1427 test(field.newDfp("1234.5000").rint(),
1428 field.newDfp("1234"),
1429 DfpField.FLAG_INEXACT, "Rint #2");
1430
1431 test(field.newDfp("1235.5000").rint(),
1432 field.newDfp("1236"),
1433 DfpField.FLAG_INEXACT, "Rint #3");
1434 }
1435
1436 @Test
1437 void testCopySign()
1438 {
1439 test(Dfp.copysign(field.newDfp("1234."), field.newDfp("-1")),
1440 field.newDfp("-1234"),
1441 0, "CopySign #1");
1442
1443 test(Dfp.copysign(field.newDfp("-1234."), field.newDfp("-1")),
1444 field.newDfp("-1234"),
1445 0, "CopySign #2");
1446
1447 test(Dfp.copysign(field.newDfp("-1234."), field.newDfp("1")),
1448 field.newDfp("1234"),
1449 0, "CopySign #3");
1450
1451 test(Dfp.copysign(field.newDfp("1234."), field.newDfp("1")),
1452 field.newDfp("1234"),
1453 0, "CopySign #4");
1454 }
1455
1456 @Test
1457 void testIntValue()
1458 {
1459 assertEquals(1234, field.newDfp("1234").intValue(), "intValue #1");
1460 assertEquals(-1234, field.newDfp("-1234").intValue(), "intValue #2");
1461 assertEquals(1234, field.newDfp("1234.5").intValue(), "intValue #3");
1462 assertEquals(1235, field.newDfp("1234.500001").intValue(), "intValue #4");
1463 assertEquals(2147483647, field.newDfp("1e1000").intValue(), "intValue #5");
1464 assertEquals(-2147483648, field.newDfp("-1e1000").intValue(), "intValue #6");
1465 }
1466
1467 @Test
1468 void testLog10K()
1469 {
1470 assertEquals(1, field.newDfp("123456").log10K(), "log10K #1");
1471 assertEquals(2, field.newDfp("123456789").log10K(), "log10K #2");
1472 assertEquals(0, field.newDfp("2").log10K(), "log10K #3");
1473 assertEquals(0, field.newDfp("1").log10K(), "log10K #3");
1474 assertEquals(-1, field.newDfp("0.1").log10K(), "log10K #4");
1475 }
1476
1477 @Test
1478 void testPower10K()
1479 {
1480 Dfp d = field.newDfp();
1481
1482 test(d.power10K(0), field.newDfp("1"), 0, "Power10 #1");
1483 test(d.power10K(1), field.newDfp("10000"), 0, "Power10 #2");
1484 test(d.power10K(2), field.newDfp("100000000"), 0, "Power10 #3");
1485
1486 test(d.power10K(-1), field.newDfp("0.0001"), 0, "Power10 #4");
1487 test(d.power10K(-2), field.newDfp("0.00000001"), 0, "Power10 #5");
1488 test(d.power10K(-3), field.newDfp("0.000000000001"), 0, "Power10 #6");
1489 }
1490
1491 @Test
1492 public void testLog10()
1493 {
1494
1495 assertEquals(1, field.newDfp("12").intLog10(), "log10 #1");
1496 assertEquals(2, field.newDfp("123").intLog10(), "log10 #2");
1497 assertEquals(3, field.newDfp("1234").intLog10(), "log10 #3");
1498 assertEquals(4, field.newDfp("12345").intLog10(), "log10 #4");
1499 assertEquals(5, field.newDfp("123456").intLog10(), "log10 #5");
1500 assertEquals(6, field.newDfp("1234567").intLog10(), "log10 #6");
1501 assertEquals(7, field.newDfp("12345678").intLog10(), "log10 #6");
1502 assertEquals(8, field.newDfp("123456789").intLog10(), "log10 #7");
1503 assertEquals(9, field.newDfp("1234567890").intLog10(), "log10 #8");
1504 assertEquals(10, field.newDfp("12345678901").intLog10(), "log10 #9");
1505 assertEquals(11, field.newDfp("123456789012").intLog10(), "log10 #10");
1506 assertEquals(12, field.newDfp("1234567890123").intLog10(), "log10 #11");
1507
1508 assertEquals(0, field.newDfp("2").intLog10(), "log10 #12");
1509 assertEquals(0, field.newDfp("1").intLog10(), "log10 #13");
1510 assertEquals(-1, field.newDfp("0.12").intLog10(), "log10 #14");
1511 assertEquals(-2, field.newDfp("0.012").intLog10(), "log10 #15");
1512 }
1513
1514 @Test
1515 void testPower10()
1516 {
1517 Dfp d = field.newDfp();
1518
1519 test(d.power10(0), field.newDfp("1"), 0, "Power10 #1");
1520 test(d.power10(1), field.newDfp("10"), 0, "Power10 #2");
1521 test(d.power10(2), field.newDfp("100"), 0, "Power10 #3");
1522 test(d.power10(3), field.newDfp("1000"), 0, "Power10 #4");
1523 test(d.power10(4), field.newDfp("10000"), 0, "Power10 #5");
1524 test(d.power10(5), field.newDfp("100000"), 0, "Power10 #6");
1525 test(d.power10(6), field.newDfp("1000000"), 0, "Power10 #7");
1526 test(d.power10(7), field.newDfp("10000000"), 0, "Power10 #8");
1527 test(d.power10(8), field.newDfp("100000000"), 0, "Power10 #9");
1528 test(d.power10(9), field.newDfp("1000000000"), 0, "Power10 #10");
1529
1530 test(d.power10(-1), field.newDfp(".1"), 0, "Power10 #11");
1531 test(d.power10(-2), field.newDfp(".01"), 0, "Power10 #12");
1532 test(d.power10(-3), field.newDfp(".001"), 0, "Power10 #13");
1533 test(d.power10(-4), field.newDfp(".0001"), 0, "Power10 #14");
1534 test(d.power10(-5), field.newDfp(".00001"), 0, "Power10 #15");
1535 test(d.power10(-6), field.newDfp(".000001"), 0, "Power10 #16");
1536 test(d.power10(-7), field.newDfp(".0000001"), 0, "Power10 #17");
1537 test(d.power10(-8), field.newDfp(".00000001"), 0, "Power10 #18");
1538 test(d.power10(-9), field.newDfp(".000000001"), 0, "Power10 #19");
1539 test(d.power10(-10), field.newDfp(".0000000001"), 0, "Power10 #20");
1540 }
1541
1542 @Test
1543 void testRemainder()
1544 {
1545 test(field.newDfp("10").remainder(field.newDfp("3")),
1546 field.newDfp("1"),
1547 DfpField.FLAG_INEXACT, "Remainder #1");
1548
1549 test(field.newDfp("9").remainder(field.newDfp("3")),
1550 field.newDfp("0"),
1551 0, "Remainder #2");
1552
1553 test(field.newDfp("-9").remainder(field.newDfp("3")),
1554 field.newDfp("-0"),
1555 0, "Remainder #3");
1556 }
1557
1558 @Override
1559 @Test
1560 public void testSqrt()
1561 {
1562 test(field.newDfp("0").sqrt(),
1563 field.newDfp("0"),
1564 0, "Sqrt #1");
1565
1566 test(field.newDfp("-0").sqrt(),
1567 field.newDfp("-0"),
1568 0, "Sqrt #2");
1569
1570 test(field.newDfp("1").sqrt(),
1571 field.newDfp("1"),
1572 0, "Sqrt #3");
1573
1574 test(field.newDfp("2").sqrt(),
1575 field.newDfp("1.4142135623730950"),
1576 DfpField.FLAG_INEXACT, "Sqrt #4");
1577
1578 test(field.newDfp("3").sqrt(),
1579 field.newDfp("1.7320508075688773"),
1580 DfpField.FLAG_INEXACT, "Sqrt #5");
1581
1582 test(field.newDfp("5").sqrt(),
1583 field.newDfp("2.2360679774997897"),
1584 DfpField.FLAG_INEXACT, "Sqrt #6");
1585
1586 test(field.newDfp("500").sqrt(),
1587 field.newDfp("22.3606797749978970"),
1588 DfpField.FLAG_INEXACT, "Sqrt #6.2");
1589
1590 test(field.newDfp("50000").sqrt(),
1591 field.newDfp("223.6067977499789696"),
1592 DfpField.FLAG_INEXACT, "Sqrt #6.3");
1593
1594 test(field.newDfp("-1").sqrt(),
1595 nan,
1596 DfpField.FLAG_INVALID, "Sqrt #7");
1597
1598 test(pinf.sqrt(),
1599 pinf,
1600 0, "Sqrt #8");
1601
1602 test(field.newDfp((byte) 1, Dfp.QNAN).sqrt(),
1603 nan,
1604 0, "Sqrt #9");
1605
1606 test(field.newDfp((byte) 1, Dfp.SNAN).sqrt(),
1607 nan,
1608 DfpField.FLAG_INVALID, "Sqrt #9");
1609 }
1610
1611 @Test
1612 void testIssue567() {
1613 DfpField field = new DfpField(100);
1614 assertEquals(0.0, field.getZero().toDouble(), Precision.SAFE_MIN);
1615 assertEquals(0.0, field.newDfp(0.0).toDouble(), Precision.SAFE_MIN);
1616 assertEquals(-1, FastMath.copySign(1, field.newDfp(-0.0).toDouble()), Precision.EPSILON);
1617 assertEquals(+1, FastMath.copySign(1, field.newDfp(+0.0).toDouble()), Precision.EPSILON);
1618 }
1619
1620 @Test
1621 void testIsZero() {
1622 assertTrue(field.getZero().isZero());
1623 assertTrue(field.getZero().negate().isZero());
1624 assertTrue(field.newDfp(+0.0).isZero());
1625 assertTrue(field.newDfp(-0.0).isZero());
1626 assertFalse(field.newDfp(1.0e-90).isZero());
1627 assertFalse(nan.isZero());
1628 assertFalse(nan.negate().isZero());
1629 assertFalse(pinf.isZero());
1630 assertFalse(pinf.negate().isZero());
1631 assertFalse(ninf.isZero());
1632 assertFalse(ninf.negate().isZero());
1633 }
1634
1635 @Test
1636 void testSignPredicates() {
1637
1638 assertTrue(field.getZero().negativeOrNull());
1639 assertTrue(field.getZero().positiveOrNull());
1640 assertFalse(field.getZero().strictlyNegative());
1641 assertFalse(field.getZero().strictlyPositive());
1642
1643 assertTrue(field.getZero().negate().negativeOrNull());
1644 assertTrue(field.getZero().negate().positiveOrNull());
1645 assertFalse(field.getZero().negate().strictlyNegative());
1646 assertFalse(field.getZero().negate().strictlyPositive());
1647
1648 assertFalse(field.getOne().negativeOrNull());
1649 assertTrue(field.getOne().positiveOrNull());
1650 assertFalse(field.getOne().strictlyNegative());
1651 assertTrue(field.getOne().strictlyPositive());
1652
1653 assertTrue(field.getOne().negate().negativeOrNull());
1654 assertFalse(field.getOne().negate().positiveOrNull());
1655 assertTrue(field.getOne().negate().strictlyNegative());
1656 assertFalse(field.getOne().negate().strictlyPositive());
1657
1658 assertFalse(nan.negativeOrNull());
1659 assertFalse(nan.positiveOrNull());
1660 assertFalse(nan.strictlyNegative());
1661 assertFalse(nan.strictlyPositive());
1662
1663 assertFalse(nan.negate().negativeOrNull());
1664 assertFalse(nan.negate().positiveOrNull());
1665 assertFalse(nan.negate().strictlyNegative());
1666 assertFalse(nan.negate().strictlyPositive());
1667
1668 assertFalse(pinf.negativeOrNull());
1669 assertTrue(pinf.positiveOrNull());
1670 assertFalse(pinf.strictlyNegative());
1671 assertTrue(pinf.strictlyPositive());
1672
1673 assertTrue(pinf.negate().negativeOrNull());
1674 assertFalse(pinf.negate().positiveOrNull());
1675 assertTrue(pinf.negate().strictlyNegative());
1676 assertFalse(pinf.negate().strictlyPositive());
1677
1678 assertTrue(ninf.negativeOrNull());
1679 assertFalse(ninf.positiveOrNull());
1680 assertTrue(ninf.strictlyNegative());
1681 assertFalse(ninf.strictlyPositive());
1682
1683 assertFalse(ninf.negate().negativeOrNull());
1684 assertTrue(ninf.negate().positiveOrNull());
1685 assertFalse(ninf.negate().strictlyNegative());
1686 assertTrue(ninf.negate().strictlyPositive());
1687
1688 }
1689
1690 @Test
1691 void testSpecialConstructors() {
1692 assertEquals(ninf, field.newDfp(Double.NEGATIVE_INFINITY));
1693 assertEquals(ninf, field.newDfp("-Infinity"));
1694 assertEquals(pinf, field.newDfp(Double.POSITIVE_INFINITY));
1695 assertEquals(pinf, field.newDfp("Infinity"));
1696 assertTrue(field.newDfp(Double.NaN).isNaN());
1697 assertTrue(field.newDfp("NaN").isNaN());
1698 }
1699
1700 @Test
1701 void testHypotNoOverflow() {
1702 Dfp x = field.newDfp(+3);
1703 Dfp y = field.newDfp(-4);
1704 Dfp h = field.newDfp(+5);
1705 for (int i = 0; i < 70000; ++i) {
1706 x = x.multiply(10);
1707 y = y.multiply(10);
1708 h = h.multiply(10);
1709 }
1710 assertEquals(h, x.hypot(y));
1711 }
1712
1713 @Test
1714 void testGetExponentVsDouble() {
1715 for (int i = -1000; i < 1000; ++i) {
1716 final double x = FastMath.scalb(1.0, i);
1717 final double xMinus = 0.99 * x;
1718 final double xPlus = 1.01 * x;
1719 final Dfp dfpMinus = field.newDfp(xMinus);
1720 final Dfp dfpPlus = field.newDfp(xPlus);
1721 assertEquals(FastMath.getExponent(xMinus), dfpMinus.getExponent());
1722 assertEquals(FastMath.getExponent(xPlus), dfpPlus.getExponent());
1723 }
1724 }
1725
1726 @Test
1727 void testGetExponentSpecialCases() {
1728 assertEquals(-435412, field.newDfp(0).getExponent());
1729 assertEquals(0, field.newDfp(1).getExponent());
1730 assertEquals(1, field.newDfp(2).getExponent());
1731 assertEquals(435411, field.newDfp(Double.NaN).getExponent());
1732 assertEquals(435411, field.newDfp(Double.POSITIVE_INFINITY).getExponent());
1733 assertEquals(435411, field.newDfp(Double.NEGATIVE_INFINITY).getExponent());
1734 }
1735
1736 @Test
1737 void testGetExponentAutonomous() {
1738 for (int i = -435411; i < 435411; i += 217) {
1739 final Dfp x = field.newDfp(2).pow(i).multiply(1.1);
1740 assertEquals(i, x.getExponent());
1741 }
1742 }
1743
1744 @Test
1745 void testEqualsHashcodeContract() {
1746 DfpField var1 = new DfpField(1);
1747 Dfp var6 = var1.newDfp(-0.0d);
1748 Dfp var5 = var1.newDfp(0L);
1749
1750
1751 assertTrue(var5.equals(var6) ? var5.hashCode() == var6.hashCode() : true);
1752 }
1753
1754 @Test
1755 void testZero() {
1756 Dfp zero = new DfpField(15).getZero();
1757 assertEquals(0.0, zero.toDouble(), 1.0e-15);
1758 }
1759
1760 @Test
1761 void testOne() {
1762 Dfp one = new DfpField(15).getOne();
1763 assertEquals(1.0, one.toDouble(), 1.0e-15);
1764 }
1765
1766 @Test
1767 void testToDegreesDefinition() {
1768 double epsilon = 1.0e-14;
1769 for (int maxOrder = 0; maxOrder < 6; ++maxOrder) {
1770 for (double x = 0.1; x < 1.0; x += 0.001) {
1771 Dfp value = new Dfp(field, x);
1772 assertEquals(FastMath.toDegrees(x), value.toDegrees().getReal(), epsilon);
1773 }
1774 }
1775 }
1776
1777 @Test
1778 void testToRadiansDefinition() {
1779 double epsilon = 1.0e-15;
1780 for (int maxOrder = 0; maxOrder < 6; ++maxOrder) {
1781 for (double x = 0.1; x < 1.0; x += 0.001) {
1782 Dfp value = new Dfp(field, x);
1783 assertEquals(FastMath.toRadians(x), value.toRadians().getReal(), epsilon);
1784 }
1785 }
1786 }
1787
1788 @Test
1789 void testDegRad() {
1790 for (double x = 0.1; x < 1.2; x += 0.001) {
1791 Dfp value = field.newDfp("x");
1792 Dfp rebuilt = value.toDegrees().toRadians();
1793 Dfp zero = rebuilt.subtract(value);
1794 assertEquals(0, zero.getReal(), 3.0e-16);
1795 }
1796 }
1797
1798 @SuppressWarnings("unlikely-arg-type")
1799 @Test
1800 void testMap() {
1801 int[] decimalDigits = new int[] { 10, 50, 100 };
1802 Map<DfpField, Integer> map = new HashMap<>();
1803 for (int i = 0; i < 1000; ++i) {
1804
1805 map.put(new DfpField(decimalDigits[i % decimalDigits.length]), 0);
1806 }
1807
1808
1809
1810 assertEquals(decimalDigits.length, map.size());
1811 DfpField first = map.entrySet().iterator().next().getKey();
1812 assertEquals(first, first);
1813 assertNotEquals(first, Binary64Field.getInstance());
1814
1815 }
1816
1817 @Test
1818 void testPi() {
1819 assertEquals("3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117",
1820 new DfpField(100).newDfp(1.0).getPi().toString());
1821 }
1822
1823 @Test
1824 void testEquals() {
1825 DfpField f10A = new DfpField(10);
1826 DfpField f10B = new DfpField(10);
1827 DfpField f50 = new DfpField(50);
1828 assertNotEquals(f10A, f50);
1829 assertEquals(f10A, f10B);
1830 f10B.setRoundingMode(DfpField.RoundingMode.ROUND_DOWN);
1831 assertNotEquals(f10A, f10B);
1832 f10B.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_EVEN);
1833 assertEquals(f10A, f10B);
1834 f10B.setIEEEFlags(DfpField.FLAG_UNDERFLOW | DfpField.FLAG_OVERFLOW);
1835 assertNotEquals(f10A.getIEEEFlags(), f10B.getIEEEFlags());
1836 assertEquals(f10A, f10B);
1837 }
1838
1839 @Test
1840 void testRunTimeClass() {
1841 DfpField field = new DfpField(15);
1842 assertEquals(Dfp.class, field.getRuntimeClass());
1843 }
1844
1845 @Override
1846 @Test
1847 public void testLinearCombinationReference() {
1848 final DfpField field25 = new DfpField(25);
1849 doTestLinearCombinationReference(x -> field25.newDfp(x), 4.15e-9, 4.21e-9);
1850 }
1851
1852 @Test
1853 void testConvertToSameAccuracy() {
1854 DfpField field13 = new DfpField(13);
1855 DfpField field16 = new DfpField(16);
1856 Dfp dfp = field13.newDfp(1.25);
1857 assertSame(dfp, dfp.newInstance(field16, DfpField.RoundingMode.ROUND_HALF_EVEN));
1858 }
1859
1860 @Test
1861 void testConvertToHigherAccuracy() {
1862
1863 DfpField field16 = new DfpField(16);
1864 DfpField field24 = new DfpField(24);
1865
1866 checkConvert(field16, "1.25", field24, "1.25", null);
1867
1868 assertTrue(field16.newDfp(-1).sqrt().newInstance(field24, null).isNaN());
1869 assertTrue(field16.newDfp().reciprocal().newInstance(field24, null).isInfinite());
1870 }
1871
1872 @Test
1873 void testUlpdDfpA() {
1874 assertEquals(1.0e-36, new DfpField(40).getOne().ulp().getReal(), 1.0e-51);
1875 assertEquals(1.0e-40, new DfpField(41).getOne().ulp().getReal(), 1.0e-55);
1876 }
1877
1878 @Test
1879 void testUlpdDfpB() {
1880 DfpField field = new DfpField(41);
1881 Dfp one = field.getOne();
1882 Dfp ulp = one.ulp();
1883 assertTrue(one.add(ulp).greaterThan(one));
1884 assertFalse(one.add(ulp.divide(2)).greaterThan(one));
1885 }
1886
1887 @Test
1888 void testConvertToLowerAccuracy() {
1889 DfpField field16 = new DfpField(16);
1890 DfpField field24 = new DfpField(24);
1891
1892 checkConvert(field24, "1234.56789012345678901234", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_DOWN);
1893 checkConvert(field24, "1234.56789012345678901234", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_UP);
1894 checkConvert(field24, "1234.56789012345678901234", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_UP);
1895 checkConvert(field24, "1234.56789012345678901234", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_DOWN);
1896 checkConvert(field24, "1234.56789012345678901234", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_EVEN);
1897 checkConvert(field24, "1234.56789012345678901234", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_ODD);
1898 checkConvert(field24, "1234.56789012345678901234", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_CEIL);
1899 checkConvert(field24, "1234.56789012345678901234", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_FLOOR);
1900
1901 checkConvert(field24, "1234.56789012345600000001", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_DOWN);
1902 checkConvert(field24, "1234.56789012345600000001", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_UP);
1903 checkConvert(field24, "1234.56789012345600000001", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_HALF_UP);
1904 checkConvert(field24, "1234.56789012345600000001", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_HALF_DOWN);
1905 checkConvert(field24, "1234.56789012345600000001", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_HALF_EVEN);
1906 checkConvert(field24, "1234.56789012345600000001", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_HALF_ODD);
1907 checkConvert(field24, "1234.56789012345600000001", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_CEIL);
1908 checkConvert(field24, "1234.56789012345600000001", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_FLOOR);
1909
1910 checkConvert(field24, "1234.56789012345650000000", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_DOWN);
1911 checkConvert(field24, "1234.56789012345650000000", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_UP);
1912 checkConvert(field24, "1234.56789012345650000000", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_UP);
1913 checkConvert(field24, "1234.56789012345650000000", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_HALF_DOWN);
1914 checkConvert(field24, "1234.56789012345650000000", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_HALF_EVEN);
1915 checkConvert(field24, "1234.56789012345650000000", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_ODD);
1916 checkConvert(field24, "1234.56789012345650000000", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_CEIL);
1917 checkConvert(field24, "1234.56789012345650000000", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_FLOOR);
1918
1919 checkConvert(field24, "1234.56789012345650000001", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_DOWN);
1920 checkConvert(field24, "1234.56789012345650000001", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_UP);
1921 checkConvert(field24, "1234.56789012345650000001", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_UP);
1922 checkConvert(field24, "1234.56789012345650000001", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_DOWN);
1923 checkConvert(field24, "1234.56789012345650000001", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_EVEN);
1924 checkConvert(field24, "1234.56789012345650000001", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_ODD);
1925 checkConvert(field24, "1234.56789012345650000001", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_CEIL);
1926 checkConvert(field24, "1234.56789012345650000001", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_FLOOR);
1927
1928 checkConvert(field24, "1234.56789012345750000000", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_DOWN);
1929 checkConvert(field24, "1234.56789012345750000000", field16, "1234.567890123458", DfpField.RoundingMode.ROUND_UP);
1930 checkConvert(field24, "1234.56789012345750000000", field16, "1234.567890123458", DfpField.RoundingMode.ROUND_HALF_UP);
1931 checkConvert(field24, "1234.56789012345750000000", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_DOWN);
1932 checkConvert(field24, "1234.56789012345750000000", field16, "1234.567890123458", DfpField.RoundingMode.ROUND_HALF_EVEN);
1933 checkConvert(field24, "1234.56789012345750000000", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_ODD);
1934 checkConvert(field24, "1234.56789012345750000000", field16, "1234.567890123458", DfpField.RoundingMode.ROUND_CEIL);
1935 checkConvert(field24, "1234.56789012345750000000", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_FLOOR);
1936
1937 checkConvert(field24, "1234.56789012345750000001", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_DOWN);
1938 checkConvert(field24, "1234.56789012345750000001", field16, "1234.567890123458", DfpField.RoundingMode.ROUND_UP);
1939 checkConvert(field24, "1234.56789012345750000001", field16, "1234.567890123458", DfpField.RoundingMode.ROUND_HALF_UP);
1940 checkConvert(field24, "1234.56789012345750000001", field16, "1234.567890123458", DfpField.RoundingMode.ROUND_HALF_DOWN);
1941 checkConvert(field24, "1234.56789012345750000001", field16, "1234.567890123458", DfpField.RoundingMode.ROUND_HALF_EVEN);
1942 checkConvert(field24, "1234.56789012345750000001", field16, "1234.567890123458", DfpField.RoundingMode.ROUND_HALF_ODD);
1943 checkConvert(field24, "1234.56789012345750000001", field16, "1234.567890123458", DfpField.RoundingMode.ROUND_CEIL);
1944 checkConvert(field24, "1234.56789012345750000001", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_FLOOR);
1945
1946 checkConvert(field24, "-1234.56789012345678901234", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_DOWN);
1947 checkConvert(field24, "-1234.56789012345678901234", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_UP);
1948 checkConvert(field24, "-1234.56789012345678901234", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_HALF_UP);
1949 checkConvert(field24, "-1234.56789012345678901234", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_HALF_DOWN);
1950 checkConvert(field24, "-1234.56789012345678901234", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_HALF_EVEN);
1951 checkConvert(field24, "-1234.56789012345678901234", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_HALF_ODD);
1952 checkConvert(field24, "-1234.56789012345678901234", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_CEIL);
1953 checkConvert(field24, "-1234.56789012345678901234", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_FLOOR);
1954
1955 checkConvert(field24, "-1234.56789012345600000001", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_DOWN);
1956 checkConvert(field24, "-1234.56789012345600000001", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_UP);
1957 checkConvert(field24, "-1234.56789012345600000001", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_HALF_UP);
1958 checkConvert(field24, "-1234.56789012345600000001", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_HALF_DOWN);
1959 checkConvert(field24, "-1234.56789012345600000001", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_HALF_EVEN);
1960 checkConvert(field24, "-1234.56789012345600000001", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_HALF_ODD);
1961 checkConvert(field24, "-1234.56789012345600000001", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_CEIL);
1962 checkConvert(field24, "-1234.56789012345600000001", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_FLOOR);
1963
1964 checkConvert(field24, "-1234.56789012345650000000", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_DOWN);
1965 checkConvert(field24, "-1234.56789012345650000000", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_UP);
1966 checkConvert(field24, "-1234.56789012345650000000", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_HALF_UP);
1967 checkConvert(field24, "-1234.56789012345650000000", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_HALF_DOWN);
1968 checkConvert(field24, "-1234.56789012345650000000", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_HALF_EVEN);
1969 checkConvert(field24, "-1234.56789012345650000000", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_HALF_ODD);
1970 checkConvert(field24, "-1234.56789012345650000000", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_CEIL);
1971 checkConvert(field24, "-1234.56789012345650000000", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_FLOOR);
1972
1973 checkConvert(field24, "-1234.56789012345650000001", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_DOWN);
1974 checkConvert(field24, "-1234.56789012345650000001", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_UP);
1975 checkConvert(field24, "-1234.56789012345650000001", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_HALF_UP);
1976 checkConvert(field24, "-1234.56789012345650000001", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_HALF_DOWN);
1977 checkConvert(field24, "-1234.56789012345650000001", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_HALF_EVEN);
1978 checkConvert(field24, "-1234.56789012345650000001", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_HALF_ODD);
1979 checkConvert(field24, "-1234.56789012345650000001", field16, "-1234.567890123456", DfpField.RoundingMode.ROUND_CEIL);
1980 checkConvert(field24, "-1234.56789012345650000001", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_FLOOR);
1981
1982 checkConvert(field24, "-1234.56789012345750000000", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_DOWN);
1983 checkConvert(field24, "-1234.56789012345750000000", field16, "-1234.567890123458", DfpField.RoundingMode.ROUND_UP);
1984 checkConvert(field24, "-1234.56789012345750000000", field16, "-1234.567890123458", DfpField.RoundingMode.ROUND_HALF_UP);
1985 checkConvert(field24, "-1234.56789012345750000000", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_HALF_DOWN);
1986 checkConvert(field24, "-1234.56789012345750000000", field16, "-1234.567890123458", DfpField.RoundingMode.ROUND_HALF_EVEN);
1987 checkConvert(field24, "-1234.56789012345750000000", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_HALF_ODD);
1988 checkConvert(field24, "-1234.56789012345750000000", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_CEIL);
1989 checkConvert(field24, "-1234.56789012345750000000", field16, "-1234.567890123458", DfpField.RoundingMode.ROUND_FLOOR);
1990
1991 checkConvert(field24, "-1234.56789012345750000001", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_DOWN);
1992 checkConvert(field24, "-1234.56789012345750000001", field16, "-1234.567890123458", DfpField.RoundingMode.ROUND_UP);
1993 checkConvert(field24, "-1234.56789012345750000001", field16, "-1234.567890123458", DfpField.RoundingMode.ROUND_HALF_UP);
1994 checkConvert(field24, "-1234.56789012345750000001", field16, "-1234.567890123458", DfpField.RoundingMode.ROUND_HALF_DOWN);
1995 checkConvert(field24, "-1234.56789012345750000001", field16, "-1234.567890123458", DfpField.RoundingMode.ROUND_HALF_EVEN);
1996 checkConvert(field24, "-1234.56789012345750000001", field16, "-1234.567890123458", DfpField.RoundingMode.ROUND_HALF_ODD);
1997 checkConvert(field24, "-1234.56789012345750000001", field16, "-1234.567890123457", DfpField.RoundingMode.ROUND_CEIL);
1998 checkConvert(field24, "-1234.56789012345750000001", field16, "-1234.567890123458", DfpField.RoundingMode.ROUND_FLOOR);
1999
2000 checkConvert(field24, "1234.56789012345650000001", field16, "1234.567890123457", DfpField.RoundingMode.ROUND_HALF_EVEN);
2001 checkConvert(field24, "1234.56789012345600000000", field16, "1234.567890123456", DfpField.RoundingMode.ROUND_HALF_EVEN);
2002 checkConvert(field24, "9999.99999999999950000000", field16, "10000.", DfpField.RoundingMode.ROUND_HALF_EVEN);
2003 checkConvert(field24, "9999.99999999999950000000", field16, "9999.999999999999", DfpField.RoundingMode.ROUND_HALF_ODD);
2004 checkConvert(field24, "9999.99999999999950000001", field16, "10000.", DfpField.RoundingMode.ROUND_HALF_ODD);
2005
2006 assertTrue(field24.newDfp(-1).sqrt().newInstance(field16, DfpField.RoundingMode.ROUND_HALF_EVEN).isNaN());
2007 assertTrue(field24.newDfp().reciprocal().newInstance(field16, DfpField.RoundingMode.ROUND_HALF_EVEN).isInfinite());
2008
2009 }
2010
2011 private void checkConvert(DfpField originalField, String originalValue,
2012 DfpField targetField, String targetValue,
2013 DfpField.RoundingMode rmode) {
2014 Dfp original = originalField.newDfp(originalValue);
2015 Dfp converted = original.newInstance(targetField, rmode);
2016 assertEquals(targetValue, converted.toString());
2017 }
2018
2019 }