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