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  package org.apache.commons.math4.legacy.ode.nonstiff;
18  
19  import org.apache.commons.math4.legacy.field.ExtendedFieldElementAbstractTest;
20  import org.junit.Assert;
21  import org.junit.Test;
22  
23  public class Decimal64Test extends ExtendedFieldElementAbstractTest<Decimal64> {
24      public static final double X = 1.2345;
25  
26      public static final Decimal64 PLUS_X = new Decimal64(X);
27  
28      public static final Decimal64 MINUS_X = new Decimal64(-X);
29  
30      public static final double Y = 6.789;
31  
32      public static final Decimal64 PLUS_Y = new Decimal64(Y);
33  
34      public static final Decimal64 MINUS_Y = new Decimal64(-Y);
35  
36      public static final Decimal64 PLUS_ZERO = new Decimal64(0.0);
37  
38      public static final Decimal64 MINUS_ZERO = new Decimal64(-0.0);
39  
40      @Override
41      protected Decimal64 build(final double x) {
42          return new Decimal64(x);
43      }
44  
45      @Test
46      public void testAdd() {
47          Decimal64 expected;
48          Decimal64 actual;
49  
50          expected = new Decimal64(X + Y);
51          actual = PLUS_X.add(PLUS_Y);
52          Assert.assertEquals(expected, actual);
53          actual = PLUS_Y.add(PLUS_X);
54          Assert.assertEquals(expected, actual);
55  
56          expected = new Decimal64(X + (-Y));
57          actual = PLUS_X.add(MINUS_Y);
58          Assert.assertEquals(expected, actual);
59          actual = MINUS_Y.add(PLUS_X);
60          Assert.assertEquals(expected, actual);
61  
62          expected = new Decimal64((-X) + (-Y));
63          actual = MINUS_X.add(MINUS_Y);
64          Assert.assertEquals(expected, actual);
65          actual = MINUS_Y.add(MINUS_X);
66          Assert.assertEquals(expected, actual);
67  
68          expected = Decimal64.POSITIVE_INFINITY;
69          actual = PLUS_X.add(Decimal64.POSITIVE_INFINITY);
70          Assert.assertEquals(expected, actual);
71          actual = Decimal64.POSITIVE_INFINITY.add(PLUS_X);
72          Assert.assertEquals(expected, actual);
73          actual = MINUS_X.add(Decimal64.POSITIVE_INFINITY);
74          Assert.assertEquals(expected, actual);
75          actual = Decimal64.POSITIVE_INFINITY.add(MINUS_X);
76          Assert.assertEquals(expected, actual);
77          actual = Decimal64.POSITIVE_INFINITY.add(Decimal64.POSITIVE_INFINITY);
78          Assert.assertEquals(expected, actual);
79  
80          expected = Decimal64.NEGATIVE_INFINITY;
81          actual = PLUS_X.add(Decimal64.NEGATIVE_INFINITY);
82          Assert.assertEquals(expected, actual);
83          actual = Decimal64.NEGATIVE_INFINITY.add(PLUS_X);
84          Assert.assertEquals(expected, actual);
85          actual = Decimal64.NEGATIVE_INFINITY.add(Decimal64.NEGATIVE_INFINITY);
86          Assert.assertEquals(expected, actual);
87          actual = MINUS_X.add(Decimal64.NEGATIVE_INFINITY);
88          Assert.assertEquals(expected, actual);
89          actual = Decimal64.NEGATIVE_INFINITY.add(MINUS_X);
90          Assert.assertEquals(expected, actual);
91  
92          expected = Decimal64.NAN;
93          actual = Decimal64.POSITIVE_INFINITY.add(Decimal64.NEGATIVE_INFINITY);
94          Assert.assertEquals(expected, actual);
95          actual = Decimal64.NEGATIVE_INFINITY.add(Decimal64.POSITIVE_INFINITY);
96          Assert.assertEquals(expected, actual);
97          actual = PLUS_X.add(Decimal64.NAN);
98          Assert.assertEquals(expected, actual);
99          actual = Decimal64.NAN.add(PLUS_X);
100         Assert.assertEquals(expected, actual);
101         actual = MINUS_X.add(Decimal64.NAN);
102         Assert.assertEquals(expected, actual);
103         actual = Decimal64.NAN.add(MINUS_X);
104         Assert.assertEquals(expected, actual);
105         actual = Decimal64.POSITIVE_INFINITY.add(Decimal64.NAN);
106         Assert.assertEquals(expected, actual);
107         actual = Decimal64.NAN.add(Decimal64.POSITIVE_INFINITY);
108         Assert.assertEquals(expected, actual);
109         actual = Decimal64.NEGATIVE_INFINITY.add(Decimal64.NAN);
110         Assert.assertEquals(expected, actual);
111         actual = Decimal64.NAN.add(Decimal64.NEGATIVE_INFINITY);
112         Assert.assertEquals(expected, actual);
113         actual = Decimal64.NAN.add(Decimal64.NAN);
114         Assert.assertEquals(expected, actual);
115     }
116 
117     @Test
118     public void testSubtract() {
119         Decimal64 expected;
120         Decimal64 actual;
121 
122         expected = new Decimal64(X - Y);
123         actual = PLUS_X.subtract(PLUS_Y);
124         Assert.assertEquals(expected, actual);
125 
126         expected = new Decimal64(X - (-Y));
127         actual = PLUS_X.subtract(MINUS_Y);
128         Assert.assertEquals(expected, actual);
129 
130         expected = new Decimal64((-X) - Y);
131         actual = MINUS_X.subtract(PLUS_Y);
132         Assert.assertEquals(expected, actual);
133 
134         expected = new Decimal64((-X) - (-Y));
135         actual = MINUS_X.subtract(MINUS_Y);
136         Assert.assertEquals(expected, actual);
137 
138         expected = Decimal64.NEGATIVE_INFINITY;
139         actual = PLUS_X.subtract(Decimal64.POSITIVE_INFINITY);
140         Assert.assertEquals(expected, actual);
141         actual = MINUS_X.subtract(Decimal64.POSITIVE_INFINITY);
142         Assert.assertEquals(expected, actual);
143         actual = Decimal64.NEGATIVE_INFINITY
144                 .subtract(Decimal64.POSITIVE_INFINITY);
145         Assert.assertEquals(expected, actual);
146 
147         expected = Decimal64.POSITIVE_INFINITY;
148         actual = PLUS_X.subtract(Decimal64.NEGATIVE_INFINITY);
149         Assert.assertEquals(expected, actual);
150         actual = MINUS_X.subtract(Decimal64.NEGATIVE_INFINITY);
151         Assert.assertEquals(expected, actual);
152         actual = Decimal64.POSITIVE_INFINITY
153                 .subtract(Decimal64.NEGATIVE_INFINITY);
154         Assert.assertEquals(expected, actual);
155 
156         expected = Decimal64.NAN;
157         actual = Decimal64.POSITIVE_INFINITY
158                 .subtract(Decimal64.POSITIVE_INFINITY);
159         Assert.assertEquals(expected, actual);
160         actual = Decimal64.NEGATIVE_INFINITY
161                 .subtract(Decimal64.NEGATIVE_INFINITY);
162         Assert.assertEquals(expected, actual);
163         actual = PLUS_X.subtract(Decimal64.NAN);
164         Assert.assertEquals(expected, actual);
165         actual = Decimal64.NAN.subtract(PLUS_X);
166         Assert.assertEquals(expected, actual);
167         actual = MINUS_X.subtract(Decimal64.NAN);
168         Assert.assertEquals(expected, actual);
169         actual = Decimal64.NAN.subtract(MINUS_X);
170         Assert.assertEquals(expected, actual);
171         actual = Decimal64.POSITIVE_INFINITY.subtract(Decimal64.NAN);
172         Assert.assertEquals(expected, actual);
173         actual = Decimal64.NAN.subtract(Decimal64.POSITIVE_INFINITY);
174         Assert.assertEquals(expected, actual);
175         actual = Decimal64.NEGATIVE_INFINITY.subtract(Decimal64.NAN);
176         Assert.assertEquals(expected, actual);
177         actual = Decimal64.NAN.subtract(Decimal64.NEGATIVE_INFINITY);
178         Assert.assertEquals(expected, actual);
179         actual = Decimal64.NAN.subtract(Decimal64.NAN);
180         Assert.assertEquals(expected, actual);
181     }
182 
183     @Test
184     public void testNegate() {
185         Decimal64 expected;
186         Decimal64 actual;
187 
188         expected = MINUS_X;
189         actual = PLUS_X.negate();
190         Assert.assertEquals(expected, actual);
191 
192         expected = PLUS_X;
193         actual = MINUS_X.negate();
194         Assert.assertEquals(expected, actual);
195 
196         expected = MINUS_ZERO;
197         actual = PLUS_ZERO.negate();
198         Assert.assertEquals(expected, actual);
199 
200         expected = PLUS_ZERO;
201         actual = MINUS_ZERO.negate();
202         Assert.assertEquals(expected, actual);
203 
204         expected = Decimal64.POSITIVE_INFINITY;
205         actual = Decimal64.NEGATIVE_INFINITY.negate();
206         Assert.assertEquals(expected, actual);
207 
208         expected = Decimal64.NEGATIVE_INFINITY;
209         actual = Decimal64.POSITIVE_INFINITY.negate();
210         Assert.assertEquals(expected, actual);
211 
212         expected = Decimal64.NAN;
213         actual = Decimal64.NAN.negate();
214         Assert.assertEquals(expected, actual);
215     }
216 
217     @Test
218     public void testMultiply() {
219         Decimal64 expected;
220         Decimal64 actual;
221 
222         expected = new Decimal64(X * Y);
223         actual = PLUS_X.multiply(PLUS_Y);
224         Assert.assertEquals(expected, actual);
225         actual = PLUS_Y.multiply(PLUS_X);
226         Assert.assertEquals(expected, actual);
227 
228         expected = new Decimal64(X * (-Y));
229         actual = PLUS_X.multiply(MINUS_Y);
230         Assert.assertEquals(expected, actual);
231         actual = MINUS_Y.multiply(PLUS_X);
232         Assert.assertEquals(expected, actual);
233 
234         expected = new Decimal64((-X) * (-Y));
235         actual = MINUS_X.multiply(MINUS_Y);
236         Assert.assertEquals(expected, actual);
237         actual = MINUS_Y.multiply(MINUS_X);
238         Assert.assertEquals(expected, actual);
239 
240         expected = Decimal64.POSITIVE_INFINITY;
241         actual = PLUS_X.multiply(Decimal64.POSITIVE_INFINITY);
242         Assert.assertEquals(expected, actual);
243         actual = Decimal64.POSITIVE_INFINITY.multiply(PLUS_X);
244         Assert.assertEquals(expected, actual);
245         actual = MINUS_X.multiply(Decimal64.NEGATIVE_INFINITY);
246         Assert.assertEquals(expected, actual);
247         actual = Decimal64.NEGATIVE_INFINITY.multiply(MINUS_X);
248         Assert.assertEquals(expected, actual);
249         actual = Decimal64.POSITIVE_INFINITY
250                 .multiply(Decimal64.POSITIVE_INFINITY);
251         Assert.assertEquals(expected, actual);
252         actual = Decimal64.NEGATIVE_INFINITY
253                 .multiply(Decimal64.NEGATIVE_INFINITY);
254         Assert.assertEquals(expected, actual);
255 
256         expected = Decimal64.NEGATIVE_INFINITY;
257         actual = PLUS_X.multiply(Decimal64.NEGATIVE_INFINITY);
258         Assert.assertEquals(expected, actual);
259         actual = Decimal64.NEGATIVE_INFINITY.multiply(PLUS_X);
260         Assert.assertEquals(expected, actual);
261         actual = MINUS_X.multiply(Decimal64.POSITIVE_INFINITY);
262         Assert.assertEquals(expected, actual);
263         actual = Decimal64.POSITIVE_INFINITY.multiply(MINUS_X);
264         Assert.assertEquals(expected, actual);
265         actual = Decimal64.POSITIVE_INFINITY
266                 .multiply(Decimal64.NEGATIVE_INFINITY);
267         Assert.assertEquals(expected, actual);
268         actual = Decimal64.NEGATIVE_INFINITY
269                 .multiply(Decimal64.POSITIVE_INFINITY);
270         Assert.assertEquals(expected, actual);
271 
272         expected = Decimal64.NAN;
273         actual = PLUS_X.multiply(Decimal64.NAN);
274         Assert.assertEquals(expected, actual);
275         actual = Decimal64.NAN.multiply(PLUS_X);
276         Assert.assertEquals(expected, actual);
277         actual = MINUS_X.multiply(Decimal64.NAN);
278         Assert.assertEquals(expected, actual);
279         actual = Decimal64.NAN.multiply(MINUS_X);
280         Assert.assertEquals(expected, actual);
281         actual = Decimal64.POSITIVE_INFINITY.multiply(Decimal64.NAN);
282         Assert.assertEquals(expected, actual);
283         actual = Decimal64.NAN.multiply(Decimal64.POSITIVE_INFINITY);
284         Assert.assertEquals(expected, actual);
285         actual = Decimal64.NEGATIVE_INFINITY.multiply(Decimal64.NAN);
286         Assert.assertEquals(expected, actual);
287         actual = Decimal64.NAN.multiply(Decimal64.NEGATIVE_INFINITY);
288         Assert.assertEquals(expected, actual);
289         actual = Decimal64.NAN.multiply(Decimal64.NAN);
290         Assert.assertEquals(expected, actual);
291     }
292 
293     @Test
294     public void testDivide() {
295         Decimal64 expected;
296         Decimal64 actual;
297 
298         expected = new Decimal64(X / Y);
299         actual = PLUS_X.divide(PLUS_Y);
300         Assert.assertEquals(expected, actual);
301 
302         expected = new Decimal64(X / (-Y));
303         actual = PLUS_X.divide(MINUS_Y);
304         Assert.assertEquals(expected, actual);
305 
306         expected = new Decimal64((-X) / Y);
307         actual = MINUS_X.divide(PLUS_Y);
308         Assert.assertEquals(expected, actual);
309 
310         expected = new Decimal64((-X) / (-Y));
311         actual = MINUS_X.divide(MINUS_Y);
312         Assert.assertEquals(expected, actual);
313 
314         expected = PLUS_ZERO;
315         actual = PLUS_X.divide(Decimal64.POSITIVE_INFINITY);
316         Assert.assertEquals(expected, actual);
317         actual = MINUS_X.divide(Decimal64.NEGATIVE_INFINITY);
318         Assert.assertEquals(expected, actual);
319 
320         expected = MINUS_ZERO;
321         actual = MINUS_X.divide(Decimal64.POSITIVE_INFINITY);
322         Assert.assertEquals(expected, actual);
323         actual = PLUS_X.divide(Decimal64.NEGATIVE_INFINITY);
324         Assert.assertEquals(expected, actual);
325 
326         expected = Decimal64.POSITIVE_INFINITY;
327         actual = Decimal64.POSITIVE_INFINITY.divide(PLUS_X);
328         Assert.assertEquals(expected, actual);
329         actual = Decimal64.NEGATIVE_INFINITY.divide(MINUS_X);
330         Assert.assertEquals(expected, actual);
331         actual = PLUS_X.divide(PLUS_ZERO);
332         Assert.assertEquals(expected, actual);
333         actual = MINUS_X.divide(MINUS_ZERO);
334         Assert.assertEquals(expected, actual);
335 
336         expected = Decimal64.NEGATIVE_INFINITY;
337         actual = Decimal64.POSITIVE_INFINITY.divide(MINUS_X);
338         Assert.assertEquals(expected, actual);
339         actual = Decimal64.NEGATIVE_INFINITY.divide(PLUS_X);
340         Assert.assertEquals(expected, actual);
341         actual = PLUS_X.divide(MINUS_ZERO);
342         Assert.assertEquals(expected, actual);
343         actual = MINUS_X.divide(PLUS_ZERO);
344         Assert.assertEquals(expected, actual);
345 
346         expected = Decimal64.NAN;
347         actual = Decimal64.POSITIVE_INFINITY
348                 .divide(Decimal64.POSITIVE_INFINITY);
349         Assert.assertEquals(expected, actual);
350         actual = Decimal64.POSITIVE_INFINITY
351                 .divide(Decimal64.NEGATIVE_INFINITY);
352         Assert.assertEquals(expected, actual);
353         actual = Decimal64.NEGATIVE_INFINITY
354                 .divide(Decimal64.POSITIVE_INFINITY);
355         Assert.assertEquals(expected, actual);
356         actual = Decimal64.NEGATIVE_INFINITY
357                 .divide(Decimal64.NEGATIVE_INFINITY);
358         Assert.assertEquals(expected, actual);
359         actual = PLUS_X.divide(Decimal64.NAN);
360         Assert.assertEquals(expected, actual);
361         actual = Decimal64.NAN.divide(PLUS_X);
362         Assert.assertEquals(expected, actual);
363         actual = MINUS_X.divide(Decimal64.NAN);
364         Assert.assertEquals(expected, actual);
365         actual = Decimal64.NAN.divide(MINUS_X);
366         Assert.assertEquals(expected, actual);
367         actual = Decimal64.POSITIVE_INFINITY.divide(Decimal64.NAN);
368         Assert.assertEquals(expected, actual);
369         actual = Decimal64.NAN.divide(Decimal64.POSITIVE_INFINITY);
370         Assert.assertEquals(expected, actual);
371         actual = Decimal64.NEGATIVE_INFINITY.divide(Decimal64.NAN);
372         Assert.assertEquals(expected, actual);
373         actual = Decimal64.NAN.divide(Decimal64.NEGATIVE_INFINITY);
374         Assert.assertEquals(expected, actual);
375         actual = Decimal64.NAN.divide(Decimal64.NAN);
376         Assert.assertEquals(expected, actual);
377         actual = PLUS_ZERO.divide(PLUS_ZERO);
378         Assert.assertEquals(expected, actual);
379         actual = PLUS_ZERO.divide(MINUS_ZERO);
380         Assert.assertEquals(expected, actual);
381         actual = MINUS_ZERO.divide(PLUS_ZERO);
382         Assert.assertEquals(expected, actual);
383         actual = MINUS_ZERO.divide(MINUS_ZERO);
384         Assert.assertEquals(expected, actual);
385     }
386 
387     @Test
388     public void testReciprocal() {
389         Decimal64 expected;
390         Decimal64 actual;
391 
392         expected = new Decimal64(1.0 / X);
393         actual = PLUS_X.reciprocal();
394         Assert.assertEquals(expected, actual);
395 
396         expected = new Decimal64(1.0 / (-X));
397         actual = MINUS_X.reciprocal();
398         Assert.assertEquals(expected, actual);
399 
400         expected = PLUS_ZERO;
401         actual = Decimal64.POSITIVE_INFINITY.reciprocal();
402         Assert.assertEquals(expected, actual);
403 
404         expected = MINUS_ZERO;
405         actual = Decimal64.NEGATIVE_INFINITY.reciprocal();
406         Assert.assertEquals(expected, actual);
407     }
408 
409     @Test
410     public void testIsInfinite() {
411         Assert.assertFalse(MINUS_X.isInfinite());
412         Assert.assertFalse(PLUS_X.isInfinite());
413         Assert.assertFalse(MINUS_Y.isInfinite());
414         Assert.assertFalse(PLUS_Y.isInfinite());
415         Assert.assertFalse(Decimal64.NAN.isInfinite());
416 
417         Assert.assertTrue(Decimal64.NEGATIVE_INFINITY.isInfinite());
418         Assert.assertTrue(Decimal64.POSITIVE_INFINITY.isInfinite());
419     }
420 
421     @Test
422     public void testIsNaN() {
423         Assert.assertFalse(MINUS_X.isNaN());
424         Assert.assertFalse(PLUS_X.isNaN());
425         Assert.assertFalse(MINUS_Y.isNaN());
426         Assert.assertFalse(PLUS_Y.isNaN());
427         Assert.assertFalse(Decimal64.NEGATIVE_INFINITY.isNaN());
428         Assert.assertFalse(Decimal64.POSITIVE_INFINITY.isNaN());
429 
430         Assert.assertTrue(Decimal64.NAN.isNaN());
431     }
432 }