001/* 002 * $Id: ArithTest.java 4913 2014-09-21 14:41:09Z kredel $ 003 */ 004 005package edu.jas.arith; 006 007 008import junit.framework.Test; 009import junit.framework.TestCase; 010import junit.framework.TestSuite; 011 012import edu.jas.structure.Power; 013 014 015/** 016 * Basic arithmetic tests with JUnit. 017 * @author Heinz Kredel. 018 */ 019 020public class ArithTest extends TestCase { 021 022 023 /** 024 * main. 025 */ 026 public static void main(String[] args) { 027 junit.textui.TestRunner.run(suite()); 028 } 029 030 031 /** 032 * Constructs a <CODE>ArithTest</CODE> object. 033 * @param name String. 034 */ 035 public ArithTest(String name) { 036 super(name); 037 } 038 039 040 /** 041 * suite. 042 */ 043 public static Test suite() { 044 TestSuite suite = new TestSuite(ArithTest.class); 045 return suite; 046 } 047 048 049 /* 050 RingElem a; 051 RingElem b; 052 RingElem c; 053 RingElem d; 054 RingElem e; 055 */ 056 057 @Override 058 protected void setUp() { 059 //a = b = c = d = e = null; 060 } 061 062 063 @Override 064 protected void tearDown() { 065 //a = b = c = d = e = null; 066 } 067 068 069 /** 070 * Test static initialization and constants for BigInteger. 071 */ 072 public void testIntegerConstants() { 073 BigInteger a, b, c, d; 074 a = BigInteger.ZERO; 075 b = BigInteger.ONE; 076 c = b.subtract(b); 077 078 assertTrue("0.isZERO()", a.isZERO()); 079 assertTrue("1.isONE", b.isONE()); 080 081 assertEquals("1-1 = 0", c, a); 082 assertTrue("(1-1).isZERO()", c.isZERO()); 083 084 d = b.multiply(b); 085 assertTrue("1*1 = 1", d.isONE()); 086 087 d = b.multiply(a); 088 assertTrue("1*0 = 0", d.isZERO()); 089 } 090 091 092 //-------------------------------------------------------- 093 094 095 /** 096 * Test string constructor and toString for BigInteger. 097 */ 098 public void testIntegerConstructor() { 099 BigInteger a, b, c, d; 100 a = new BigInteger(1); 101 b = new BigInteger(-1); 102 c = new BigInteger(0); 103 104 d = a.sum(b); 105 assertTrue("'1'.isONE()", a.isONE()); 106 assertTrue("1+(-1) = 0", d.isZERO()); 107 d = a.negate(); 108 assertEquals("-1 = -(1)", d, b); 109 110 d = a.multiply(c); 111 assertTrue("'0'.isZERO()", d.isZERO()); 112 d = b.multiply(b); 113 assertTrue("(-1)*(-1) = 1", d.isONE()); 114 115 a = new BigInteger(3); 116 b = new BigInteger("3"); 117 assertEquals("3 = '3'", a, b); 118 119 a = new BigInteger(-5); 120 b = new BigInteger("-5"); 121 assertEquals("-5 = '-5'", a, b); 122 123 // 0 1 2 3 4 124 // 0123456789012345678901234567890123456789012345 125 String s = "1111111111111111111111111111111111111111111111"; 126 a = new BigInteger(s); 127 String t = a.toString(); 128 assertEquals("stringConstr = toString", s, t); 129 } 130 131 132 //-------------------------------------------------------- 133 134 /** 135 * Test random and compares Integer. 136 */ 137 public void testIntegerRandom() { 138 BigInteger a, b, c; 139 a = BigInteger.ZERO.random(500); 140 b = new BigInteger("" + a); 141 c = b.subtract(a); 142 143 assertTrue("a-'a' = 0", c.isZERO()); 144 assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a)); 145 assertEquals("signum('a'-a) = 0", 0, c.signum()); 146 } 147 148 149 //-------------------------------------------------------- 150 151 152 /** 153 * Test addition for Integer. 154 */ 155 public void testIntegerAddition() { 156 BigInteger a, b, c, d, e; 157 // neutral element 158 a = BigInteger.ZERO.random(500); 159 d = a.sum(BigInteger.ZERO); 160 assertEquals("a+0 = a", d, a); 161 d = a.subtract(BigInteger.ZERO); 162 assertEquals("a-0 = a", d, a); 163 164 // inverse operations 165 b = a.sum(a); 166 c = b.subtract(a); 167 assertEquals("(a+a)-a = a", c, a); 168 b = a.subtract(a); 169 c = b.sum(a); 170 assertEquals("(a-a)+a = a", c, a); 171 172 // comutativity 173 b = BigInteger.ZERO.random(500); 174 c = a.sum(b); 175 d = b.sum(a); 176 assertEquals("a+b = b+a", c, d); 177 178 // negation 179 c = a.subtract(b); 180 d = a.sum(b.negate()); 181 assertEquals("a-b = a+(-b)", c, d); 182 183 // associativity 184 c = BigInteger.ZERO.random(500); 185 d = a.sum(b.sum(c)); 186 e = a.sum(b).sum(c); 187 assertEquals("a+(b+c) = (a+b)+c", d, e); 188 } 189 190 191 //-------------------------------------------------------- 192 193 194 /** 195 * Test multiplication for Integer. 196 */ 197 public void testIntegerMultiplication() { 198 BigInteger a, b, c, d, e; 199 // neutral element 200 a = BigInteger.ZERO.random(500); 201 d = a.multiply(BigInteger.ONE); 202 assertEquals("a*1 = a", d, a); 203 d = a.divide(BigInteger.ONE); 204 assertEquals("a/1 = a", d, a); 205 206 // inverse operations 207 b = a.multiply(a); 208 c = b.divide(a); 209 assertEquals("(a*a)/a = a", c, a); 210 b = a.divide(a); 211 c = b.multiply(a); 212 assertEquals("(a/a)*a = a", c, a); 213 214 // comutativity 215 b = BigInteger.ZERO.random(500); 216 c = a.multiply(b); 217 d = b.multiply(a); 218 assertEquals("a*b = b*a", c, d); 219 220 // inverse 221 d = c.divide(b); 222 // e = c.multiply( b.inverse() ); 223 e = a; 224 assertEquals("a/b = a*(1/b)", d, e); 225 226 // associativity 227 c = BigInteger.ZERO.random(500); 228 d = a.multiply(b.multiply(c)); 229 e = a.multiply(b).multiply(c); 230 assertEquals("a*(b*c) = (a*b)*c", d, e); 231 } 232 233 234 /** 235 * Test static initialization and constants for BigRational. 236 */ 237 public void testRationalConstants() { 238 BigRational a, b, c, d; 239 a = BigRational.ZERO; 240 b = BigRational.ONE; 241 //System.out.println("a = " + a); 242 //System.out.println("b = " + b); 243 c = b.subtract(b); 244 245 assertTrue("0.isZERO()", a.isZERO()); 246 assertTrue("1.isONE", b.isONE()); 247 248 assertEquals("1-1 = 0", c, a); 249 assertTrue("(1-1).isZERO()", c.isZERO()); 250 251 d = b.multiply(b); 252 assertTrue("1*1 = 1", d.isONE()); 253 254 d = b.multiply(a); 255 assertTrue("1*0 = 0", d.isZERO()); 256 } 257 258 259 /** 260 * Test static initialization and constants for BigComplex. 261 */ 262 public void testComplexConstants() { 263 BigComplex a, b, c, d; 264 a = BigComplex.ZERO; 265 b = BigComplex.ONE; 266 c = b.subtract(b); 267 268 assertTrue("0.isZERO()", a.isZERO()); 269 assertTrue("1.isONE", b.isONE()); 270 271 assertEquals("1-1 = 0", c, a); 272 assertTrue("(1-1).isZERO()", c.isZERO()); 273 274 d = b.multiply(b); 275 assertTrue("1*1 = 1", d.isONE()); 276 277 d = b.multiply(a); 278 assertTrue("1*0 = 0", d.isZERO()); 279 } 280 281 282 /** 283 * Test static initialization and constants for BigQuaternion. 284 */ 285 public void testQuaternionConstants() { 286 BigQuaternion a, b, c, d; 287 a = BigQuaternion.ZERO; 288 b = BigQuaternion.ONE; 289 c = b.subtract(b); 290 291 assertTrue("0.isZERO()", a.isZERO()); 292 assertTrue("1.isONE", b.isONE()); 293 294 assertEquals("1-1 = 0", c, a); 295 assertTrue("(1-1).isZERO()", c.isZERO()); 296 297 d = b.multiply(b); 298 assertTrue("1*1 = 1", d.isONE()); 299 300 d = b.multiply(a); 301 assertTrue("1*0 = 0", d.isZERO()); 302 } 303 304 305 //-------------------------------------------------------- 306 307 308 /** 309 * Test string constructor and toString for BigRational. 310 */ 311 public void testRationalConstructor() { 312 BigRational a, b, c, d; 313 a = new BigRational(1); 314 b = new BigRational(-1); 315 c = new BigRational(0); 316 317 d = a.sum(b); 318 assertTrue("'1'.isONE()", a.isONE()); 319 assertTrue("1+(-1) = 0", d.isZERO()); 320 d = a.negate(); 321 assertEquals("-1 = -(1)", d, b); 322 323 d = a.multiply(c); 324 assertTrue("'0'.isZERO()", d.isZERO()); 325 d = b.multiply(b); 326 assertTrue("(-1)*(-1) = 1", d.isONE()); 327 328 a = new BigRational(3); 329 b = new BigRational("3"); 330 assertEquals("3 = '3'", a, b); 331 332 a = new BigRational(-5); 333 b = new BigRational("-5"); 334 assertEquals("-5 = '-5'", a, b); 335 336 // 0 1 2 3 4 337 // 0123456789012345678901234567890123456789012345 338 String s = "1111111111111111111111111111111111111111111111"; 339 a = new BigRational(s); 340 String t = a.toString(); 341 assertEquals("stringConstr = toString", s, t); 342 343 s = "2/4"; 344 a = new BigRational(s); 345 t = a.toString(5); 346 //System.out.println("a = " + a); 347 //System.out.println("t = " + t); 348 String r = "0.5"; 349 assertEquals("stringConstr = toString", r, t); 350 } 351 352 353 /** 354 * Test string constructor and toString for BigComplex. 355 */ 356 public void testComplexConstructor() { 357 BigComplex a, b, c, d; 358 a = new BigComplex(1); 359 b = new BigComplex(-1); 360 c = new BigComplex(0); 361 362 d = a.sum(b); 363 assertTrue("'1'.isONE()", a.isONE()); 364 assertTrue("1+(-1) = 0", d.isZERO()); 365 d = a.negate(); 366 assertEquals("-1 = -(1)", d, b); 367 368 d = a.multiply(c); 369 assertTrue("'0'.isZERO()", d.isZERO()); 370 d = b.multiply(b); 371 assertTrue("(-1)*(-1) = 1", d.isONE()); 372 373 a = new BigComplex(3); 374 b = new BigComplex("3"); 375 assertEquals("3 = '3'", a, b); 376 377 a = new BigComplex(-5); 378 b = new BigComplex("-5"); 379 assertEquals("-5 = '-5'", a, b); 380 381 // 0 1 2 3 4 382 // 0123456789012345678901234567890123456789012345 383 String s = "1111111111111111111111111111111111111111111111"; 384 a = new BigComplex(s); 385 String t = a.toString(); 386 assertEquals("stringConstr = toString", s, t); 387 } 388 389 390 /** 391 * Test string constructor and toString for BigQuaternion. 392 */ 393 public void testQuaternionConstructor() { 394 BigQuaternion a, b, c, d; 395 a = new BigQuaternion(1); 396 b = new BigQuaternion(-1); 397 c = new BigQuaternion(0); 398 399 d = a.sum(b); 400 assertTrue("'1'.isONE()", a.isONE()); 401 assertTrue("1+(-1) = 0", d.isZERO()); 402 d = a.negate(); 403 assertEquals("-1 = -(1)", d, b); 404 405 d = a.multiply(c); 406 assertTrue("'0'.isZERO()", d.isZERO()); 407 d = b.multiply(b); 408 assertTrue("(-1)*(-1) = 1", d.isONE()); 409 410 a = new BigQuaternion(3); 411 b = new BigQuaternion("3"); 412 assertEquals("3 = '3'", a, b); 413 414 a = new BigQuaternion(-5); 415 b = new BigQuaternion("-5"); 416 assertEquals("-5 = '-5'", a, b); 417 418 // 0 1 2 3 4 419 // 0123456789012345678901234567890123456789012345 420 String s = "1111111111111111111111111111111111111111111111"; 421 a = new BigQuaternion(s); 422 String t = a.toString(); 423 assertEquals("stringConstr = toString", s, t); 424 } 425 426 427 //-------------------------------------------------------- 428 429 430 /** 431 * Test random and compares Rational. 432 */ 433 public void testRationalRandom() { 434 BigRational a, b, c; 435 a = BigRational.ZERO.random(500); 436 b = new BigRational("" + a); 437 c = b.subtract(a); 438 439 assertTrue("a-'a' = 0", c.isZERO()); 440 assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a)); 441 assertEquals("signum('a'-a) = 0", 0, c.signum()); 442 } 443 444 445 /** 446 * Test random and compares Complex. 447 */ 448 public void testComplexRandom() { 449 BigComplex a, b, c; 450 a = BigComplex.ZERO.random(500); 451 b = new BigComplex("" + a); 452 c = b.subtract(a); 453 454 assertTrue("a-'a' = 0", c.isZERO()); 455 assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a)); 456 assertEquals("signum('a'-a) = 0", 0, c.signum()); 457 } 458 459 460 /** 461 * Test random and compares Quaternion. 462 */ 463 public void testQuaternionRandom() { 464 BigQuaternion a, b, c; 465 a = BigQuaternion.ZERO.random(500); 466 b = new BigQuaternion("" + a); 467 c = b.subtract(a); 468 469 assertTrue("a-'a' = 0", c.isZERO()); 470 assertEquals("signum('a'-a) = 0", 0, c.signum()); 471 assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a)); 472 } 473 474 475 //-------------------------------------------------------- 476 477 478 /** 479 * Test addition for Rational. 480 */ 481 public void testRationalAddition() { 482 BigRational a, b, c, d, e; 483 // neutral element 484 a = BigRational.ZERO.random(500); 485 d = a.sum(BigRational.ZERO); 486 assertEquals("a+0 = a", d, a); 487 d = a.subtract(BigRational.ZERO); 488 assertEquals("a-0 = a", d, a); 489 490 // inverse operations 491 b = a.sum(a); 492 c = b.subtract(a); 493 assertEquals("(a+a)-a = a", c, a); 494 b = a.subtract(a); 495 c = b.sum(a); 496 assertEquals("(a-a)+a = a", c, a); 497 498 // comutativity 499 b = BigRational.ZERO.random(500); 500 c = a.sum(b); 501 d = b.sum(a); 502 assertEquals("a+b = b+a", c, d); 503 504 // negation 505 c = a.subtract(b); 506 d = a.sum(b.negate()); 507 assertEquals("a-b = a+(-b)", c, d); 508 509 // associativity 510 c = BigRational.ZERO.random(500); 511 d = a.sum(b.sum(c)); 512 e = a.sum(b).sum(c); 513 assertEquals("a+(b+c) = (a+b)+c", d, e); 514 } 515 516 517 /** 518 * Test addition for Complex. 519 */ 520 public void testComplexAddition() { 521 BigComplex a, b, c, d, e; 522 // neutral element 523 a = BigComplex.ZERO.random(500); 524 d = a.sum(BigComplex.ZERO); 525 assertEquals("a+0 = a", d, a); 526 d = a.subtract(BigComplex.ZERO); 527 assertEquals("a-0 = a", d, a); 528 529 // inverse operations 530 b = a.sum(a); 531 c = b.subtract(a); 532 assertEquals("(a+a)-a = a", c, a); 533 b = a.subtract(a); 534 c = b.sum(a); 535 assertEquals("(a-a)+a = a", c, a); 536 537 // comutativity 538 b = BigComplex.ZERO.random(500); 539 c = a.sum(b); 540 d = b.sum(a); 541 assertEquals("a+b = b+a", c, d); 542 543 // negation 544 c = a.subtract(b); 545 d = a.sum(b.negate()); 546 assertEquals("a-b = a+(-b)", c, d); 547 548 // associativity 549 c = BigComplex.ZERO.random(500); 550 d = a.sum(b.sum(c)); 551 e = a.sum(b).sum(c); 552 assertEquals("a+(b+c) = (a+b)+c", d, e); 553 } 554 555 556 /** 557 * Test addition for Quaternion. 558 */ 559 public void testQuaternionAddition() { 560 BigQuaternion a, b, c, d, e; 561 // neutral element 562 a = BigQuaternion.ZERO.random(500); 563 d = a.sum(BigQuaternion.ZERO); 564 assertEquals("a+0 = a", d, a); 565 d = a.subtract(BigQuaternion.ZERO); 566 assertEquals("a-0 = a", d, a); 567 568 // inverse operations 569 b = a.sum(a); 570 c = b.subtract(a); 571 assertEquals("(a+a)-a = a", c, a); 572 b = a.subtract(a); 573 c = b.sum(a); 574 assertEquals("(a-a)+a = a", c, a); 575 576 // comutativity 577 b = BigQuaternion.ZERO.random(500); 578 c = a.sum(b); 579 d = b.sum(a); 580 assertEquals("a+b = b+a", c, d); 581 582 // negation 583 c = a.subtract(b); 584 d = a.sum(b.negate()); 585 assertEquals("a-b = a+(-b)", c, d); 586 587 // associativity 588 c = BigQuaternion.ZERO.random(500); 589 d = a.sum(b.sum(c)); 590 e = a.sum(b).sum(c); 591 assertEquals("a+(b+c) = (a+b)+c", d, e); 592 } 593 594 595 //-------------------------------------------------------- 596 597 598 /** 599 * Test multiplication for Rational. 600 */ 601 public void testRationalMultiplication() { 602 BigRational a, b, c, d, e; 603 // neutral element 604 a = BigRational.ZERO.random(500); 605 d = a.multiply(BigRational.ONE); 606 assertEquals("a*1 = a", d, a); 607 d = a.divide(BigRational.ONE); 608 assertEquals("a/1 = a", d, a); 609 610 // inverse operations 611 b = a.multiply(a); 612 c = b.divide(a); 613 assertEquals("(a*a)/a = a", c, a); 614 b = a.divide(a); 615 c = b.multiply(a); 616 assertEquals("(a/a)*a = a", c, a); 617 618 // comutativity 619 b = BigRational.ZERO.random(500); 620 c = a.multiply(b); 621 d = b.multiply(a); 622 assertEquals("a*b = b*a", c, d); 623 624 // inverse 625 d = c.divide(b); 626 e = c.multiply(b.inverse()); 627 //e = a; 628 assertEquals("a/b = a*(1/b)", d, e); 629 630 // associativity 631 c = BigRational.ZERO.random(500); 632 d = a.multiply(b.multiply(c)); 633 e = a.multiply(b).multiply(c); 634 assertEquals("a*(b*c) = (a*b)*c", d, e); 635 } 636 637 638 /** 639 * Test multiplication for Complex. 640 */ 641 public void testComplexMultiplication() { 642 BigComplex a, b, c, d, e; 643 // neutral element 644 a = BigComplex.ZERO.random(500); 645 d = a.multiply(BigComplex.ONE); 646 assertEquals("a*1 = a", d, a); 647 d = a.divide(BigComplex.ONE); 648 assertEquals("a/1 = a", d, a); 649 650 // inverse operations 651 b = a.multiply(a); 652 c = b.divide(a); 653 assertEquals("(a*a)/a = a", c, a); 654 b = a.divide(a); 655 c = b.multiply(a); 656 assertEquals("(a/a)*a = a", c, a); 657 658 // comutativity 659 b = BigComplex.ZERO.random(500); 660 c = a.multiply(b); 661 d = b.multiply(a); 662 assertEquals("a*b = b*a", c, d); 663 664 // inverse 665 d = c.divide(b); 666 e = c.multiply(b.inverse()); 667 //e = a; 668 assertEquals("a/b = a*(1/b)", d, e); 669 670 // associativity 671 c = BigComplex.ZERO.random(500); 672 d = a.multiply(b.multiply(c)); 673 e = a.multiply(b).multiply(c); 674 assertEquals("a*(b*c) = (a*b)*c", d, e); 675 } 676 677 678 /** 679 * Test multiplication for Quaternion. 680 */ 681 public void testQuaternionMultiplication() { 682 BigQuaternion a, b, c, d, e; 683 // neutral element 684 a = BigQuaternion.ZERO.random(500); 685 d = a.multiply(BigQuaternion.ONE); 686 assertEquals("a*1 = a", d, a); 687 d = a.divide(BigQuaternion.ONE); 688 assertEquals("a/1 = a", d, a); 689 690 // inverse operations 691 b = a.multiply(a); 692 c = b.divide(a); 693 assertEquals("(a*a)/a = a", c, a); 694 b = a.divide(a); 695 c = b.multiply(a); 696 assertEquals("(a/a)*a = a", c, a); 697 698 // inverse 699 b = BigQuaternion.ZERO.random(500); 700 c = b.multiply(a); 701 d = c.divide(b); 702 e = c.multiply(b.inverse()); 703 //e = a; 704 assertEquals("a/b = a*(1/b)", d, e); 705 706 // associativity 707 c = BigQuaternion.ZERO.random(500); 708 d = a.multiply(b.multiply(c)); 709 e = a.multiply(b).multiply(c); 710 assertEquals("a*(b*c) = (a*b)*c", d, e); 711 712 // non comutativity 713 a = BigQuaternion.I; 714 b = BigQuaternion.J; 715 c = a.multiply(b); 716 d = b.multiply(a); 717 assertEquals("I*J = -J*I", c, d.negate()); 718 a = BigQuaternion.I; 719 b = BigQuaternion.K; 720 c = a.multiply(b); 721 d = b.multiply(a); 722 assertEquals("I*K = -K*I", c, d.negate()); 723 a = BigQuaternion.J; 724 b = BigQuaternion.K; 725 c = a.multiply(b); 726 d = b.multiply(a); 727 assertEquals("J*K = -K*J", c, d.negate()); 728 } 729 730 731 /** 732 * Test power for Rational. 733 */ 734 public void testRationalPower() { 735 BigRational a, b, c, d; 736 a = BigRational.ZERO.random(100); 737 738 // power operations 739 b = Power.<BigRational> positivePower(a, 1); 740 assertEquals("a^1 = a", b, a); 741 742 Power<BigRational> pow = new Power<BigRational>(BigRational.ONE); 743 b = pow.power(a, 1); 744 assertEquals("a^1 = a", b, a); 745 746 b = pow.power(a, 2); 747 c = a.multiply(a); 748 assertEquals("a^2 = a*a", b, c); 749 750 d = pow.power(a, -2); 751 c = b.multiply(d); 752 assertTrue("a^2 * a^-2 = 1", c.isONE()); 753 754 b = pow.power(a, 3); 755 c = a.multiply(a).multiply(a); 756 assertEquals("a^3 = a*a*a", b, c); 757 758 d = pow.power(a, -3); 759 c = b.multiply(d); 760 assertTrue("a^3 * a^-3 = 1", c.isONE()); 761 762 //Java 8: 763 //d = a.power(-3); 764 //c = b.multiply(d); 765 //assertTrue("a^3 * a^-3 = 1", c.isONE()); 766 } 767 768 769 /** 770 * Test power for Integer. 771 */ 772 public void testIntegerPower() { 773 BigInteger a, b, c, d, e; 774 a = BigInteger.ZERO.random(500); 775 776 // power operations 777 b = Power.<BigInteger> positivePower(a, 1); 778 assertEquals("a^1 = a", b, a); 779 780 Power<BigInteger> pow = new Power<BigInteger>(BigInteger.ONE); 781 b = pow.power(a, 1); 782 assertEquals("a^1 = a", b, a); 783 784 b = pow.power(a, 2); 785 c = a.multiply(a); 786 assertEquals("a^2 = a*a", b, c); 787 788 b = pow.power(a, 3); 789 c = a.multiply(a).multiply(a); 790 assertEquals("a^3 = a*a*a", b, c); 791 792 // mod power operations 793 a = new BigInteger(3); 794 b = Power.<BigInteger> positivePower(a, 1); 795 assertEquals("a^1 = a", b, a); 796 797 a = new BigInteger(11); 798 e = new BigInteger(2); 799 c = Power.<BigInteger> modPositivePower(a, 10, e); 800 assertTrue("3^n mod 2 = 1", c.isONE()); 801 802 // little fermat 803 a = BigInteger.ZERO.random(500); 804 b = new BigInteger(11); 805 c = Power.<BigInteger> modPositivePower(a, 11, b); 806 d = a.remainder(b); 807 assertEquals("a^p = a mod p", c, d); 808 809 c = pow.modPower(a, 11, b); 810 assertEquals("a^p = a mod p", c, d); 811 812 //Java 8: 813 //a = BigInteger.ZERO.random(100); 814 //d = a.power(1); 815 //c = a; 816 //assertEquals("a^1 == a", c, d); 817 818 //d = a.power(0); 819 //c = BigInteger.ONE; 820 //assertEquals("a^0 == 1", c, d); 821 822 //d = a.power(3); 823 //c = a.multiply(a).multiply(a); 824 //assertEquals("a^3 == a*a*a", c, d); 825 } 826 827 828 /** 829 * Test Combinatoric. 830 */ 831 public void testCombinatoric() { 832 BigInteger a, b, c; 833 834 a = Combinatoric.binCoeff(5, 0); 835 assertTrue("(5 0) == 1 ", a.isONE()); 836 837 a = Combinatoric.binCoeff(5, 7); 838 //System.out.println(5 + " over " + 7 + " = " + a); 839 assertTrue("(5 7) == 1 ", a.isONE()); 840 841 int n = 7; 842 for (int k = 0; k <= n; k++) { 843 a = Combinatoric.binCoeff(n, k); 844 b = Combinatoric.binCoeff(n, n - k); 845 assertEquals("(5 k) == (5 5-k) ", b, a); 846 //System.out.println(n + " over " + k + " = " + a); 847 } 848 assertTrue("(5 5) == 1 ", a.isONE()); 849 850 b = Combinatoric.binCoeffSum(n, n); 851 //System.out.println("sum( " + n + " over " + n + " ) = " + b); 852 c = Power.positivePower(new BigInteger(2), n); 853 assertEquals("sum(5 5) == 1 ", b, c); 854 855 b = Combinatoric.factorial(3); 856 assertEquals("3! == 6 ", b, new BigInteger(6)); 857 b = Combinatoric.factorial(0); 858 assertEquals("0! == 1 ", b, new BigInteger(1)); 859 } 860 861 862 /** 863 * Test square root. 864 */ 865 public void testSquareRoot() { 866 BigInteger a, b, c, d, e, f; 867 a = BigInteger.ONE; 868 869 b = a.random(47).abs(); 870 //b = c.multiply(c); 871 d = Roots.sqrtInt(b); 872 //System.out.println("b = " + b); 873 //System.out.println("root = " + d); 874 e = d.multiply(d); 875 //System.out.println("root^2 = " + e); 876 assertTrue("root^2 <= a ", e.compareTo(b) <= 0); 877 d = d.sum(BigInteger.ONE); 878 f = d.multiply(d); 879 //System.out.println("(root+1)^2 = " + f); 880 assertTrue("(root+1)^2 >= a ", f.compareTo(b) >= 0); 881 882 c = Roots.sqrt(b); 883 //System.out.println("b = " + b); 884 //System.out.println("root = " + c); 885 e = c.multiply(c); 886 //System.out.println("root^2 = " + e); 887 assertTrue("root^2 <= a ", e.compareTo(b) <= 0); 888 c = c.sum(BigInteger.ONE); 889 f = c.multiply(c); 890 //System.out.println("(root+1)^2 = " + f); 891 assertTrue("(root+1)^2 >= a ", f.compareTo(b) >= 0); 892 } 893 894 895 /** 896 * Test root. 897 */ 898 public void testRoot() { 899 BigInteger a, b, d, e, f; 900 a = BigInteger.ONE; 901 902 b = a.random(47).abs(); 903 //System.out.println("\nb = " + b); 904 //System.out.println("bitsize(b) = " + b.val.bitLength()); 905 for (int n = 2; n < 8; n++) { 906 d = Roots.root(b, n); 907 //System.out.println(n+"-th root = " + d); 908 e = Power.positivePower(d, n); 909 //System.out.println("root^"+n+" = " + e); 910 assertTrue("root^" + n + " <= a " + (b.subtract(e)), e.compareTo(b) <= 0); 911 d = d.sum(BigInteger.ONE); 912 f = Power.positivePower(d, n); 913 //System.out.println("(root+1)^"+n+" = " + f); 914 assertTrue("(root+1)^" + n + " >= a ", f.compareTo(b) >= 0); 915 } 916 } 917 918 919 /** 920 * Test root decimal. 921 */ 922 public void testRootDecimal() { 923 BigDecimal a, b, d, e; 924 a = BigDecimal.ONE; 925 926 b = a.random(7).abs(); 927 //System.out.println("\nb = " + b); 928 //System.out.println("ulp(b) = " + b.val.ulp()); 929 for (int n = 1; n < 8; n++) { 930 d = Roots.root(b, n); 931 //System.out.println(n+"-th root = " + d); 932 e = Power.positivePower(d, n); 933 //System.out.println("root^"+n+" = " + e); 934 if (b.compareTo(e) == 0) { 935 assertTrue("root^" + n + " == b: " + e, b.compareTo(e) == 0); 936 } else { 937 //System.out.println("b = " + b + ", root(b," + n +") = " + d); 938 System.out.print("b = " + b + ", "); 939 System.out.println("d^" + n + " = " + e + ", b-e = " + b.subtract(e).abs()); 940 //System.out.println("b~e = " + b.compareToAbsolute(e) + ", (b-e)/e = " + b.compareToRelative(e)); 941 } 942 } 943 } 944 945 946 /** 947 * Test root decimal. 948 */ 949 public void test2RootDecimal() { 950 BigDecimal a, b, c; 951 a = BigDecimal.ZERO; 952 b = Roots.sqrt(a); 953 assertTrue("sqrt(0) == 0: " + b, b.isZERO()); 954 955 a = BigDecimal.ONE; 956 b = Roots.sqrt(a); 957 assertTrue("sqrt(1) == 1: " + b, b.isONE()); 958 959 a = new BigDecimal("4"); 960 b = Roots.sqrt(a); 961 //b = Roots.root(a,2); 962 c = b.multiply(b); 963 assertTrue("sqrt(4)*sqrt(4) == 4: " + a.subtract(c), a.compareTo(c) == 0); 964 //System.out.println("DEFAULT_PRECISION = " + BigDecimal.DEFAULT_PRECISION); 965 966 a = new BigDecimal("0.5"); 967 b = Roots.sqrt(a); 968 //b = Roots.root(a,2); 969 c = b.multiply(b); 970 //System.out.println("a = " + a + ", sqrt(a) = " + b + ", b^2 = " + c); 971 assertTrue("sqrt(0.5)*sqrt(0.5) == 0.5: " + a.subtract(c), a.compareTo(c) == 0); 972 assertTrue("sqrt(0.5)*sqrt(0.5) == 0.5: " + b, a.compareTo(c) == 0); 973 974 a = a.random(5).abs(); 975 b = Roots.sqrt(a); 976 //b = Roots.root(a,2); 977 c = b.multiply(b); 978 //System.out.println("a = " + a + ", sqrt(a) = " + b + ", b^2 = " + c); 979 assertTrue("sqrt(a)*sqrt(a) == a: " + a.subtract(c), a.compareTo(c) == 0); 980 } 981 982 983 /** 984 * Test root complex decimal. 985 */ 986 public void testRootDecimalComplex() { 987 BigDecimalComplex a, b, c, d; 988 a = BigDecimalComplex.ZERO; 989 b = Roots.sqrt(a); 990 assertTrue("sqrt(0) == 0: " + b, b.isZERO()); 991 992 a = BigDecimalComplex.ONE; 993 b = Roots.sqrt(a); 994 assertTrue("sqrt(1) == 1: " + b, b.isONE()); 995 996 a = BigDecimalComplex.ONE.negate(); 997 b = Roots.sqrt(a); 998 d = b.multiply(b); 999 //System.out.println("a = " + a + ", b = " + b + ", d = " + d); 1000 assertTrue("sqrt(-1) == I: " + b, b.isIMAG()); 1001 assertTrue("sqrt(-1)*sqrt(-1) == -1: " + a + ", b = " + b, a.compareTo(d) == 0); 1002 1003 b = BigDecimalComplex.I; 1004 c = Roots.sqrt(b); 1005 d = c.multiply(c); 1006 //System.out.println("b = " + b + ", c = " + c + ", d = " + d); 1007 assertTrue("sqrt(b)*sqrt(b) == b: " + c + ", b = " + b, b.compareTo(d) == 0); 1008 1009 b = a.fromInteger(4); 1010 c = Roots.sqrt(b); 1011 d = BigDecimalComplex.ONE.sum(BigDecimalComplex.ONE); 1012 //System.out.println("b = " + b + ", c = " + c + ", d = " + d); 1013 assertTrue("sqrt(4) == 2: " + c, c.compareTo(d) == 0); 1014 1015 b = b.multiply(BigDecimalComplex.I); 1016 c = Roots.sqrt(b); 1017 d = c.multiply(c); 1018 //System.out.println("b = " + b + ", c = " + c + ", d = " + d); 1019 assertTrue("sqrt(b)*sqrt(b) == b: " + c + ", b = " + b, b.compareTo(d) == 0); 1020 1021 b = a.random(5); 1022 c = Roots.sqrt(b); 1023 d = c.multiply(c); 1024 if (b.compareTo(d) != 0) { 1025 System.out.println("b = " + b + ", c = " + c + ", d = " + d); 1026 } 1027 assertTrue("sqrt(b)*sqrt(b) == b: b-d = " + b.subtract(d), b.compareTo(d) == 0); 1028 } 1029 1030}