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