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 18 package org.apache.harmony.tests.java.math; 19 20 import java.math.BigDecimal; 21 import java.math.BigInteger; 22 import java.math.MathContext; 23 import java.math.RoundingMode; 24 25 import junit.framework.TestCase; 26 27 /** 28 * Class: java.math.BigDecimal 29 * Methods: add, subtract, multiply, divide 30 */ 31 public class BigDecimalArithmeticTest extends TestCase { 32 /** 33 * Add two numbers of equal positive scales 34 */ 35 public void testAddEqualScalePosPos() { 36 String a = "1231212478987482988429808779810457634781384756794987"; 37 int aScale = 10; 38 String b = "747233429293018787918347987234564568"; 39 int bScale = 10; 40 String c = "123121247898748373566323807282924555312937.1991359555"; 41 int cScale = 10; 42 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 43 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 44 BigDecimal result = aNumber.add(bNumber); 45 assertEquals("incorrect value", c, result.toString()); 46 assertEquals("incorrect scale", cScale, result.scale()); 47 } 48 49 /** 50 * Add two numbers of equal positive scales using MathContext 51 */ 52 public void testAddMathContextEqualScalePosPos() { 53 String a = "1231212478987482988429808779810457634781384756794987"; 54 int aScale = 10; 55 String b = "747233429293018787918347987234564568"; 56 int bScale = 10; 57 String c = "1.2313E+41"; 58 int cScale = -37; 59 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 60 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 61 MathContext mc = new MathContext(5, RoundingMode.UP); 62 BigDecimal result = aNumber.add(bNumber, mc); 63 assertEquals("incorrect value", c, result.toString()); 64 assertEquals("incorrect scale", cScale, result.scale()); 65 } 66 67 /** 68 * Add two numbers of equal negative scales 69 */ 70 public void testAddEqualScaleNegNeg() { 71 String a = "1231212478987482988429808779810457634781384756794987"; 72 int aScale = -10; 73 String b = "747233429293018787918347987234564568"; 74 int bScale = -10; 75 String c = "1.231212478987483735663238072829245553129371991359555E+61"; 76 int cScale = -10; 77 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 78 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 79 BigDecimal result = aNumber.add(bNumber); 80 assertEquals("incorrect value", c, result.toString()); 81 assertEquals("incorrect scale", cScale, result.scale()); 82 } 83 84 /** 85 * Add two numbers of equal negative scales using MathContext 86 */ 87 public void testAddMathContextEqualScaleNegNeg() { 88 String a = "1231212478987482988429808779810457634781384756794987"; 89 int aScale = -10; 90 String b = "747233429293018787918347987234564568"; 91 int bScale = -10; 92 String c = "1.2312E+61"; 93 int cScale = -57; 94 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 95 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 96 MathContext mc = new MathContext(5, RoundingMode.FLOOR); 97 BigDecimal result = aNumber.add(bNumber, mc); 98 assertEquals("incorrect value ", c, result.toString()); 99 assertEquals("incorrect scale", cScale, result.scale()); 100 } 101 102 /** 103 * Add two numbers of different scales; the first is positive 104 */ 105 public void testAddDiffScalePosNeg() { 106 String a = "1231212478987482988429808779810457634781384756794987"; 107 int aScale = 15; 108 String b = "747233429293018787918347987234564568"; 109 int bScale = -10; 110 String c = "7472334294161400358170962860775454459810457634.781384756794987"; 111 int cScale = 15; 112 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 113 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 114 BigDecimal result = aNumber.add(bNumber); 115 assertEquals("incorrect value", c, result.toString()); 116 assertEquals("incorrect scale", cScale, result.scale()); 117 } 118 119 /** 120 * Add two numbers of different scales using MathContext; the first is positive 121 */ 122 public void testAddMathContextDiffScalePosNeg() { 123 String a = "1231212478987482988429808779810457634781384756794987"; 124 int aScale = 15; 125 String b = "747233429293018787918347987234564568"; 126 int bScale = -10; 127 String c = "7.47233429416141E+45"; 128 int cScale = -31; 129 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 130 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 131 MathContext mc = new MathContext(15, RoundingMode.CEILING); 132 BigDecimal result = aNumber.add(bNumber, mc); 133 assertEquals("incorrect value", c, c.toString()); 134 assertEquals("incorrect scale", cScale, result.scale()); 135 } 136 137 /** 138 * Add two numbers of different scales; the first is negative 139 */ 140 public void testAddDiffScaleNegPos() { 141 String a = "1231212478987482988429808779810457634781384756794987"; 142 int aScale = -15; 143 String b = "747233429293018787918347987234564568"; 144 int bScale = 10; 145 String c = "1231212478987482988429808779810457634781459480137916301878791834798.7234564568"; 146 int cScale = 10; 147 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 148 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 149 BigDecimal result = aNumber.add(bNumber); 150 assertEquals("incorrect value", c, result.toString()); 151 assertEquals("incorrect scale", cScale, result.scale()); 152 } 153 154 /** 155 * Add two zeroes of different scales; the first is negative 156 */ 157 public void testAddDiffScaleZeroZero() { 158 String a = "0"; 159 int aScale = -15; 160 String b = "0"; 161 int bScale = 10; 162 String c = "0E-10"; 163 int cScale = 10; 164 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 165 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 166 BigDecimal result = aNumber.add(bNumber); 167 assertEquals("incorrect value", c, result.toString()); 168 assertEquals("incorrect scale", cScale, result.scale()); 169 } 170 171 /** 172 * Subtract two numbers of equal positive scales 173 */ 174 public void testSubtractEqualScalePosPos() { 175 String a = "1231212478987482988429808779810457634781384756794987"; 176 int aScale = 10; 177 String b = "747233429293018787918347987234564568"; 178 int bScale = 10; 179 String c = "123121247898748224119637948679166971643339.7522230419"; 180 int cScale = 10; 181 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 182 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 183 BigDecimal result = aNumber.subtract(bNumber); 184 assertEquals("incorrect value", c, result.toString()); 185 assertEquals("incorrect scale", cScale, result.scale()); 186 } 187 188 /** 189 * Subtract two numbers of equal positive scales using MathContext 190 */ 191 public void testSubtractMathContextEqualScalePosPos() { 192 String a = "1231212478987482988429808779810457634781384756794987"; 193 int aScale = 10; 194 String b = "747233429293018787918347987234564568"; 195 int bScale = 10; 196 String c = "1.23121247898749E+41"; 197 int cScale = -27; 198 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 199 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 200 MathContext mc = new MathContext(15, RoundingMode.CEILING); 201 BigDecimal result = aNumber.subtract(bNumber, mc); 202 assertEquals("incorrect value", c, result.toString()); 203 assertEquals("incorrect scale", cScale, result.scale()); 204 } 205 206 /** 207 * Subtract two numbers of equal negative scales 208 */ 209 public void testSubtractEqualScaleNegNeg() { 210 String a = "1231212478987482988429808779810457634781384756794987"; 211 int aScale = -10; 212 String b = "747233429293018787918347987234564568"; 213 int bScale = -10; 214 String c = "1.231212478987482241196379486791669716433397522230419E+61"; 215 int cScale = -10; 216 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 217 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 218 BigDecimal result = aNumber.subtract(bNumber); 219 assertEquals("incorrect value", c, result.toString()); 220 assertEquals("incorrect scale", cScale, result.scale()); 221 } 222 223 /** 224 * Subtract two numbers of different scales; the first is positive 225 */ 226 public void testSubtractDiffScalePosNeg() { 227 String a = "1231212478987482988429808779810457634781384756794987"; 228 int aScale = 15; 229 String b = "747233429293018787918347987234564568"; 230 int bScale = -10; 231 String c = "-7472334291698975400195996883915836900189542365.218615243205013"; 232 int cScale = 15; 233 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 234 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 235 BigDecimal result = aNumber.subtract(bNumber); 236 assertEquals("incorrect value", c, result.toString()); 237 assertEquals("incorrect scale", cScale, result.scale()); 238 } 239 240 /** 241 * Subtract two numbers of different scales using MathContext; 242 * the first is positive 243 */ 244 public void testSubtractMathContextDiffScalePosNeg() { 245 String a = "1231212478987482988429808779810457634781384756794987"; 246 int aScale = 15; 247 String b = "747233429293018787918347987234564568"; 248 int bScale = -10; 249 String c = "-7.4723342916989754E+45"; 250 int cScale = -29; 251 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 252 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 253 MathContext mc = new MathContext(17, RoundingMode.DOWN); 254 BigDecimal result = aNumber.subtract(bNumber, mc); 255 assertEquals("incorrect value", c, result.toString()); 256 assertEquals("incorrect scale", cScale, result.scale()); 257 } 258 259 /** 260 * Subtract two numbers of different scales; the first is negative 261 */ 262 public void testSubtractDiffScaleNegPos() { 263 String a = "1231212478987482988429808779810457634781384756794987"; 264 int aScale = -15; 265 String b = "747233429293018787918347987234564568"; 266 int bScale = 10; 267 String c = "1231212478987482988429808779810457634781310033452057698121208165201.2765435432"; 268 int cScale = 10; 269 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 270 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 271 BigDecimal result = aNumber.subtract(bNumber); 272 assertEquals("incorrect value", c, result.toString()); 273 assertEquals("incorrect scale", cScale, result.scale()); 274 } 275 276 /** 277 * Subtract two numbers of different scales using MathContext; 278 * the first is negative 279 */ 280 public void testSubtractMathContextDiffScaleNegPos() { 281 String a = "986798656676789766678767876078779810457634781384756794987"; 282 int aScale = -15; 283 String b = "747233429293018787918347987234564568"; 284 int bScale = 40; 285 String c = "9.867986566767897666787678760787798104576347813847567949870000000000000E+71"; 286 int cScale = -2; 287 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 288 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 289 MathContext mc = new MathContext(70, RoundingMode.HALF_DOWN); 290 BigDecimal result = aNumber.subtract(bNumber, mc); 291 assertEquals("incorrect value", c, result.toString()); 292 assertEquals("incorrect scale", cScale, result.scale()); 293 } 294 295 /** 296 * Multiply two numbers of positive scales 297 */ 298 public void testMultiplyScalePosPos() { 299 String a = "1231212478987482988429808779810457634781384756794987"; 300 int aScale = 15; 301 String b = "747233429293018787918347987234564568"; 302 int bScale = 10; 303 String c = "92000312286217574978643009574114545567010139156902666284589309.1880727173060570190220616"; 304 int cScale = 25; 305 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 306 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 307 BigDecimal result = aNumber.multiply(bNumber); 308 assertEquals("incorrect value", c, result.toString()); 309 assertEquals("incorrect scale", cScale, result.scale()); 310 } 311 312 /** 313 * Multiply two numbers of positive scales using MathContext 314 */ 315 public void testMultiplyMathContextScalePosPos() { 316 String a = "97665696756578755423325476545428779810457634781384756794987"; 317 int aScale = -25; 318 String b = "87656965586786097685674786576598865"; 319 int bScale = 10; 320 String c = "8.561078619600910561431314228543672720908E+108"; 321 int cScale = -69; 322 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 323 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 324 MathContext mc = new MathContext(40, RoundingMode.HALF_DOWN); 325 BigDecimal result = aNumber.multiply(bNumber, mc); 326 assertEquals("incorrect value", c, result.toString()); 327 assertEquals("incorrect scale", cScale, result.scale()); 328 } 329 330 /** 331 * Multiply two numbers of negative scales 332 */ 333 public void testMultiplyEqualScaleNegNeg() { 334 String a = "1231212478987482988429808779810457634781384756794987"; 335 int aScale = -15; 336 String b = "747233429293018787918347987234564568"; 337 int bScale = -10; 338 String c = "9.20003122862175749786430095741145455670101391569026662845893091880727173060570190220616E+111"; 339 int cScale = -25; 340 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 341 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 342 BigDecimal result = aNumber.multiply(bNumber); 343 assertEquals("incorrect value", c, result.toString()); 344 assertEquals("incorrect scale", cScale, result.scale()); 345 } 346 347 /** 348 * Multiply two numbers of different scales 349 */ 350 public void testMultiplyDiffScalePosNeg() { 351 String a = "1231212478987482988429808779810457634781384756794987"; 352 int aScale = 10; 353 String b = "747233429293018787918347987234564568"; 354 int bScale = -10; 355 String c = "920003122862175749786430095741145455670101391569026662845893091880727173060570190220616"; 356 int cScale = 0; 357 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 358 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 359 BigDecimal result = aNumber.multiply(bNumber); 360 assertEquals("incorrect value", c, result.toString()); 361 assertEquals("incorrect scale", cScale, result.scale()); 362 } 363 364 /** 365 * Multiply two numbers of different scales using MathContext 366 */ 367 public void testMultiplyMathContextDiffScalePosNeg() { 368 String a = "987667796597975765768768767866756808779810457634781384756794987"; 369 int aScale = 100; 370 String b = "747233429293018787918347987234564568"; 371 int bScale = -70; 372 String c = "7.3801839465418518653942222612429081498248509257207477E+68"; 373 int cScale = -16; 374 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 375 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 376 MathContext mc = new MathContext(53, RoundingMode.HALF_UP); 377 BigDecimal result = aNumber.multiply(bNumber, mc); 378 assertEquals("incorrect value", c, result.toString()); 379 assertEquals("incorrect scale", cScale, result.scale()); 380 } 381 382 /** 383 * Multiply two numbers of different scales 384 */ 385 public void testMultiplyDiffScaleNegPos() { 386 String a = "1231212478987482988429808779810457634781384756794987"; 387 int aScale = -15; 388 String b = "747233429293018787918347987234564568"; 389 int bScale = 10; 390 String c = "9.20003122862175749786430095741145455670101391569026662845893091880727173060570190220616E+91"; 391 int cScale = -5; 392 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 393 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 394 BigDecimal result = aNumber.multiply(bNumber); 395 assertEquals("incorrect value", c, result.toString()); 396 assertEquals("incorrect scale", cScale, result.scale()); 397 } 398 399 /** 400 * Multiply two numbers of different scales using MathContext 401 */ 402 public void testMultiplyMathContextDiffScaleNegPos() { 403 String a = "488757458676796558668876576576579097029810457634781384756794987"; 404 int aScale = -63; 405 String b = "747233429293018787918347987234564568"; 406 int bScale = 63; 407 String c = "3.6521591193960361339707130098174381429788164316E+98"; 408 int cScale = -52; 409 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 410 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 411 MathContext mc = new MathContext(47, RoundingMode.HALF_UP); 412 BigDecimal result = aNumber.multiply(bNumber, mc); 413 assertEquals("incorrect value", c, result.toString()); 414 assertEquals("incorrect scale", cScale, result.scale()); 415 } 416 417 /** 418 * pow(int) 419 */ 420 public void testPow() { 421 String a = "123121247898748298842980"; 422 int aScale = 10; 423 int exp = 10; 424 String c = "8004424019039195734129783677098845174704975003788210729597" + 425 "4875206425711159855030832837132149513512555214958035390490" + 426 "798520842025826.594316163502809818340013610490541783276343" + 427 "6514490899700151256484355936102754469438371850240000000000"; 428 int cScale = 100; 429 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 430 BigDecimal result = aNumber.pow(exp); 431 assertEquals("incorrect value", c, result.toString()); 432 assertEquals("incorrect scale", cScale, result.scale()); 433 } 434 435 /** 436 * pow(0) 437 */ 438 public void testPow0() { 439 String a = "123121247898748298842980"; 440 int aScale = 10; 441 int exp = 0; 442 String c = "1"; 443 int cScale = 0; 444 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 445 BigDecimal result = aNumber.pow(exp); 446 assertEquals("incorrect value", c, result.toString()); 447 assertEquals("incorrect scale", cScale, result.scale()); 448 } 449 450 /** 451 * ZERO.pow(0) 452 */ 453 public void testZeroPow0() { 454 String c = "1"; 455 int cScale = 0; 456 BigDecimal result = BigDecimal.ZERO.pow(0); 457 assertEquals("incorrect value", c, result.toString()); 458 assertEquals("incorrect scale", cScale, result.scale()); 459 } 460 461 /** 462 * pow(int, MathContext) 463 */ 464 public void testPowMathContext() { 465 String a = "123121247898748298842980"; 466 int aScale = 10; 467 int exp = 10; 468 String c = "8.0044E+130"; 469 int cScale = -126; 470 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 471 MathContext mc = new MathContext(5, RoundingMode.HALF_UP); 472 BigDecimal result = aNumber.pow(exp, mc); 473 assertEquals("incorrect value", c, result.toString()); 474 assertEquals("incorrect scale", cScale, result.scale()); 475 } 476 477 /** 478 * Divide by zero 479 */ 480 public void testDivideByZero() { 481 String a = "1231212478987482988429808779810457634781384756794987"; 482 int aScale = 15; 483 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 484 BigDecimal bNumber = BigDecimal.valueOf(0L); 485 try { 486 aNumber.divide(bNumber); 487 fail("ArithmeticException has not been caught"); 488 } catch (ArithmeticException e) { 489 assertEquals("Improper exception message", "Division by zero", e.getMessage()); 490 } 491 } 492 493 /** 494 * Divide with ROUND_UNNECESSARY 495 */ 496 public void testDivideExceptionRM() { 497 String a = "1231212478987482988429808779810457634781384756794987"; 498 int aScale = 15; 499 String b = "747233429293018787918347987234564568"; 500 int bScale = 10; 501 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 502 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 503 try { 504 aNumber.divide(bNumber, BigDecimal.ROUND_UNNECESSARY); 505 fail("ArithmeticException has not been caught"); 506 } catch (ArithmeticException e) { 507 assertEquals("Improper exception message", "Rounding necessary", e.getMessage()); 508 } 509 } 510 511 /** 512 * Divide with invalid rounding mode 513 */ 514 public void testDivideExceptionInvalidRM() { 515 String a = "1231212478987482988429808779810457634781384756794987"; 516 int aScale = 15; 517 String b = "747233429293018787918347987234564568"; 518 int bScale = 10; 519 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 520 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 521 try { 522 aNumber.divide(bNumber, 100); 523 fail("IllegalArgumentException has not been caught"); 524 } catch (IllegalArgumentException e) { 525 assertEquals("Improper exception message", "Invalid rounding mode", e.getMessage()); 526 } 527 } 528 529 /** 530 * Divide: local variable exponent is less than zero 531 */ 532 public void testDivideExpLessZero() { 533 String a = "1231212478987482988429808779810457634781384756794987"; 534 int aScale = 15; 535 String b = "747233429293018787918347987234564568"; 536 int bScale = 10; 537 String c = "1.64770E+10"; 538 int resScale = -5; 539 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 540 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 541 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING); 542 assertEquals("incorrect value", c, result.toString()); 543 assertEquals("incorrect scale", resScale, result.scale()); 544 } 545 546 /** 547 * Divide: local variable exponent is equal to zero 548 */ 549 public void testDivideExpEqualsZero() { 550 String a = "1231212478987482988429808779810457634781384756794987"; 551 int aScale = -15; 552 String b = "747233429293018787918347987234564568"; 553 int bScale = 10; 554 String c = "1.64769459009933764189139568605273529E+40"; 555 int resScale = -5; 556 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 557 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 558 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING); 559 assertEquals("incorrect value", c, result.toString()); 560 assertEquals("incorrect scale", resScale, result.scale()); 561 } 562 563 /** 564 * Divide: local variable exponent is greater than zero 565 */ 566 public void testDivideExpGreaterZero() { 567 String a = "1231212478987482988429808779810457634781384756794987"; 568 int aScale = -15; 569 String b = "747233429293018787918347987234564568"; 570 int bScale = 20; 571 String c = "1.647694590099337641891395686052735285121058381E+50"; 572 int resScale = -5; 573 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 574 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 575 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING); 576 assertEquals("incorrect value", c, result.toString()); 577 assertEquals("incorrect scale", resScale, result.scale()); 578 } 579 580 /** 581 * Divide: remainder is zero 582 */ 583 public void testDivideRemainderIsZero() { 584 String a = "8311389578904553209874735431110"; 585 int aScale = -15; 586 String b = "237468273682987234567849583746"; 587 int bScale = 20; 588 String c = "3.5000000000000000000000000000000E+36"; 589 int resScale = -5; 590 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 591 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 592 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING); 593 assertEquals("incorrect value", c, result.toString()); 594 assertEquals("incorrect scale", resScale, result.scale()); 595 } 596 597 /** 598 * Divide: rounding mode is ROUND_UP, result is negative 599 */ 600 public void testDivideRoundUpNeg() { 601 String a = "-92948782094488478231212478987482988429808779810457634781384756794987"; 602 int aScale = -24; 603 String b = "7472334223847623782375469293018787918347987234564568"; 604 int bScale = 13; 605 String c = "-1.24390557635720517122423359799284E+53"; 606 int resScale = -21; 607 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 608 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 609 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_UP); 610 assertEquals("incorrect value", c, result.toString()); 611 assertEquals("incorrect scale", resScale, result.scale()); 612 } 613 614 /** 615 * Divide: rounding mode is ROUND_UP, result is positive 616 */ 617 public void testDivideRoundUpPos() { 618 String a = "92948782094488478231212478987482988429808779810457634781384756794987"; 619 int aScale = -24; 620 String b = "7472334223847623782375469293018787918347987234564568"; 621 int bScale = 13; 622 String c = "1.24390557635720517122423359799284E+53"; 623 int resScale = -21; 624 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 625 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 626 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_UP); 627 assertEquals("incorrect value", c, result.toString()); 628 assertEquals("incorrect scale", resScale, result.scale()); 629 } 630 631 /** 632 * Divide: rounding mode is ROUND_DOWN, result is negative 633 */ 634 public void testDivideRoundDownNeg() { 635 String a = "-92948782094488478231212478987482988429808779810457634781384756794987"; 636 int aScale = -24; 637 String b = "7472334223847623782375469293018787918347987234564568"; 638 int bScale = 13; 639 String c = "-1.24390557635720517122423359799283E+53"; 640 int resScale = -21; 641 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 642 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 643 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_DOWN); 644 assertEquals("incorrect value", c, result.toString()); 645 assertEquals("incorrect scale", resScale, result.scale()); 646 } 647 648 /** 649 * Divide: rounding mode is ROUND_DOWN, result is positive 650 */ 651 public void testDivideRoundDownPos() { 652 String a = "92948782094488478231212478987482988429808779810457634781384756794987"; 653 int aScale = -24; 654 String b = "7472334223847623782375469293018787918347987234564568"; 655 int bScale = 13; 656 String c = "1.24390557635720517122423359799283E+53"; 657 int resScale = -21; 658 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 659 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 660 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_DOWN); 661 assertEquals("incorrect value", c, result.toString()); 662 assertEquals("incorrect scale", resScale, result.scale()); 663 } 664 665 /** 666 * Divide: rounding mode is ROUND_FLOOR, result is positive 667 */ 668 public void testDivideRoundFloorPos() { 669 String a = "92948782094488478231212478987482988429808779810457634781384756794987"; 670 int aScale = -24; 671 String b = "7472334223847623782375469293018787918347987234564568"; 672 int bScale = 13; 673 String c = "1.24390557635720517122423359799283E+53"; 674 int resScale = -21; 675 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 676 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 677 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_FLOOR); 678 assertEquals("incorrect value", c, result.toString()); 679 assertEquals("incorrect scale", resScale, result.scale()); 680 } 681 682 /** 683 * Divide: rounding mode is ROUND_FLOOR, result is negative 684 */ 685 public void testDivideRoundFloorNeg() { 686 String a = "-92948782094488478231212478987482988429808779810457634781384756794987"; 687 int aScale = -24; 688 String b = "7472334223847623782375469293018787918347987234564568"; 689 int bScale = 13; 690 String c = "-1.24390557635720517122423359799284E+53"; 691 int resScale = -21; 692 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 693 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 694 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_FLOOR); 695 assertEquals("incorrect value", c, result.toString()); 696 assertEquals("incorrect scale", resScale, result.scale()); 697 } 698 699 /** 700 * Divide: rounding mode is ROUND_CEILING, result is positive 701 */ 702 public void testDivideRoundCeilingPos() { 703 String a = "92948782094488478231212478987482988429808779810457634781384756794987"; 704 int aScale = -24; 705 String b = "7472334223847623782375469293018787918347987234564568"; 706 int bScale = 13; 707 String c = "1.24390557635720517122423359799284E+53"; 708 int resScale = -21; 709 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 710 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 711 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING); 712 assertEquals("incorrect value", c, result.toString()); 713 assertEquals("incorrect scale", resScale, result.scale()); 714 } 715 716 /** 717 * Divide: rounding mode is ROUND_CEILING, result is negative 718 */ 719 public void testDivideRoundCeilingNeg() { 720 String a = "-92948782094488478231212478987482988429808779810457634781384756794987"; 721 int aScale = -24; 722 String b = "7472334223847623782375469293018787918347987234564568"; 723 int bScale = 13; 724 String c = "-1.24390557635720517122423359799283E+53"; 725 int resScale = -21; 726 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 727 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 728 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING); 729 assertEquals("incorrect value", c, result.toString()); 730 assertEquals("incorrect scale", resScale, result.scale()); 731 } 732 733 /** 734 * Divide: rounding mode is ROUND_HALF_UP, result is positive; distance = -1 735 */ 736 public void testDivideRoundHalfUpPos() { 737 String a = "92948782094488478231212478987482988429808779810457634781384756794987"; 738 int aScale = -24; 739 String b = "7472334223847623782375469293018787918347987234564568"; 740 int bScale = 13; 741 String c = "1.24390557635720517122423359799284E+53"; 742 int resScale = -21; 743 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 744 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 745 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP); 746 assertEquals("incorrect value", c, result.toString()); 747 assertEquals("incorrect scale", resScale, result.scale()); 748 } 749 750 /** 751 * Divide: rounding mode is ROUND_HALF_UP, result is negative; distance = -1 752 */ 753 public void testDivideRoundHalfUpNeg() { 754 String a = "-92948782094488478231212478987482988429808779810457634781384756794987"; 755 int aScale = -24; 756 String b = "7472334223847623782375469293018787918347987234564568"; 757 int bScale = 13; 758 String c = "-1.24390557635720517122423359799284E+53"; 759 int resScale = -21; 760 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 761 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 762 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP); 763 assertEquals("incorrect value", c, result.toString()); 764 assertEquals("incorrect scale", resScale, result.scale()); 765 } 766 767 /** 768 * Divide: rounding mode is ROUND_HALF_UP, result is positive; distance = 1 769 */ 770 public void testDivideRoundHalfUpPos1() { 771 String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456"; 772 int aScale = -24; 773 String b = "74723342238476237823754692930187879183479"; 774 int bScale = 13; 775 String c = "1.2439055763572051712242335979928354832010167729111113605E+76"; 776 int resScale = -21; 777 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 778 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 779 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP); 780 assertEquals("incorrect value", c, result.toString()); 781 assertEquals("incorrect scale", resScale, result.scale()); 782 } 783 784 /** 785 * Divide: rounding mode is ROUND_HALF_UP, result is negative; distance = 1 786 */ 787 public void testDivideRoundHalfUpNeg1() { 788 String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456"; 789 int aScale = -24; 790 String b = "74723342238476237823754692930187879183479"; 791 int bScale = 13; 792 String c = "-1.2439055763572051712242335979928354832010167729111113605E+76"; 793 int resScale = -21; 794 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 795 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 796 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP); 797 assertEquals("incorrect value", c, result.toString()); 798 assertEquals("incorrect scale", resScale, result.scale()); 799 } 800 801 /** 802 * Divide: rounding mode is ROUND_HALF_UP, result is negative; equidistant 803 */ 804 public void testDivideRoundHalfUpNeg2() { 805 String a = "-37361671119238118911893939591735"; 806 int aScale = 10; 807 String b = "74723342238476237823787879183470"; 808 int bScale = 15; 809 String c = "-1E+5"; 810 int resScale = -5; 811 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 812 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 813 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_UP); 814 assertEquals("incorrect value", c, result.toString()); 815 assertEquals("incorrect scale", resScale, result.scale()); 816 } 817 818 /** 819 * Divide: rounding mode is ROUND_HALF_DOWN, result is positive; distance = -1 820 */ 821 public void testDivideRoundHalfDownPos() { 822 String a = "92948782094488478231212478987482988429808779810457634781384756794987"; 823 int aScale = -24; 824 String b = "7472334223847623782375469293018787918347987234564568"; 825 int bScale = 13; 826 String c = "1.24390557635720517122423359799284E+53"; 827 int resScale = -21; 828 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 829 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 830 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN); 831 assertEquals("incorrect value", c, result.toString()); 832 assertEquals("incorrect scale", resScale, result.scale()); 833 } 834 835 /** 836 * Divide: rounding mode is ROUND_HALF_DOWN, result is negative; distance = -1 837 */ 838 public void testDivideRoundHalfDownNeg() { 839 String a = "-92948782094488478231212478987482988429808779810457634781384756794987"; 840 int aScale = -24; 841 String b = "7472334223847623782375469293018787918347987234564568"; 842 int bScale = 13; 843 String c = "-1.24390557635720517122423359799284E+53"; 844 int resScale = -21; 845 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 846 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 847 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN); 848 assertEquals("incorrect value", c, result.toString()); 849 assertEquals("incorrect scale", resScale, result.scale()); 850 } 851 852 /** 853 * Divide: rounding mode is ROUND_HALF_DOWN, result is positive; distance = 1 854 */ 855 public void testDivideRoundHalfDownPos1() { 856 String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456"; 857 int aScale = -24; 858 String b = "74723342238476237823754692930187879183479"; 859 int bScale = 13; 860 String c = "1.2439055763572051712242335979928354832010167729111113605E+76"; 861 int resScale = -21; 862 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 863 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 864 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN); 865 assertEquals("incorrect value", c, result.toString()); 866 assertEquals("incorrect scale", resScale, result.scale()); 867 } 868 869 /** 870 * Divide: rounding mode is ROUND_HALF_DOWN, result is negative; distance = 1 871 */ 872 public void testDivideRoundHalfDownNeg1() { 873 String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456"; 874 int aScale = -24; 875 String b = "74723342238476237823754692930187879183479"; 876 int bScale = 13; 877 String c = "-1.2439055763572051712242335979928354832010167729111113605E+76"; 878 int resScale = -21; 879 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 880 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 881 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN); 882 assertEquals("incorrect value", c, result.toString()); 883 assertEquals("incorrect scale", resScale, result.scale()); 884 } 885 886 /** 887 * Divide: rounding mode is ROUND_HALF_UP, result is negative; equidistant 888 */ 889 public void testDivideRoundHalfDownNeg2() { 890 String a = "-37361671119238118911893939591735"; 891 int aScale = 10; 892 String b = "74723342238476237823787879183470"; 893 int bScale = 15; 894 String c = "0E+5"; 895 int resScale = -5; 896 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 897 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 898 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_DOWN); 899 assertEquals("incorrect value", c, result.toString()); 900 assertEquals("incorrect scale", resScale, result.scale()); 901 } 902 903 /** 904 * Divide: rounding mode is ROUND_HALF_EVEN, result is positive; distance = -1 905 */ 906 public void testDivideRoundHalfEvenPos() { 907 String a = "92948782094488478231212478987482988429808779810457634781384756794987"; 908 int aScale = -24; 909 String b = "7472334223847623782375469293018787918347987234564568"; 910 int bScale = 13; 911 String c = "1.24390557635720517122423359799284E+53"; 912 int resScale = -21; 913 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 914 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 915 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN); 916 assertEquals("incorrect value", c, result.toString()); 917 assertEquals("incorrect scale", resScale, result.scale()); 918 } 919 920 /** 921 * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; distance = -1 922 */ 923 public void testDivideRoundHalfEvenNeg() { 924 String a = "-92948782094488478231212478987482988429808779810457634781384756794987"; 925 int aScale = -24; 926 String b = "7472334223847623782375469293018787918347987234564568"; 927 int bScale = 13; 928 String c = "-1.24390557635720517122423359799284E+53"; 929 int resScale = -21; 930 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 931 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 932 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN); 933 assertEquals("incorrect value", c, result.toString()); 934 assertEquals("incorrect scale", resScale, result.scale()); 935 } 936 937 /** 938 * Divide: rounding mode is ROUND_HALF_EVEN, result is positive; distance = 1 939 */ 940 public void testDivideRoundHalfEvenPos1() { 941 String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456"; 942 int aScale = -24; 943 String b = "74723342238476237823754692930187879183479"; 944 int bScale = 13; 945 String c = "1.2439055763572051712242335979928354832010167729111113605E+76"; 946 int resScale = -21; 947 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 948 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 949 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN); 950 assertEquals("incorrect value", c, result.toString()); 951 assertEquals("incorrect scale", resScale, result.scale()); 952 } 953 954 /** 955 * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; distance = 1 956 */ 957 public void testDivideRoundHalfEvenNeg1() { 958 String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456"; 959 int aScale = -24; 960 String b = "74723342238476237823754692930187879183479"; 961 int bScale = 13; 962 String c = "-1.2439055763572051712242335979928354832010167729111113605E+76"; 963 int resScale = -21; 964 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 965 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 966 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN); 967 assertEquals("incorrect value", c, result.toString()); 968 assertEquals("incorrect scale", resScale, result.scale()); 969 } 970 971 /** 972 * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; equidistant 973 */ 974 public void testDivideRoundHalfEvenNeg2() { 975 String a = "-37361671119238118911893939591735"; 976 int aScale = 10; 977 String b = "74723342238476237823787879183470"; 978 int bScale = 15; 979 String c = "0E+5"; 980 int resScale = -5; 981 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 982 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 983 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_HALF_EVEN); 984 assertEquals("incorrect value", c, result.toString()); 985 assertEquals("incorrect scale", resScale, result.scale()); 986 } 987 988 /** 989 * Divide to BigDecimal 990 */ 991 public void testDivideBigDecimal1() { 992 String a = "-37361671119238118911893939591735"; 993 int aScale = 10; 994 String b = "74723342238476237823787879183470"; 995 int bScale = 15; 996 String c = "-5E+4"; 997 int resScale = -4; 998 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 999 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1000 BigDecimal result = aNumber.divide(bNumber); 1001 assertEquals("incorrect value", c, result.toString()); 1002 assertEquals("incorrect scale", resScale, result.scale()); 1003 } 1004 1005 /** 1006 * Divide to BigDecimal 1007 */ 1008 public void testDivideBigDecimal2() { 1009 String a = "-37361671119238118911893939591735"; 1010 int aScale = 10; 1011 String b = "74723342238476237823787879183470"; 1012 int bScale = -15; 1013 String c = "-5E-26"; 1014 int resScale = 26; 1015 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1016 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1017 BigDecimal result = aNumber.divide(bNumber); 1018 assertEquals("incorrect value", c, result.toString()); 1019 assertEquals("incorrect scale", resScale, result.scale()); 1020 } 1021 1022 /** 1023 * divide(BigDecimal, scale, RoundingMode) 1024 */ 1025 public void testDivideBigDecimalScaleRoundingModeUP() { 1026 String a = "-37361671119238118911893939591735"; 1027 int aScale = 10; 1028 String b = "74723342238476237823787879183470"; 1029 int bScale = -15; 1030 int newScale = 31; 1031 RoundingMode rm = RoundingMode.UP; 1032 String c = "-5.00000E-26"; 1033 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1034 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1035 BigDecimal result = aNumber.divide(bNumber, newScale, rm); 1036 assertEquals("incorrect value", c, result.toString()); 1037 assertEquals("incorrect scale", newScale, result.scale()); 1038 } 1039 1040 /** 1041 * divide(BigDecimal, scale, RoundingMode) 1042 */ 1043 public void testDivideBigDecimalScaleRoundingModeDOWN() { 1044 String a = "-37361671119238118911893939591735"; 1045 int aScale = 10; 1046 String b = "74723342238476237823787879183470"; 1047 int bScale = 15; 1048 int newScale = 31; 1049 RoundingMode rm = RoundingMode.DOWN; 1050 String c = "-50000.0000000000000000000000000000000"; 1051 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1052 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1053 BigDecimal result = aNumber.divide(bNumber, newScale, rm); 1054 assertEquals("incorrect value", c, result.toString()); 1055 assertEquals("incorrect scale", newScale, result.scale()); 1056 } 1057 1058 /** 1059 * divide(BigDecimal, scale, RoundingMode) 1060 */ 1061 public void testDivideBigDecimalScaleRoundingModeCEILING() { 1062 String a = "3736186567876876578956958765675671119238118911893939591735"; 1063 int aScale = 100; 1064 String b = "74723342238476237823787879183470"; 1065 int bScale = 15; 1066 int newScale = 45; 1067 RoundingMode rm = RoundingMode.CEILING; 1068 String c = "1E-45"; 1069 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1070 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1071 BigDecimal result = aNumber.divide(bNumber, newScale, rm); 1072 assertEquals("incorrect value", c, result.toString()); 1073 assertEquals("incorrect scale", newScale, result.scale()); 1074 } 1075 1076 /** 1077 * divide(BigDecimal, scale, RoundingMode) 1078 */ 1079 public void testDivideBigDecimalScaleRoundingModeFLOOR() { 1080 String a = "3736186567876876578956958765675671119238118911893939591735"; 1081 int aScale = 100; 1082 String b = "74723342238476237823787879183470"; 1083 int bScale = 15; 1084 int newScale = 45; 1085 RoundingMode rm = RoundingMode.FLOOR; 1086 String c = "0E-45"; 1087 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1088 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1089 BigDecimal result = aNumber.divide(bNumber, newScale, rm); 1090 assertEquals("incorrect value", c, result.toString()); 1091 assertEquals("incorrect scale", newScale, result.scale()); 1092 } 1093 1094 /** 1095 * divide(BigDecimal, scale, RoundingMode) 1096 */ 1097 public void testDivideBigDecimalScaleRoundingModeHALF_UP() { 1098 String a = "3736186567876876578956958765675671119238118911893939591735"; 1099 int aScale = -51; 1100 String b = "74723342238476237823787879183470"; 1101 int bScale = 45; 1102 int newScale = 3; 1103 RoundingMode rm = RoundingMode.HALF_UP; 1104 String c = "50000260373164286401361913262100972218038099522752460421" + 1105 "05959924024355721031761947728703598332749334086415670525" + 1106 "3761096961.670"; 1107 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1108 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1109 BigDecimal result = aNumber.divide(bNumber, newScale, rm); 1110 assertEquals("incorrect value", c, result.toString()); 1111 assertEquals("incorrect scale", newScale, result.scale()); 1112 } 1113 1114 /** 1115 * divide(BigDecimal, scale, RoundingMode) 1116 */ 1117 public void testDivideBigDecimalScaleRoundingModeHALF_DOWN() { 1118 String a = "3736186567876876578956958765675671119238118911893939591735"; 1119 int aScale = 5; 1120 String b = "74723342238476237823787879183470"; 1121 int bScale = 15; 1122 int newScale = 7; 1123 RoundingMode rm = RoundingMode.HALF_DOWN; 1124 String c = "500002603731642864013619132621009722.1803810"; 1125 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1126 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1127 BigDecimal result = aNumber.divide(bNumber, newScale, rm); 1128 assertEquals("incorrect value", c, result.toString()); 1129 assertEquals("incorrect scale", newScale, result.scale()); 1130 } 1131 1132 /** 1133 * divide(BigDecimal, scale, RoundingMode) 1134 */ 1135 public void testDivideBigDecimalScaleRoundingModeHALF_EVEN() { 1136 String a = "3736186567876876578956958765675671119238118911893939591735"; 1137 int aScale = 5; 1138 String b = "74723342238476237823787879183470"; 1139 int bScale = 15; 1140 int newScale = 7; 1141 RoundingMode rm = RoundingMode.HALF_EVEN; 1142 String c = "500002603731642864013619132621009722.1803810"; 1143 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1144 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1145 BigDecimal result = aNumber.divide(bNumber, newScale, rm); 1146 assertEquals("incorrect value", c, result.toString()); 1147 assertEquals("incorrect scale", newScale, result.scale()); 1148 } 1149 1150 /** 1151 * divide(BigDecimal, MathContext) 1152 */ 1153 public void testDivideBigDecimalScaleMathContextUP() { 1154 String a = "3736186567876876578956958765675671119238118911893939591735"; 1155 int aScale = 15; 1156 String b = "748766876876723342238476237823787879183470"; 1157 int bScale = 10; 1158 int precision = 21; 1159 RoundingMode rm = RoundingMode.UP; 1160 MathContext mc = new MathContext(precision, rm); 1161 String c = "49897861180.2562512996"; 1162 int resScale = 10; 1163 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1164 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1165 BigDecimal result = aNumber.divide(bNumber, mc); 1166 assertEquals("incorrect value", c, result.toString()); 1167 assertEquals("incorrect scale", resScale, result.scale()); 1168 } 1169 1170 /** 1171 * divide(BigDecimal, MathContext) 1172 */ 1173 public void testDivideBigDecimalScaleMathContextDOWN() { 1174 String a = "3736186567876876578956958765675671119238118911893939591735"; 1175 int aScale = 15; 1176 String b = "748766876876723342238476237823787879183470"; 1177 int bScale = 70; 1178 int precision = 21; 1179 RoundingMode rm = RoundingMode.DOWN; 1180 MathContext mc = new MathContext(precision, rm); 1181 String c = "4.98978611802562512995E+70"; 1182 int resScale = -50; 1183 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1184 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1185 BigDecimal result = aNumber.divide(bNumber, mc); 1186 assertEquals("incorrect value", c, result.toString()); 1187 assertEquals("incorrect scale", resScale, result.scale()); 1188 } 1189 1190 /** 1191 * divide(BigDecimal, MathContext) 1192 */ 1193 public void testDivideBigDecimalScaleMathContextCEILING() { 1194 String a = "3736186567876876578956958765675671119238118911893939591735"; 1195 int aScale = 15; 1196 String b = "748766876876723342238476237823787879183470"; 1197 int bScale = 70; 1198 int precision = 21; 1199 RoundingMode rm = RoundingMode.CEILING; 1200 MathContext mc = new MathContext(precision, rm); 1201 String c = "4.98978611802562512996E+70"; 1202 int resScale = -50; 1203 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1204 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1205 BigDecimal result = aNumber.divide(bNumber, mc); 1206 assertEquals("incorrect value", c, result.toString()); 1207 assertEquals("incorrect scale", resScale, result.scale()); 1208 } 1209 1210 /** 1211 * divide(BigDecimal, MathContext) 1212 */ 1213 public void testDivideBigDecimalScaleMathContextFLOOR() { 1214 String a = "3736186567876876578956958765675671119238118911893939591735"; 1215 int aScale = 15; 1216 String b = "748766876876723342238476237823787879183470"; 1217 int bScale = 70; 1218 int precision = 21; 1219 RoundingMode rm = RoundingMode.FLOOR; 1220 MathContext mc = new MathContext(precision, rm); 1221 String c = "4.98978611802562512995E+70"; 1222 int resScale = -50; 1223 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1224 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1225 BigDecimal result = aNumber.divide(bNumber, mc); 1226 assertEquals("incorrect value", c, result.toString()); 1227 assertEquals("incorrect scale", resScale, result.scale()); 1228 } 1229 1230 /** 1231 * divide(BigDecimal, MathContext) 1232 */ 1233 public void testDivideBigDecimalScaleMathContextHALF_UP() { 1234 String a = "3736186567876876578956958765675671119238118911893939591735"; 1235 int aScale = 45; 1236 String b = "134432345432345748766876876723342238476237823787879183470"; 1237 int bScale = 70; 1238 int precision = 21; 1239 RoundingMode rm = RoundingMode.HALF_UP; 1240 MathContext mc = new MathContext(precision, rm); 1241 String c = "2.77923185514690367475E+26"; 1242 int resScale = -6; 1243 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1244 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1245 BigDecimal result = aNumber.divide(bNumber, mc); 1246 assertEquals("incorrect value", c, result.toString()); 1247 assertEquals("incorrect scale", resScale, result.scale()); 1248 } 1249 1250 /** 1251 * divide(BigDecimal, MathContext) 1252 */ 1253 public void testDivideBigDecimalScaleMathContextHALF_DOWN() { 1254 String a = "3736186567876876578956958765675671119238118911893939591735"; 1255 int aScale = 45; 1256 String b = "134432345432345748766876876723342238476237823787879183470"; 1257 int bScale = 70; 1258 int precision = 21; 1259 RoundingMode rm = RoundingMode.HALF_DOWN; 1260 MathContext mc = new MathContext(precision, rm); 1261 String c = "2.77923185514690367475E+26"; 1262 int resScale = -6; 1263 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1264 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1265 BigDecimal result = aNumber.divide(bNumber, mc); 1266 assertEquals("incorrect value", c, result.toString()); 1267 assertEquals("incorrect scale", resScale, result.scale()); 1268 } 1269 1270 /** 1271 * divide(BigDecimal, MathContext) 1272 */ 1273 public void testDivideBigDecimalScaleMathContextHALF_EVEN() { 1274 String a = "3736186567876876578956958765675671119238118911893939591735"; 1275 int aScale = 45; 1276 String b = "134432345432345748766876876723342238476237823787879183470"; 1277 int bScale = 70; 1278 int precision = 21; 1279 RoundingMode rm = RoundingMode.HALF_EVEN; 1280 MathContext mc = new MathContext(precision, rm); 1281 String c = "2.77923185514690367475E+26"; 1282 int resScale = -6; 1283 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1284 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1285 BigDecimal result = aNumber.divide(bNumber, mc); 1286 assertEquals("incorrect value", c, result.toString()); 1287 assertEquals("incorrect scale", resScale, result.scale()); 1288 } 1289 1290 1291 /** 1292 * BigDecimal.divide with a scale that's too large 1293 * 1294 * Regression test for HARMONY-6271 1295 */ 1296 public void testDivideLargeScale() { 1297 BigDecimal arg1 = new BigDecimal("320.0E+2147483647"); 1298 BigDecimal arg2 = new BigDecimal("6E-2147483647"); 1299 try { 1300 BigDecimal result = arg1.divide(arg2, Integer.MAX_VALUE, 1301 java.math.RoundingMode.CEILING); 1302 fail("Expected ArithmeticException when dividing with a scale that's too large"); 1303 } catch (ArithmeticException e) { 1304 // expected behaviour 1305 } 1306 } 1307 1308 /** 1309 * divideToIntegralValue(BigDecimal) 1310 */ 1311 public void testDivideToIntegralValue() { 1312 String a = "3736186567876876578956958765675671119238118911893939591735"; 1313 int aScale = 45; 1314 String b = "134432345432345748766876876723342238476237823787879183470"; 1315 int bScale = 70; 1316 String c = "277923185514690367474770683"; 1317 int resScale = 0; 1318 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1319 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1320 BigDecimal result = aNumber.divideToIntegralValue(bNumber); 1321 assertEquals("incorrect value", c, result.toString()); 1322 assertEquals("incorrect scale", resScale, result.scale()); 1323 } 1324 1325 /** 1326 * divideToIntegralValue(BigDecimal, MathContext) 1327 */ 1328 public void testDivideToIntegralValueMathContextUP() { 1329 String a = "3736186567876876578956958765675671119238118911893939591735"; 1330 int aScale = 45; 1331 String b = "134432345432345748766876876723342238476237823787879183470"; 1332 int bScale = 70; 1333 int precision = 32; 1334 RoundingMode rm = RoundingMode.UP; 1335 MathContext mc = new MathContext(precision, rm); 1336 String c = "277923185514690367474770683"; 1337 int resScale = 0; 1338 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1339 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1340 BigDecimal result = aNumber.divideToIntegralValue(bNumber, mc); 1341 assertEquals("incorrect value", c, result.toString()); 1342 assertEquals("incorrect scale", resScale, result.scale()); 1343 } 1344 1345 /** 1346 * divideToIntegralValue(BigDecimal, MathContext) 1347 */ 1348 public void testDivideToIntegralValueMathContextDOWN() { 1349 String a = "3736186567876876578956958769675785435673453453653543654354365435675671119238118911893939591735"; 1350 int aScale = 45; 1351 String b = "134432345432345748766876876723342238476237823787879183470"; 1352 int bScale = 70; 1353 int precision = 75; 1354 RoundingMode rm = RoundingMode.DOWN; 1355 MathContext mc = new MathContext(precision, rm); 1356 String c = "2.7792318551469036747477068339450205874992634417590178670822889E+62"; 1357 int resScale = -1; 1358 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1359 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1360 BigDecimal result = aNumber.divideToIntegralValue(bNumber, mc); 1361 assertEquals("incorrect value", c, result.toString()); 1362 assertEquals("incorrect scale", resScale, result.scale()); 1363 } 1364 1365 /** 1366 * divideAndRemainder(BigDecimal) 1367 */ 1368 public void testDivideAndRemainder1() { 1369 String a = "3736186567876876578956958765675671119238118911893939591735"; 1370 int aScale = 45; 1371 String b = "134432345432345748766876876723342238476237823787879183470"; 1372 int bScale = 70; 1373 String res = "277923185514690367474770683"; 1374 int resScale = 0; 1375 String rem = "1.3032693871288309587558885943391070087960319452465789990E-15"; 1376 int remScale = 70; 1377 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1378 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1379 BigDecimal result[] = aNumber.divideAndRemainder(bNumber); 1380 assertEquals("incorrect quotient value", res, result[0].toString()); 1381 assertEquals("incorrect quotient scale", resScale, result[0].scale()); 1382 assertEquals("incorrect remainder value", rem, result[1].toString()); 1383 assertEquals("incorrect remainder scale", remScale, result[1].scale()); 1384 } 1385 1386 /** 1387 * divideAndRemainder(BigDecimal) 1388 */ 1389 public void testDivideAndRemainder2() { 1390 String a = "3736186567876876578956958765675671119238118911893939591735"; 1391 int aScale = -45; 1392 String b = "134432345432345748766876876723342238476237823787879183470"; 1393 int bScale = 70; 1394 String res = "2779231855146903674747706830969461168692256919247547952" + 1395 "2608549363170374005512836303475980101168105698072946555" + 1396 "6862849"; 1397 int resScale = 0; 1398 String rem = "3.4935796954060524114470681810486417234751682675102093970E-15"; 1399 int remScale = 70; 1400 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1401 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1402 BigDecimal result[] = aNumber.divideAndRemainder(bNumber); 1403 assertEquals("incorrect quotient value", res, result[0].toString()); 1404 assertEquals("incorrect quotient scale", resScale, result[0].scale()); 1405 assertEquals("incorrect remainder value", rem, result[1].toString()); 1406 assertEquals("incorrect remainder scale", remScale, result[1].scale()); 1407 } 1408 1409 /** 1410 * divideAndRemainder(BigDecimal, MathContext) 1411 */ 1412 public void testDivideAndRemainderMathContextUP() { 1413 String a = "3736186567876876578956958765675671119238118911893939591735"; 1414 int aScale = 45; 1415 String b = "134432345432345748766876876723342238476237823787879183470"; 1416 int bScale = 70; 1417 int precision = 75; 1418 RoundingMode rm = RoundingMode.UP; 1419 MathContext mc = new MathContext(precision, rm); 1420 String res = "277923185514690367474770683"; 1421 int resScale = 0; 1422 String rem = "1.3032693871288309587558885943391070087960319452465789990E-15"; 1423 int remScale = 70; 1424 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1425 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1426 BigDecimal result[] = aNumber.divideAndRemainder(bNumber, mc); 1427 assertEquals("incorrect quotient value", res, result[0].toString()); 1428 assertEquals("incorrect quotient scale", resScale, result[0].scale()); 1429 assertEquals("incorrect remainder value", rem, result[1].toString()); 1430 assertEquals("incorrect remainder scale", remScale, result[1].scale()); 1431 } 1432 1433 /** 1434 * divideAndRemainder(BigDecimal, MathContext) 1435 */ 1436 public void testDivideAndRemainderMathContextDOWN() { 1437 String a = "3736186567876876578956958765675671119238118911893939591735"; 1438 int aScale = 45; 1439 String b = "134432345432345748766876876723342238476237823787879183470"; 1440 int bScale = 20; 1441 int precision = 15; 1442 RoundingMode rm = RoundingMode.DOWN; 1443 MathContext mc = new MathContext(precision, rm); 1444 String res = "0E-25"; 1445 int resScale = 25; 1446 String rem = "3736186567876.876578956958765675671119238118911893939591735"; 1447 int remScale = 45; 1448 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1449 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1450 BigDecimal result[] = aNumber.divideAndRemainder(bNumber, mc); 1451 assertEquals("incorrect quotient value", res, result[0].toString()); 1452 assertEquals("incorrect quotient scale", resScale, result[0].scale()); 1453 assertEquals("incorrect remainder value", rem, result[1].toString()); 1454 assertEquals("incorrect remainder scale", remScale, result[1].scale()); 1455 } 1456 1457 /** 1458 * remainder(BigDecimal) 1459 */ 1460 public void testRemainder1() { 1461 String a = "3736186567876876578956958765675671119238118911893939591735"; 1462 int aScale = 45; 1463 String b = "134432345432345748766876876723342238476237823787879183470"; 1464 int bScale = 10; 1465 String res = "3736186567876.876578956958765675671119238118911893939591735"; 1466 int resScale = 45; 1467 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1468 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1469 BigDecimal result = aNumber.remainder(bNumber); 1470 assertEquals("incorrect quotient value", res, result.toString()); 1471 assertEquals("incorrect quotient scale", resScale, result.scale()); 1472 } 1473 1474 /** 1475 * remainder(BigDecimal) 1476 */ 1477 public void testRemainder2() { 1478 String a = "3736186567876876578956958765675671119238118911893939591735"; 1479 int aScale = -45; 1480 String b = "134432345432345748766876876723342238476237823787879183470"; 1481 int bScale = 10; 1482 String res = "1149310942946292909508821656680979993738625937.2065885780"; 1483 int resScale = 10; 1484 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1485 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1486 BigDecimal result = aNumber.remainder(bNumber); 1487 assertEquals("incorrect quotient value", res, result.toString()); 1488 assertEquals("incorrect quotient scale", resScale, result.scale()); 1489 } 1490 1491 /** 1492 * remainder(BigDecimal, MathContext) 1493 */ 1494 public void testRemainderMathContextHALF_UP() { 1495 String a = "3736186567876876578956958765675671119238118911893939591735"; 1496 int aScale = 45; 1497 String b = "134432345432345748766876876723342238476237823787879183470"; 1498 int bScale = 10; 1499 int precision = 15; 1500 RoundingMode rm = RoundingMode.HALF_UP; 1501 MathContext mc = new MathContext(precision, rm); 1502 String res = "3736186567876.876578956958765675671119238118911893939591735"; 1503 int resScale = 45; 1504 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1505 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1506 BigDecimal result = aNumber.remainder(bNumber, mc); 1507 assertEquals("incorrect quotient value", res, result.toString()); 1508 assertEquals("incorrect quotient scale", resScale, result.scale()); 1509 } 1510 1511 /** 1512 * remainder(BigDecimal, MathContext) 1513 */ 1514 public void testRemainderMathContextHALF_DOWN() { 1515 String a = "3736186567876876578956958765675671119238118911893939591735"; 1516 int aScale = -45; 1517 String b = "134432345432345748766876876723342238476237823787879183470"; 1518 int bScale = 10; 1519 int precision = 75; 1520 RoundingMode rm = RoundingMode.HALF_DOWN; 1521 MathContext mc = new MathContext(precision, rm); 1522 String res = "1149310942946292909508821656680979993738625937.2065885780"; 1523 int resScale = 10; 1524 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1525 BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale); 1526 BigDecimal result = aNumber.remainder(bNumber, mc); 1527 assertEquals("incorrect quotient value", res, result.toString()); 1528 assertEquals("incorrect quotient scale", resScale, result.scale()); 1529 } 1530 1531 /** 1532 * round(BigDecimal, MathContext) 1533 */ 1534 public void testRoundMathContextHALF_DOWN() { 1535 String a = "3736186567876876578956958765675671119238118911893939591735"; 1536 int aScale = -45; 1537 int precision = 75; 1538 RoundingMode rm = RoundingMode.HALF_DOWN; 1539 MathContext mc = new MathContext(precision, rm); 1540 String res = "3.736186567876876578956958765675671119238118911893939591735E+102"; 1541 int resScale = -45; 1542 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1543 BigDecimal result = aNumber.round(mc); 1544 assertEquals("incorrect quotient value", res, result.toString()); 1545 assertEquals("incorrect quotient scale", resScale, result.scale()); 1546 } 1547 1548 /** 1549 * round(BigDecimal, MathContext) 1550 */ 1551 public void testRoundMathContextHALF_UP() { 1552 String a = "3736186567876876578956958765675671119238118911893939591735"; 1553 int aScale = 45; 1554 int precision = 15; 1555 RoundingMode rm = RoundingMode.HALF_UP; 1556 MathContext mc = new MathContext(precision, rm); 1557 String res = "3736186567876.88"; 1558 int resScale = 2; 1559 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1560 BigDecimal result = aNumber.round(mc); 1561 assertEquals("incorrect quotient value", res, result.toString()); 1562 assertEquals("incorrect quotient scale", resScale, result.scale()); 1563 } 1564 1565 /** 1566 * round(BigDecimal, MathContext) when precision = 0 1567 */ 1568 public void testRoundMathContextPrecision0() { 1569 String a = "3736186567876876578956958765675671119238118911893939591735"; 1570 int aScale = 45; 1571 int precision = 0; 1572 RoundingMode rm = RoundingMode.HALF_UP; 1573 MathContext mc = new MathContext(precision, rm); 1574 String res = "3736186567876.876578956958765675671119238118911893939591735"; 1575 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1576 BigDecimal result = aNumber.round(mc); 1577 assertEquals("incorrect quotient value", res, result.toString()); 1578 assertEquals("incorrect quotient scale", aScale, result.scale()); 1579 } 1580 1581 1582 /** 1583 * ulp() of a positive BigDecimal 1584 */ 1585 public void testUlpPos() { 1586 String a = "3736186567876876578956958765675671119238118911893939591735"; 1587 int aScale = -45; 1588 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1589 BigDecimal result = aNumber.ulp(); 1590 String res = "1E+45"; 1591 int resScale = -45; 1592 assertEquals("incorrect value", res, result.toString()); 1593 assertEquals("incorrect scale", resScale, result.scale()); 1594 } 1595 1596 /** 1597 * ulp() of a negative BigDecimal 1598 */ 1599 public void testUlpNeg() { 1600 String a = "-3736186567876876578956958765675671119238118911893939591735"; 1601 int aScale = 45; 1602 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1603 BigDecimal result = aNumber.ulp(); 1604 String res = "1E-45"; 1605 int resScale = 45; 1606 assertEquals("incorrect value", res, result.toString()); 1607 assertEquals("incorrect scale", resScale, result.scale()); 1608 } 1609 1610 /** 1611 * ulp() of a negative BigDecimal 1612 */ 1613 public void testUlpZero() { 1614 String a = "0"; 1615 int aScale = 2; 1616 BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale); 1617 BigDecimal result = aNumber.ulp(); 1618 String res = "0.01"; 1619 int resScale = 2; 1620 assertEquals("incorrect value", res, result.toString()); 1621 assertEquals("incorrect scale", resScale, result.scale()); 1622 } 1623 } 1624
