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    *      https://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  /*
19   * This is not the original file distributed by the Apache Software Foundation
20   * It has been modified by the Hipparchus project
21   */
22  package org.hipparchus.util;
23  
24  import org.hipparchus.CalculusFieldElementAbstractTest;
25  import org.junit.jupiter.api.Test;
26  
27  import static org.junit.jupiter.api.Assertions.assertEquals;
28  import static org.junit.jupiter.api.Assertions.assertFalse;
29  import static org.junit.jupiter.api.Assertions.assertNotEquals;
30  import static org.junit.jupiter.api.Assertions.assertTrue;
31  
32  public class Binary64Test extends CalculusFieldElementAbstractTest<Binary64> {
33      public static final double X = 1.2345;
34  
35      public static final Binary64 PLUS_X = new Binary64(X);
36  
37      public static final Binary64 MINUS_X = new Binary64(-X);
38  
39      public static final double Y = 6.789;
40  
41      public static final Binary64 PLUS_Y = new Binary64(Y);
42  
43      public static final Binary64 MINUS_Y = new Binary64(-Y);
44  
45      public static final Binary64 PLUS_ZERO = new Binary64(0.0);
46  
47      public static final Binary64 MINUS_ZERO = new Binary64(-0.0);
48  
49      @Override
50      protected Binary64 build(final double x) {
51          return new Binary64(x);
52      }
53  
54      @Test
55      void testAdd() {
56          Binary64 expected, actual;
57  
58          expected = new Binary64(X + Y);
59          actual = PLUS_X.add(PLUS_Y);
60          assertEquals(expected, actual);
61          actual = PLUS_Y.add(PLUS_X);
62          assertEquals(expected, actual);
63  
64          expected = new Binary64(X + (-Y));
65          actual = PLUS_X.add(MINUS_Y);
66          assertEquals(expected, actual);
67          actual = MINUS_Y.add(PLUS_X);
68          assertEquals(expected, actual);
69  
70          expected = new Binary64((-X) + (-Y));
71          actual = MINUS_X.add(MINUS_Y);
72          assertEquals(expected, actual);
73          actual = MINUS_Y.add(MINUS_X);
74          assertEquals(expected, actual);
75  
76          expected = Binary64.POSITIVE_INFINITY;
77          actual = PLUS_X.add(Binary64.POSITIVE_INFINITY);
78          assertEquals(expected, actual);
79          actual = Binary64.POSITIVE_INFINITY.add(PLUS_X);
80          assertEquals(expected, actual);
81          actual = MINUS_X.add(Binary64.POSITIVE_INFINITY);
82          assertEquals(expected, actual);
83          actual = Binary64.POSITIVE_INFINITY.add(MINUS_X);
84          assertEquals(expected, actual);
85          actual = Binary64.POSITIVE_INFINITY.add(Binary64.POSITIVE_INFINITY);
86          assertEquals(expected, actual);
87  
88          expected = Binary64.NEGATIVE_INFINITY;
89          actual = PLUS_X.add(Binary64.NEGATIVE_INFINITY);
90          assertEquals(expected, actual);
91          actual = Binary64.NEGATIVE_INFINITY.add(PLUS_X);
92          assertEquals(expected, actual);
93          actual = Binary64.NEGATIVE_INFINITY.add(Binary64.NEGATIVE_INFINITY);
94          assertEquals(expected, actual);
95          actual = MINUS_X.add(Binary64.NEGATIVE_INFINITY);
96          assertEquals(expected, actual);
97          actual = Binary64.NEGATIVE_INFINITY.add(MINUS_X);
98          assertEquals(expected, actual);
99  
100         expected = Binary64.NAN;
101         actual = Binary64.POSITIVE_INFINITY.add(Binary64.NEGATIVE_INFINITY);
102         assertEquals(expected, actual);
103         actual = Binary64.NEGATIVE_INFINITY.add(Binary64.POSITIVE_INFINITY);
104         assertEquals(expected, actual);
105         actual = PLUS_X.add(Binary64.NAN);
106         assertEquals(expected, actual);
107         actual = Binary64.NAN.add(PLUS_X);
108         assertEquals(expected, actual);
109         actual = MINUS_X.add(Binary64.NAN);
110         assertEquals(expected, actual);
111         actual = Binary64.NAN.add(MINUS_X);
112         assertEquals(expected, actual);
113         actual = Binary64.POSITIVE_INFINITY.add(Binary64.NAN);
114         assertEquals(expected, actual);
115         actual = Binary64.NAN.add(Binary64.POSITIVE_INFINITY);
116         assertEquals(expected, actual);
117         actual = Binary64.NEGATIVE_INFINITY.add(Binary64.NAN);
118         assertEquals(expected, actual);
119         actual = Binary64.NAN.add(Binary64.NEGATIVE_INFINITY);
120         assertEquals(expected, actual);
121         actual = Binary64.NAN.add(Binary64.NAN);
122         assertEquals(expected, actual);
123     }
124 
125     @Test
126     void testSubtract() {
127         Binary64 expected, actual;
128 
129         expected = new Binary64(X - Y);
130         actual = PLUS_X.subtract(PLUS_Y);
131         assertEquals(expected, actual);
132 
133         expected = new Binary64(X - (-Y));
134         actual = PLUS_X.subtract(MINUS_Y);
135         assertEquals(expected, actual);
136 
137         expected = new Binary64((-X) - Y);
138         actual = MINUS_X.subtract(PLUS_Y);
139         assertEquals(expected, actual);
140 
141         expected = new Binary64((-X) - (-Y));
142         actual = MINUS_X.subtract(MINUS_Y);
143         assertEquals(expected, actual);
144 
145         expected = Binary64.NEGATIVE_INFINITY;
146         actual = PLUS_X.subtract(Binary64.POSITIVE_INFINITY);
147         assertEquals(expected, actual);
148         actual = MINUS_X.subtract(Binary64.POSITIVE_INFINITY);
149         assertEquals(expected, actual);
150         actual = Binary64.NEGATIVE_INFINITY
151                 .subtract(Binary64.POSITIVE_INFINITY);
152         assertEquals(expected, actual);
153 
154         expected = Binary64.POSITIVE_INFINITY;
155         actual = PLUS_X.subtract(Binary64.NEGATIVE_INFINITY);
156         assertEquals(expected, actual);
157         actual = MINUS_X.subtract(Binary64.NEGATIVE_INFINITY);
158         assertEquals(expected, actual);
159         actual = Binary64.POSITIVE_INFINITY
160                 .subtract(Binary64.NEGATIVE_INFINITY);
161         assertEquals(expected, actual);
162 
163         expected = Binary64.NAN;
164         actual = Binary64.POSITIVE_INFINITY
165                 .subtract(Binary64.POSITIVE_INFINITY);
166         assertEquals(expected, actual);
167         actual = Binary64.NEGATIVE_INFINITY
168                 .subtract(Binary64.NEGATIVE_INFINITY);
169         assertEquals(expected, actual);
170         actual = PLUS_X.subtract(Binary64.NAN);
171         assertEquals(expected, actual);
172         actual = Binary64.NAN.subtract(PLUS_X);
173         assertEquals(expected, actual);
174         actual = MINUS_X.subtract(Binary64.NAN);
175         assertEquals(expected, actual);
176         actual = Binary64.NAN.subtract(MINUS_X);
177         assertEquals(expected, actual);
178         actual = Binary64.POSITIVE_INFINITY.subtract(Binary64.NAN);
179         assertEquals(expected, actual);
180         actual = Binary64.NAN.subtract(Binary64.POSITIVE_INFINITY);
181         assertEquals(expected, actual);
182         actual = Binary64.NEGATIVE_INFINITY.subtract(Binary64.NAN);
183         assertEquals(expected, actual);
184         actual = Binary64.NAN.subtract(Binary64.NEGATIVE_INFINITY);
185         assertEquals(expected, actual);
186         actual = Binary64.NAN.subtract(Binary64.NAN);
187         assertEquals(expected, actual);
188     }
189 
190     @Test
191     void testNegate() {
192         Binary64 expected, actual;
193 
194         expected = MINUS_X;
195         actual = PLUS_X.negate();
196         assertEquals(expected, actual);
197 
198         expected = PLUS_X;
199         actual = MINUS_X.negate();
200         assertEquals(expected, actual);
201 
202         expected = MINUS_ZERO;
203         actual = PLUS_ZERO.negate();
204         assertEquals(expected, actual);
205 
206         expected = PLUS_ZERO;
207         actual = MINUS_ZERO.negate();
208         assertEquals(expected, actual);
209 
210         expected = Binary64.POSITIVE_INFINITY;
211         actual = Binary64.NEGATIVE_INFINITY.negate();
212         assertEquals(expected, actual);
213 
214         expected = Binary64.NEGATIVE_INFINITY;
215         actual = Binary64.POSITIVE_INFINITY.negate();
216         assertEquals(expected, actual);
217 
218         expected = Binary64.NAN;
219         actual = Binary64.NAN.negate();
220         assertEquals(expected, actual);
221     }
222 
223     @Test
224     void testMultiply() {
225         Binary64 expected, actual;
226 
227         expected = new Binary64(X * Y);
228         actual = PLUS_X.multiply(PLUS_Y);
229         assertEquals(expected, actual);
230         actual = PLUS_Y.multiply(PLUS_X);
231         assertEquals(expected, actual);
232 
233         expected = new Binary64(X * (-Y));
234         actual = PLUS_X.multiply(MINUS_Y);
235         assertEquals(expected, actual);
236         actual = MINUS_Y.multiply(PLUS_X);
237         assertEquals(expected, actual);
238 
239         expected = new Binary64((-X) * (-Y));
240         actual = MINUS_X.multiply(MINUS_Y);
241         assertEquals(expected, actual);
242         actual = MINUS_Y.multiply(MINUS_X);
243         assertEquals(expected, actual);
244 
245         expected = Binary64.POSITIVE_INFINITY;
246         actual = PLUS_X.multiply(Binary64.POSITIVE_INFINITY);
247         assertEquals(expected, actual);
248         actual = Binary64.POSITIVE_INFINITY.multiply(PLUS_X);
249         assertEquals(expected, actual);
250         actual = MINUS_X.multiply(Binary64.NEGATIVE_INFINITY);
251         assertEquals(expected, actual);
252         actual = Binary64.NEGATIVE_INFINITY.multiply(MINUS_X);
253         assertEquals(expected, actual);
254         actual = Binary64.POSITIVE_INFINITY
255                 .multiply(Binary64.POSITIVE_INFINITY);
256         assertEquals(expected, actual);
257         actual = Binary64.NEGATIVE_INFINITY
258                 .multiply(Binary64.NEGATIVE_INFINITY);
259         assertEquals(expected, actual);
260 
261         expected = Binary64.NEGATIVE_INFINITY;
262         actual = PLUS_X.multiply(Binary64.NEGATIVE_INFINITY);
263         assertEquals(expected, actual);
264         actual = Binary64.NEGATIVE_INFINITY.multiply(PLUS_X);
265         assertEquals(expected, actual);
266         actual = MINUS_X.multiply(Binary64.POSITIVE_INFINITY);
267         assertEquals(expected, actual);
268         actual = Binary64.POSITIVE_INFINITY.multiply(MINUS_X);
269         assertEquals(expected, actual);
270         actual = Binary64.POSITIVE_INFINITY
271                 .multiply(Binary64.NEGATIVE_INFINITY);
272         assertEquals(expected, actual);
273         actual = Binary64.NEGATIVE_INFINITY
274                 .multiply(Binary64.POSITIVE_INFINITY);
275         assertEquals(expected, actual);
276 
277         expected = Binary64.NAN;
278         actual = PLUS_X.multiply(Binary64.NAN);
279         assertEquals(expected, actual);
280         actual = Binary64.NAN.multiply(PLUS_X);
281         assertEquals(expected, actual);
282         actual = MINUS_X.multiply(Binary64.NAN);
283         assertEquals(expected, actual);
284         actual = Binary64.NAN.multiply(MINUS_X);
285         assertEquals(expected, actual);
286         actual = Binary64.POSITIVE_INFINITY.multiply(Binary64.NAN);
287         assertEquals(expected, actual);
288         actual = Binary64.NAN.multiply(Binary64.POSITIVE_INFINITY);
289         assertEquals(expected, actual);
290         actual = Binary64.NEGATIVE_INFINITY.multiply(Binary64.NAN);
291         assertEquals(expected, actual);
292         actual = Binary64.NAN.multiply(Binary64.NEGATIVE_INFINITY);
293         assertEquals(expected, actual);
294         actual = Binary64.NAN.multiply(Binary64.NAN);
295         assertEquals(expected, actual);
296     }
297 
298     @Test
299     void testDivide() {
300         Binary64 expected, actual;
301 
302         expected = new Binary64(X / Y);
303         actual = PLUS_X.divide(PLUS_Y);
304         assertEquals(expected, actual);
305 
306         expected = new Binary64(X / (-Y));
307         actual = PLUS_X.divide(MINUS_Y);
308         assertEquals(expected, actual);
309 
310         expected = new Binary64((-X) / Y);
311         actual = MINUS_X.divide(PLUS_Y);
312         assertEquals(expected, actual);
313 
314         expected = new Binary64((-X) / (-Y));
315         actual = MINUS_X.divide(MINUS_Y);
316         assertEquals(expected, actual);
317 
318         expected = PLUS_ZERO;
319         actual = PLUS_X.divide(Binary64.POSITIVE_INFINITY);
320         assertEquals(expected, actual);
321         actual = MINUS_X.divide(Binary64.NEGATIVE_INFINITY);
322         assertEquals(expected, actual);
323 
324         expected = MINUS_ZERO;
325         actual = MINUS_X.divide(Binary64.POSITIVE_INFINITY);
326         assertEquals(expected, actual);
327         actual = PLUS_X.divide(Binary64.NEGATIVE_INFINITY);
328         assertEquals(expected, actual);
329 
330         expected = Binary64.POSITIVE_INFINITY;
331         actual = Binary64.POSITIVE_INFINITY.divide(PLUS_X);
332         assertEquals(expected, actual);
333         actual = Binary64.NEGATIVE_INFINITY.divide(MINUS_X);
334         assertEquals(expected, actual);
335         actual = PLUS_X.divide(PLUS_ZERO);
336         assertEquals(expected, actual);
337         actual = MINUS_X.divide(MINUS_ZERO);
338         assertEquals(expected, actual);
339 
340         expected = Binary64.NEGATIVE_INFINITY;
341         actual = Binary64.POSITIVE_INFINITY.divide(MINUS_X);
342         assertEquals(expected, actual);
343         actual = Binary64.NEGATIVE_INFINITY.divide(PLUS_X);
344         assertEquals(expected, actual);
345         actual = PLUS_X.divide(MINUS_ZERO);
346         assertEquals(expected, actual);
347         actual = MINUS_X.divide(PLUS_ZERO);
348         assertEquals(expected, actual);
349 
350         expected = Binary64.NAN;
351         actual = Binary64.POSITIVE_INFINITY
352                 .divide(Binary64.POSITIVE_INFINITY);
353         assertEquals(expected, actual);
354         actual = Binary64.POSITIVE_INFINITY
355                 .divide(Binary64.NEGATIVE_INFINITY);
356         assertEquals(expected, actual);
357         actual = Binary64.NEGATIVE_INFINITY
358                 .divide(Binary64.POSITIVE_INFINITY);
359         assertEquals(expected, actual);
360         actual = Binary64.NEGATIVE_INFINITY
361                 .divide(Binary64.NEGATIVE_INFINITY);
362         assertEquals(expected, actual);
363         actual = PLUS_X.divide(Binary64.NAN);
364         assertEquals(expected, actual);
365         actual = Binary64.NAN.divide(PLUS_X);
366         assertEquals(expected, actual);
367         actual = MINUS_X.divide(Binary64.NAN);
368         assertEquals(expected, actual);
369         actual = Binary64.NAN.divide(MINUS_X);
370         assertEquals(expected, actual);
371         actual = Binary64.POSITIVE_INFINITY.divide(Binary64.NAN);
372         assertEquals(expected, actual);
373         actual = Binary64.NAN.divide(Binary64.POSITIVE_INFINITY);
374         assertEquals(expected, actual);
375         actual = Binary64.NEGATIVE_INFINITY.divide(Binary64.NAN);
376         assertEquals(expected, actual);
377         actual = Binary64.NAN.divide(Binary64.NEGATIVE_INFINITY);
378         assertEquals(expected, actual);
379         actual = Binary64.NAN.divide(Binary64.NAN);
380         assertEquals(expected, actual);
381         actual = PLUS_ZERO.divide(PLUS_ZERO);
382         assertEquals(expected, actual);
383         actual = PLUS_ZERO.divide(MINUS_ZERO);
384         assertEquals(expected, actual);
385         actual = MINUS_ZERO.divide(PLUS_ZERO);
386         assertEquals(expected, actual);
387         actual = MINUS_ZERO.divide(MINUS_ZERO);
388         assertEquals(expected, actual);
389     }
390 
391     @Test
392     void testReciprocal() {
393         Binary64 expected, actual;
394 
395         expected = new Binary64(1.0 / X);
396         actual = PLUS_X.reciprocal();
397         assertEquals(expected, actual);
398 
399         expected = new Binary64(1.0 / (-X));
400         actual = MINUS_X.reciprocal();
401         assertEquals(expected, actual);
402 
403         expected = PLUS_ZERO;
404         actual = Binary64.POSITIVE_INFINITY.reciprocal();
405         assertEquals(expected, actual);
406 
407         expected = MINUS_ZERO;
408         actual = Binary64.NEGATIVE_INFINITY.reciprocal();
409         assertEquals(expected, actual);
410     }
411 
412     @Test
413     void testIsInfinite() {
414         assertFalse(MINUS_X.isInfinite());
415         assertFalse(PLUS_X.isInfinite());
416         assertFalse(MINUS_Y.isInfinite());
417         assertFalse(PLUS_Y.isInfinite());
418         assertFalse(Binary64.NAN.isInfinite());
419 
420         assertTrue(Binary64.NEGATIVE_INFINITY.isInfinite());
421         assertTrue(Binary64.POSITIVE_INFINITY.isInfinite());
422     }
423 
424     @Test
425     void testIsNaN() {
426         assertFalse(MINUS_X.isNaN());
427         assertFalse(PLUS_X.isNaN());
428         assertFalse(MINUS_Y.isNaN());
429         assertFalse(PLUS_Y.isNaN());
430         assertFalse(Binary64.NEGATIVE_INFINITY.isNaN());
431         assertFalse(Binary64.POSITIVE_INFINITY.isNaN());
432 
433         assertTrue(Binary64.NAN.isNaN());
434     }
435 
436     @Test
437     void testToDegreesDefinition() {
438         double epsilon = 3.0e-16;
439         for (int maxOrder = 0; maxOrder < 6; ++maxOrder) {
440             for (double x = 0.1; x < 1.2; x += 0.001) {
441                 Binary64 value = new Binary64(x);
442                 assertEquals(FastMath.toDegrees(x), value.toDegrees().getReal(), epsilon);
443             }
444         }
445     }
446 
447     @Test
448     void testToRadiansDefinition() {
449         double epsilon = 3.0e-16;
450         for (int maxOrder = 0; maxOrder < 6; ++maxOrder) {
451             for (double x = 0.1; x < 1.2; x += 0.001) {
452                 Binary64 value = new Binary64(x);
453                 assertEquals(FastMath.toRadians(x), value.toRadians().getReal(), epsilon);
454             }
455         }
456     }
457 
458     @Test
459     void testDegRad() {
460         for (double x = 0.1; x < 1.2; x += 0.001) {
461             Binary64 value = new Binary64(x);
462             Binary64 rebuilt = value.toDegrees().toRadians();
463             Binary64 zero = rebuilt.subtract(value);
464             assertEquals(0, zero.getReal(), 3.0e-16);
465         }
466     }
467 
468     @Test
469     void testRootNegative() {
470         final Binary64 neg64      = new Binary64(-64);
471         final Binary64 root3Neg64 = neg64.rootN(3);
472         final Binary64 root2Neg64 = neg64.rootN(2);
473         assertEquals(-4.0, root3Neg64.getReal(), 1.0e-15);
474         assertTrue(root2Neg64.isNaN());
475     }
476 
477     @Test
478     void testSignedZeroEquality() {
479         assertFalse(new Binary64(1.0).isZero());
480         assertTrue(new Binary64(-0.0).isZero());
481         assertTrue(new Binary64(+0.0).isZero());
482         assertNotEquals(new Binary64(+0.0), new Binary64(-0.0));
483     }
484 
485     @Test
486     void testValues() {
487         assertEquals(1,    new Binary64(1.2).byteValue());
488         assertEquals(1,    new Binary64(1.2).shortValue());
489         assertEquals(1,    new Binary64(1.2).intValue());
490         assertEquals(1l,   new Binary64(1.2).longValue());
491         assertEquals(1.2f, new Binary64(1.2).floatValue(),  0.00001f);
492         assertEquals(1.2 , new Binary64(1.2).doubleValue(), 1.0e-15);
493     }
494 
495     @SuppressWarnings("unlikely-arg-type")
496     @Test
497     void testEquals() {
498         assertEquals(new Binary64(1.25), new Binary64(1.0).add(new Binary64(0.25)));
499         assertNotEquals(new Binary64(1.25), new Binary64(1.0).add(new Binary64(1.25)));
500         assertNotEquals("1.25", new Binary64(1.25));
501     }
502 
503 }