View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
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          // Some basic setup.  Define some constants and clear the status flags
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      // Generic test function.  Takes params x and y and tests them for
65      // equality.  Then checks the status flags against the flags argument.
66      // If the test fail, it prints the desc string
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)) { // NaNs involved
71              b = x.toString().equals(y.toString());
72          }
73  
74          if (x.equals(field.newDfp("0"))) { // distinguish +/- zero
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      *  Test addition
121      */
122     @Test
123     public void testAdd() {
124         test(field.newDfp("1").add(field.newDfp("1")),      // Basic tests   1+1 = 2
125              field.newDfp("2"),
126              0, "Add #1");
127 
128         test(field.newDfp("1").add(field.newDfp("-1")),     // 1 + (-1) = 0
129              field.newDfp("0"),
130              0, "Add #2");
131 
132         test(field.newDfp("-1").add(field.newDfp("1")),     // (-1) + 1 = 0
133              field.newDfp("0"),
134              0, "Add #3");
135 
136         test(field.newDfp("-1").add(field.newDfp("-1")),     // (-1) + (-1) = -2
137              field.newDfp("-2"),
138              0, "Add #4");
139 
140         // rounding mode is round half even
141 
142         test(field.newDfp("1").add(field.newDfp("1e-16")),     // rounding on add
143              field.newDfp("1.0000000000000001"),
144              0, "Add #5");
145 
146         test(field.newDfp("1").add(field.newDfp("1e-17")),     // rounding on add
147              field.newDfp("1"),
148              DfpField.FLAG_INEXACT, "Add #6");
149 
150         test(field.newDfp("0.90999999999999999999").add(field.newDfp("0.1")),     // rounding on add
151              field.newDfp("1.01"),
152              DfpField.FLAG_INEXACT, "Add #7");
153 
154         test(field.newDfp(".10000000000000005000").add(field.newDfp(".9")),     // rounding on add
155              field.newDfp("1."),
156              DfpField.FLAG_INEXACT, "Add #8");
157 
158         test(field.newDfp(".10000000000000015000").add(field.newDfp(".9")),     // rounding on add
159              field.newDfp("1.0000000000000002"),
160              DfpField.FLAG_INEXACT, "Add #9");
161 
162         test(field.newDfp(".10000000000000014999").add(field.newDfp(".9")),     // rounding on add
163              field.newDfp("1.0000000000000001"),
164              DfpField.FLAG_INEXACT, "Add #10");
165 
166         test(field.newDfp(".10000000000000015001").add(field.newDfp(".9")),     // rounding on add
167              field.newDfp("1.0000000000000002"),
168              DfpField.FLAG_INEXACT, "Add #11");
169 
170         test(field.newDfp(".11111111111111111111").add(field.newDfp("11.1111111111111111")), // rounding on add
171              field.newDfp("11.22222222222222222222"),
172              DfpField.FLAG_INEXACT, "Add #12");
173 
174         test(field.newDfp(".11111111111111111111").add(field.newDfp("1111111111111111.1111")), // rounding on add
175              field.newDfp("1111111111111111.2222"),
176              DfpField.FLAG_INEXACT, "Add #13");
177 
178         test(field.newDfp(".11111111111111111111").add(field.newDfp("11111111111111111111")), // rounding on add
179              field.newDfp("11111111111111111111"),
180              DfpField.FLAG_INEXACT, "Add #14");
181 
182         test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("-1e131052")), // overflow on add
183              field.newDfp("9.9999999999999999998e131071"),
184              0, "Add #15");
185 
186         test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("1e131052")), // overflow on add
187              pinf,
188              DfpField.FLAG_OVERFLOW, "Add #16");
189 
190         test(field.newDfp("-9.9999999999999999999e131071").add(field.newDfp("-1e131052")), // overflow on add
191              ninf,
192              DfpField.FLAG_OVERFLOW, "Add #17");
193 
194         test(field.newDfp("-9.9999999999999999999e131071").add(field.newDfp("1e131052")), // overflow on add
195              field.newDfp("-9.9999999999999999998e131071"),
196              0, "Add #18");
197 
198         test(field.newDfp("1e-131072").add(field.newDfp("1e-131072")), // underflow on add
199              field.newDfp("2e-131072"),
200              0, "Add #19");
201 
202         test(field.newDfp("1.0000000000000001e-131057").add(field.newDfp("-1e-131057")), // underflow on add
203              field.newDfp("1e-131073"),
204              DfpField.FLAG_UNDERFLOW, "Add #20");
205 
206         test(field.newDfp("1.1e-131072").add(field.newDfp("-1e-131072")), // underflow on add
207              field.newDfp("1e-131073"),
208              DfpField.FLAG_UNDERFLOW, "Add #21");
209 
210         test(field.newDfp("1.0000000000000001e-131072").add(field.newDfp("-1e-131072")), // underflow on add
211              field.newDfp("1e-131088"),
212              DfpField.FLAG_UNDERFLOW, "Add #22");
213 
214         test(field.newDfp("1.0000000000000001e-131078").add(field.newDfp("-1e-131078")), // underflow on add
215              field.newDfp("0"),
216              DfpField.FLAG_UNDERFLOW, "Add #23");
217 
218         test(field.newDfp("1.0").add(field.newDfp("-1e-20")), // loss of precision on alignment?
219              field.newDfp("0.99999999999999999999"),
220              0, "Add #23.1");
221 
222         test(field.newDfp("-0.99999999999999999999").add(field.newDfp("1")), // proper normalization?
223              field.newDfp("0.00000000000000000001"),
224              0, "Add #23.2");
225 
226         test(field.newDfp("1").add(field.newDfp("0")), // adding zeros
227              field.newDfp("1"),
228              0, "Add #24");
229 
230         test(field.newDfp("0").add(field.newDfp("0")), // adding zeros
231              field.newDfp("0"),
232              0, "Add #25");
233 
234         test(field.newDfp("-0").add(field.newDfp("0")), // adding zeros
235              field.newDfp("0"),
236              0, "Add #26");
237 
238         test(field.newDfp("0").add(field.newDfp("-0")), // adding zeros
239              field.newDfp("0"),
240              0, "Add #27");
241 
242         test(field.newDfp("-0").add(field.newDfp("-0")), // adding zeros
243              field.newDfp("-0"),
244              0, "Add #28");
245 
246         test(field.newDfp("1e-20").add(field.newDfp("0")), // adding zeros
247              field.newDfp("1e-20"),
248              0, "Add #29");
249 
250         test(field.newDfp("1e-40").add(field.newDfp("0")), // adding zeros
251              field.newDfp("1e-40"),
252              0, "Add #30");
253 
254         test(pinf.add(ninf), // adding infinities
255              nan,
256              DfpField.FLAG_INVALID, "Add #31");
257 
258         test(ninf.add(pinf), // adding infinities
259              nan,
260              DfpField.FLAG_INVALID, "Add #32");
261 
262         test(ninf.add(ninf), // adding infinities
263              ninf,
264              0, "Add #33");
265 
266         test(pinf.add(pinf), // adding infinities
267              pinf,
268              0, "Add #34");
269 
270         test(pinf.add(field.newDfp("0")), // adding infinities
271              pinf,
272              0, "Add #35");
273 
274         test(pinf.add(field.newDfp("-1e131071")), // adding infinities
275              pinf,
276              0, "Add #36");
277 
278         test(pinf.add(field.newDfp("1e131071")), // adding infinities
279              pinf,
280              0, "Add #37");
281 
282         test(field.newDfp("0").add(pinf), // adding infinities
283              pinf,
284              0, "Add #38");
285 
286         test(field.newDfp("-1e131071").add(pinf), // adding infinities
287              pinf,
288              0, "Add #39");
289 
290         test(field.newDfp("1e131071").add(pinf), // adding infinities
291              pinf,
292              0, "Add #40");
293 
294         test(ninf.add(field.newDfp("0")), // adding infinities
295              ninf,
296              0, "Add #41");
297 
298         test(ninf.add(field.newDfp("-1e131071")), // adding infinities
299              ninf,
300              0, "Add #42");
301 
302         test(ninf.add(field.newDfp("1e131071")), // adding infinities
303              ninf,
304              0, "Add #43");
305 
306         test(field.newDfp("0").add(ninf), // adding infinities
307              ninf,
308              0, "Add #44");
309 
310         test(field.newDfp("-1e131071").add(ninf), // adding infinities
311              ninf,
312              0, "Add #45");
313 
314         test(field.newDfp("1e131071").add(ninf), // adding infinities
315              ninf,
316              0, "Add #46");
317 
318         test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("5e131051")),  // overflow
319              pinf,
320              DfpField.FLAG_OVERFLOW, "Add #47");
321 
322         test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("4.9999999999999999999e131051")),  // overflow
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     // Test comparisons
374 
375     // utility function to help test comparisons
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         // test equal() comparison
405         // check zero vs. zero
406         field.clearIEEEFlags();
407 
408         cmptst(field.newDfp("0"), field.newDfp("0"), "equal", true, 1);         // 0 == 0
409         cmptst(field.newDfp("0"), field.newDfp("-0"), "equal", true, 2);        // 0 == -0
410         cmptst(field.newDfp("-0"), field.newDfp("-0"), "equal", true, 3);       // -0 == -0
411         cmptst(field.newDfp("-0"), field.newDfp("0"), "equal", true, 4);        // -0 == 0
412 
413         // check zero vs normal numbers
414 
415         cmptst(field.newDfp("0"), field.newDfp("1"), "equal", false, 5);         // 0 == 1
416         cmptst(field.newDfp("1"), field.newDfp("0"), "equal", false, 6);         // 1 == 0
417         cmptst(field.newDfp("-1"), field.newDfp("0"), "equal", false, 7);        // -1 == 0
418         cmptst(field.newDfp("0"), field.newDfp("-1"), "equal", false, 8);        // 0 == -1
419         cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "equal", false, 9); // 0 == 1e-131072
420         // check flags
421         if (field.getIEEEFlags() != 0) {
422             assertionFailDfpField(field);
423         }
424 
425         cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "equal", false, 10); // 0 == 1e-131078
426 
427         // check flags  -- underflow should be set
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); // 0 == 1e+131071
435 
436         // check zero vs infinities
437 
438         cmptst(field.newDfp("0"), pinf, "equal", false, 12);    // 0 == pinf
439         cmptst(field.newDfp("0"), ninf, "equal", false, 13);    // 0 == ninf
440         cmptst(field.newDfp("-0"), pinf, "equal", false, 14);   // -0 == pinf
441         cmptst(field.newDfp("-0"), ninf, "equal", false, 15);   // -0 == ninf
442         cmptst(pinf, field.newDfp("0"), "equal", false, 16);    // pinf == 0
443         cmptst(ninf, field.newDfp("0"), "equal", false, 17);    // ninf == 0
444         cmptst(pinf, field.newDfp("-0"), "equal", false, 18);   // pinf == -0
445         cmptst(ninf, field.newDfp("-0"), "equal", false, 19);   // ninf == -0
446         cmptst(ninf, pinf, "equal", false, 19.10);     // ninf == pinf
447         cmptst(pinf, ninf, "equal", false, 19.11);     // pinf == ninf
448         cmptst(pinf, pinf, "equal", true, 19.12);     // pinf == pinf
449         cmptst(ninf, ninf, "equal", true, 19.13);     // ninf == ninf
450 
451         // check some normal numbers
452         cmptst(field.newDfp("1"), field.newDfp("1"), "equal", true, 20);   // 1 == 1
453         cmptst(field.newDfp("1"), field.newDfp("-1"), "equal", false, 21);   // 1 == -1
454         cmptst(field.newDfp("-1"), field.newDfp("-1"), "equal", true, 22);   // -1 == -1
455         cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "equal", false, 23);   // 1 == 1.0000000000000001
456 
457         // The tests below checks to ensure that comparisons don't set FLAG_INEXACT
458         // 100000 == 1.0000000000000001
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         // check some nans -- nans shouldn't equal anything
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         // Tests for un equal  -- do it all over again
497         //
498 
499         cmptst(field.newDfp("0"), field.newDfp("0"), "unequal", false, 1);         // 0 == 0
500         cmptst(field.newDfp("0"), field.newDfp("-0"), "unequal", false, 2);        // 0 == -0
501         cmptst(field.newDfp("-0"), field.newDfp("-0"), "unequal", false, 3);       // -0 == -0
502         cmptst(field.newDfp("-0"), field.newDfp("0"), "unequal", false, 4);        // -0 == 0
503 
504         // check zero vs normal numbers
505 
506         cmptst(field.newDfp("0"), field.newDfp("1"), "unequal", true, 5);         // 0 == 1
507         cmptst(field.newDfp("1"), field.newDfp("0"), "unequal", true, 6);         // 1 == 0
508         cmptst(field.newDfp("-1"), field.newDfp("0"), "unequal", true, 7);        // -1 == 0
509         cmptst(field.newDfp("0"), field.newDfp("-1"), "unequal", true, 8);        // 0 == -1
510         cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "unequal", true, 9); // 0 == 1e-131072
511         // check flags
512         if (field.getIEEEFlags() != 0) {
513             assertionFailDfpField(field);
514         }
515 
516         cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "unequal", true, 10); // 0 == 1e-131078
517 
518         // check flags  -- underflow should be set
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); // 0 == 1e+131071
526 
527         // check zero vs infinities
528 
529         cmptst(field.newDfp("0"), pinf, "unequal", true, 12);    // 0 == pinf
530         cmptst(field.newDfp("0"), ninf, "unequal", true, 13);    // 0 == ninf
531         cmptst(field.newDfp("-0"), pinf, "unequal", true, 14);   // -0 == pinf
532         cmptst(field.newDfp("-0"), ninf, "unequal", true, 15);   // -0 == ninf
533         cmptst(pinf, field.newDfp("0"), "unequal", true, 16);    // pinf == 0
534         cmptst(ninf, field.newDfp("0"), "unequal", true, 17);    // ninf == 0
535         cmptst(pinf, field.newDfp("-0"), "unequal", true, 18);   // pinf == -0
536         cmptst(ninf, field.newDfp("-0"), "unequal", true, 19);   // ninf == -0
537         cmptst(ninf, pinf, "unequal", true, 19.10);     // ninf == pinf
538         cmptst(pinf, ninf, "unequal", true, 19.11);     // pinf == ninf
539         cmptst(pinf, pinf, "unequal", false, 19.12);     // pinf == pinf
540         cmptst(ninf, ninf, "unequal", false, 19.13);     // ninf == ninf
541 
542         // check some normal numbers
543         cmptst(field.newDfp("1"), field.newDfp("1"), "unequal", false, 20);   // 1 == 1
544         cmptst(field.newDfp("1"), field.newDfp("-1"), "unequal", true, 21);   // 1 == -1
545         cmptst(field.newDfp("-1"), field.newDfp("-1"), "unequal", false, 22);   // -1 == -1
546         cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "unequal", true, 23);   // 1 == 1.0000000000000001
547 
548         // The tests below checks to ensure that comparisons don't set FLAG_INEXACT
549         // 100000 == 1.0000000000000001
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         // check some nans -- nans shouldn't be unequal to anything
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         // Tests for lessThan  -- do it all over again
592         //
593 
594         cmptst(field.newDfp("0"), field.newDfp("0"), "lessThan", false, 1);         // 0 < 0
595         cmptst(field.newDfp("0"), field.newDfp("-0"), "lessThan", false, 2);        // 0 < -0
596         cmptst(field.newDfp("-0"), field.newDfp("-0"), "lessThan", false, 3);       // -0 < -0
597         cmptst(field.newDfp("-0"), field.newDfp("0"), "lessThan", false, 4);        // -0 < 0
598 
599         // check zero vs normal numbers
600 
601         cmptst(field.newDfp("0"), field.newDfp("1"), "lessThan", true, 5);         // 0 < 1
602         cmptst(field.newDfp("1"), field.newDfp("0"), "lessThan", false, 6);         // 1 < 0
603         cmptst(field.newDfp("-1"), field.newDfp("0"), "lessThan", true, 7);        // -1 < 0
604         cmptst(field.newDfp("0"), field.newDfp("-1"), "lessThan", false, 8);        // 0 < -1
605         cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "lessThan", true, 9); // 0 < 1e-131072
606         // check flags
607         if (field.getIEEEFlags() != 0) {
608             assertionFailDfpField(field);
609         }
610 
611         cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "lessThan", true, 10); // 0 < 1e-131078
612 
613         // check flags  -- underflow should be set
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); // 0 < 1e+131071
620 
621         // check zero vs infinities
622 
623         cmptst(field.newDfp("0"), pinf, "lessThan", true, 12);    // 0 < pinf
624         cmptst(field.newDfp("0"), ninf, "lessThan", false, 13);    // 0 < ninf
625         cmptst(field.newDfp("-0"), pinf, "lessThan", true, 14);   // -0 < pinf
626         cmptst(field.newDfp("-0"), ninf, "lessThan", false, 15);   // -0 < ninf
627         cmptst(pinf, field.newDfp("0"), "lessThan", false, 16);    // pinf < 0
628         cmptst(ninf, field.newDfp("0"), "lessThan", true, 17);    // ninf < 0
629         cmptst(pinf, field.newDfp("-0"), "lessThan", false, 18);   // pinf < -0
630         cmptst(ninf, field.newDfp("-0"), "lessThan", true, 19);   // ninf < -0
631         cmptst(ninf, pinf, "lessThan", true, 19.10);     // ninf < pinf
632         cmptst(pinf, ninf, "lessThan", false, 19.11);     // pinf < ninf
633         cmptst(pinf, pinf, "lessThan", false, 19.12);     // pinf < pinf
634         cmptst(ninf, ninf, "lessThan", false, 19.13);     // ninf < ninf
635 
636         // check some normal numbers
637         cmptst(field.newDfp("1"), field.newDfp("1"), "lessThan", false, 20);   // 1 < 1
638         cmptst(field.newDfp("1"), field.newDfp("-1"), "lessThan", false, 21);   // 1 < -1
639         cmptst(field.newDfp("-1"), field.newDfp("-1"), "lessThan", false, 22);   // -1 < -1
640         cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "lessThan", true, 23);   // 1 < 1.0000000000000001
641 
642         // The tests below checks to ensure that comparisons don't set FLAG_INEXACT
643         // 100000 < 1.0000000000000001
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         // check some nans -- nans shouldn't be lessThan to anything
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         //lessThan compares with nans should raise FLAG_INVALID
680         if (field.getIEEEFlags() != DfpField.FLAG_INVALID) {
681             assertionFail("compare lessThan flags = " + field.getIEEEFlags());
682         }
683         field.clearIEEEFlags();
684 
685         //
686         // Tests for greaterThan  -- do it all over again
687         //
688 
689         cmptst(field.newDfp("0"), field.newDfp("0"), "greaterThan", false, 1);         // 0 > 0
690         cmptst(field.newDfp("0"), field.newDfp("-0"), "greaterThan", false, 2);        // 0 > -0
691         cmptst(field.newDfp("-0"), field.newDfp("-0"), "greaterThan", false, 3);       // -0 > -0
692         cmptst(field.newDfp("-0"), field.newDfp("0"), "greaterThan", false, 4);        // -0 > 0
693 
694         // check zero vs normal numbers
695 
696         cmptst(field.newDfp("0"), field.newDfp("1"), "greaterThan", false, 5);         // 0 > 1
697         cmptst(field.newDfp("1"), field.newDfp("0"), "greaterThan", true, 6);         // 1 > 0
698         cmptst(field.newDfp("-1"), field.newDfp("0"), "greaterThan", false, 7);        // -1 > 0
699         cmptst(field.newDfp("0"), field.newDfp("-1"), "greaterThan", true, 8);        // 0 > -1
700         cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "greaterThan", false, 9); // 0 > 1e-131072
701         // check flags
702         if (field.getIEEEFlags() != 0) {
703             assertionFailDfpField(field);
704         }
705 
706         cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "greaterThan", false, 10); // 0 > 1e-131078
707 
708         // check flags  -- underflow should be set
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); // 0 > 1e+131071
715 
716         // check zero vs infinities
717 
718         cmptst(field.newDfp("0"), pinf, "greaterThan", false, 12);    // 0 > pinf
719         cmptst(field.newDfp("0"), ninf, "greaterThan", true, 13);    // 0 > ninf
720         cmptst(field.newDfp("-0"), pinf, "greaterThan", false, 14);   // -0 > pinf
721         cmptst(field.newDfp("-0"), ninf, "greaterThan", true, 15);   // -0 > ninf
722         cmptst(pinf, field.newDfp("0"), "greaterThan", true, 16);    // pinf > 0
723         cmptst(ninf, field.newDfp("0"), "greaterThan", false, 17);    // ninf > 0
724         cmptst(pinf, field.newDfp("-0"), "greaterThan", true, 18);   // pinf > -0
725         cmptst(ninf, field.newDfp("-0"), "greaterThan", false, 19);   // ninf > -0
726         cmptst(ninf, pinf, "greaterThan", false, 19.10);     // ninf > pinf
727         cmptst(pinf, ninf, "greaterThan", true, 19.11);     // pinf > ninf
728         cmptst(pinf, pinf, "greaterThan", false, 19.12);     // pinf > pinf
729         cmptst(ninf, ninf, "greaterThan", false, 19.13);     // ninf > ninf
730 
731         // check some normal numbers
732         cmptst(field.newDfp("1"), field.newDfp("1"), "greaterThan", false, 20);   // 1 > 1
733         cmptst(field.newDfp("1"), field.newDfp("-1"), "greaterThan", true, 21);   // 1 > -1
734         cmptst(field.newDfp("-1"), field.newDfp("-1"), "greaterThan", false, 22);   // -1 > -1
735         cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "greaterThan", false, 23);   // 1 > 1.0000000000000001
736 
737         // The tests below checks to ensure that comparisons don't set FLAG_INEXACT
738         // 100000 > 1.0000000000000001
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         // check some nans -- nans shouldn't be greaterThan to anything
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         // greaterThan compares with nans should raise FLAG_INVALID
775         if (field.getIEEEFlags() != DfpField.FLAG_INVALID) {
776             assertionFail("compare greaterThan flags = " + field.getIEEEFlags());
777         }
778         field.clearIEEEFlags();
779     }
780 
781     //
782     // Test multiplication
783     //
784     @Test
785     public void testMultiply() {
786         test(field.newDfp("1").multiply(field.newDfp("1")),      // Basic tests   1*1 = 1
787              field.newDfp("1"),
788              0, "Multiply #1");
789 
790         test(field.newDfp("1").multiply(1),             // Basic tests   1*1 = 1
791              field.newDfp("1"),
792              0, "Multiply #2");
793 
794         test(field.newDfp("-1").multiply(field.newDfp("1")),     // Basic tests   -1*1 = -1
795              field.newDfp("-1"),
796              0, "Multiply #3");
797 
798         test(field.newDfp("-1").multiply(1),            // Basic tests   -1*1 = -1
799              field.newDfp("-1"),
800              0, "Multiply #4");
801 
802         // basic tests with integers
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         //multiply by zero
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),      // divide by NaN = NaN
953              nan,
954              0, "Divide #1");
955 
956         test(nan.divide(field.newDfp("1")),      // NaN / number = NaN
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")),     // test trial-divisor too high
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),      // NaN / number = NaN
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         // Round down
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         // Round up
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         // Round half up
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         // Round half down
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         // Round half odd
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         // Round ceil
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         // Round floor
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);  // reset
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         // Checks the contract:  equals-hash code on var5 and var6
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 }