1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 }