001/* 002 * $Id: ArithTest.java 5712 2017-01-22 22:35:21Z kredel $ 003 */ 004 005package edu.jas.arith; 006 007 008import edu.jas.structure.Power; 009 010import junit.framework.Test; 011import junit.framework.TestCase; 012import junit.framework.TestSuite; 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 BigQuaternionRing fac = new BigQuaternionRing(); 287 BigQuaternion a, b, c, d; 288 a = fac.ZERO; 289 b = fac.ONE; 290 c = b.subtract(b); 291 292 assertTrue("0.isZERO()", a.isZERO()); 293 assertTrue("1.isONE", b.isONE()); 294 295 assertEquals("1-1 = 0", c, a); 296 assertTrue("(1-1).isZERO()", c.isZERO()); 297 298 d = b.multiply(b); 299 assertTrue("1*1 = 1", d.isONE()); 300 301 d = b.multiply(a); 302 assertTrue("1*0 = 0", d.isZERO()); 303 } 304 305 306 //-------------------------------------------------------- 307 308 309 /** 310 * Test string constructor and toString for BigRational. 311 */ 312 public void testRationalConstructor() { 313 BigRational a, b, c, d; 314 a = new BigRational(1); 315 b = new BigRational(-1); 316 c = new BigRational(0); 317 318 d = a.sum(b); 319 assertTrue("'1'.isONE()", a.isONE()); 320 assertTrue("1+(-1) = 0", d.isZERO()); 321 d = a.negate(); 322 assertEquals("-1 = -(1)", d, b); 323 324 d = a.multiply(c); 325 assertTrue("'0'.isZERO()", d.isZERO()); 326 d = b.multiply(b); 327 assertTrue("(-1)*(-1) = 1", d.isONE()); 328 329 a = new BigRational(3); 330 b = new BigRational("3"); 331 assertEquals("3 = '3'", a, b); 332 333 a = new BigRational(-5); 334 b = new BigRational("-5"); 335 assertEquals("-5 = '-5'", a, b); 336 337 // 0 1 2 3 4 338 // 0123456789012345678901234567890123456789012345 339 String s = "1111111111111111111111111111111111111111111111"; 340 a = new BigRational(s); 341 String t = a.toString(); 342 assertEquals("stringConstr = toString", s, t); 343 344 s = "2/4"; 345 a = new BigRational(s); 346 t = a.toString(5); 347 //System.out.println("a = " + a); 348 //System.out.println("t = " + t); 349 String r = "0.5"; 350 assertEquals("stringConstr = toString", r, t); 351 } 352 353 354 /** 355 * Test string constructor and toString for BigComplex. 356 */ 357 public void testComplexConstructor() { 358 BigComplex a, b, c, d; 359 a = new BigComplex(1); 360 b = new BigComplex(-1); 361 c = new BigComplex(0); 362 363 d = a.sum(b); 364 assertTrue("'1'.isONE()", a.isONE()); 365 assertTrue("1+(-1) = 0", d.isZERO()); 366 d = a.negate(); 367 assertEquals("-1 = -(1)", d, b); 368 369 d = a.multiply(c); 370 assertTrue("'0'.isZERO()", d.isZERO()); 371 d = b.multiply(b); 372 assertTrue("(-1)*(-1) = 1", d.isONE()); 373 374 a = new BigComplex(3); 375 b = new BigComplex("3"); 376 assertEquals("3 = '3'", a, b); 377 378 a = new BigComplex(-5); 379 b = new BigComplex("-5"); 380 assertEquals("-5 = '-5'", a, b); 381 382 // 0 1 2 3 4 383 // 0123456789012345678901234567890123456789012345 384 String s = "1111111111111111111111111111111111111111111111"; 385 a = new BigComplex(s); 386 String t = a.toString(); 387 assertEquals("stringConstr = toString", s, t); 388 } 389 390 391 /** 392 * Test string constructor and toString for BigQuaternion. 393 */ 394 public void testQuaternionConstructor() { 395 BigQuaternionRing fac = new BigQuaternionRing(); 396 BigQuaternion a, b, c, d; 397 a = new BigQuaternion(fac, 1); 398 b = new BigQuaternion(fac, -1); 399 c = new BigQuaternion(fac, 0); 400 401 d = a.sum(b); 402 assertTrue("'1'.isONE()", a.isONE()); 403 assertTrue("1+(-1) = 0", d.isZERO()); 404 d = a.negate(); 405 assertEquals("-1 = -(1)", d, b); 406 407 d = a.multiply(c); 408 assertTrue("'0'.isZERO()", d.isZERO()); 409 d = b.multiply(b); 410 assertTrue("(-1)*(-1) = 1", d.isONE()); 411 412 a = new BigQuaternion(fac, 3); 413 b = new BigQuaternion(fac, "3"); 414 assertEquals("3 = '3'", a, b); 415 416 a = new BigQuaternion(fac, -5); 417 b = new BigQuaternion(fac, "-5"); 418 assertEquals("-5 = '-5'", a, b); 419 420 // 0 1 2 3 4 421 // 0123456789012345678901234567890123456789012345 422 String s = "1111111111111111111111111111111111111111111111"; 423 a = new BigQuaternion(fac, s); 424 String t = a.toString(); 425 assertEquals("stringConstr = toString", s, t); 426 } 427 428 429 //-------------------------------------------------------- 430 431 432 /** 433 * Test random and compares Rational. 434 */ 435 public void testRationalRandom() { 436 BigRational a, b, c; 437 a = BigRational.ZERO.random(500); 438 b = new BigRational("" + a); 439 c = b.subtract(a); 440 441 assertTrue("a-'a' = 0", c.isZERO()); 442 assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a)); 443 assertEquals("signum('a'-a) = 0", 0, c.signum()); 444 } 445 446 447 /** 448 * Test random and compares Complex. 449 */ 450 public void testComplexRandom() { 451 BigComplex a, b, c; 452 a = BigComplex.ZERO.random(500); 453 b = new BigComplex("" + a); 454 c = b.subtract(a); 455 456 assertTrue("a-'a' = 0", c.isZERO()); 457 assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a)); 458 assertEquals("signum('a'-a) = 0", 0, c.signum()); 459 } 460 461 462 /** 463 * Test random and compares Quaternion. 464 */ 465 public void testQuaternionRandom() { 466 BigQuaternionRing fac = new BigQuaternionRing(); 467 BigQuaternion a, b, c; 468 a = fac.random(500); 469 b = new BigQuaternion(fac, a.toString()); 470 c = b.subtract(a); 471 472 assertTrue("a-'a' = 0", c.isZERO()); 473 assertEquals("signum('a'-a) = 0", 0, c.signum()); 474 assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a)); 475 } 476 477 478 //-------------------------------------------------------- 479 480 481 /** 482 * Test addition for Rational. 483 */ 484 public void testRationalAddition() { 485 BigRational a, b, c, d, e; 486 // neutral element 487 a = BigRational.ZERO.random(500); 488 d = a.sum(BigRational.ZERO); 489 assertEquals("a+0 = a", d, a); 490 d = a.subtract(BigRational.ZERO); 491 assertEquals("a-0 = a", d, a); 492 493 // inverse operations 494 b = a.sum(a); 495 c = b.subtract(a); 496 assertEquals("(a+a)-a = a", c, a); 497 b = a.subtract(a); 498 c = b.sum(a); 499 assertEquals("(a-a)+a = a", c, a); 500 501 // comutativity 502 b = BigRational.ZERO.random(500); 503 c = a.sum(b); 504 d = b.sum(a); 505 assertEquals("a+b = b+a", c, d); 506 507 // negation 508 c = a.subtract(b); 509 d = a.sum(b.negate()); 510 assertEquals("a-b = a+(-b)", c, d); 511 512 // associativity 513 c = BigRational.ZERO.random(500); 514 d = a.sum(b.sum(c)); 515 e = a.sum(b).sum(c); 516 assertEquals("a+(b+c) = (a+b)+c", d, e); 517 } 518 519 520 /** 521 * Test addition for Complex. 522 */ 523 public void testComplexAddition() { 524 BigComplex a, b, c, d, e; 525 // neutral element 526 a = BigComplex.ZERO.random(500); 527 d = a.sum(BigComplex.ZERO); 528 assertEquals("a+0 = a", d, a); 529 d = a.subtract(BigComplex.ZERO); 530 assertEquals("a-0 = a", d, a); 531 532 // inverse operations 533 b = a.sum(a); 534 c = b.subtract(a); 535 assertEquals("(a+a)-a = a", c, a); 536 b = a.subtract(a); 537 c = b.sum(a); 538 assertEquals("(a-a)+a = a", c, a); 539 540 // comutativity 541 b = BigComplex.ZERO.random(500); 542 c = a.sum(b); 543 d = b.sum(a); 544 assertEquals("a+b = b+a", c, d); 545 546 // negation 547 c = a.subtract(b); 548 d = a.sum(b.negate()); 549 assertEquals("a-b = a+(-b)", c, d); 550 551 // associativity 552 c = BigComplex.ZERO.random(500); 553 d = a.sum(b.sum(c)); 554 e = a.sum(b).sum(c); 555 assertEquals("a+(b+c) = (a+b)+c", d, e); 556 } 557 558 559 /** 560 * Test addition for Quaternion. 561 */ 562 public void testQuaternionAddition() { 563 BigQuaternionRing fac = new BigQuaternionRing(); 564 BigQuaternion a, b, c, d, e; 565 // neutral element 566 a = fac.random(500); 567 d = a.sum(fac.ZERO); 568 assertEquals("a+0 = a", d, a); 569 d = a.subtract(fac.ZERO); 570 assertEquals("a-0 = a", d, a); 571 572 // inverse operations 573 b = a.sum(a); 574 c = b.subtract(a); 575 assertEquals("(a+a)-a = a", c, a); 576 b = a.subtract(a); 577 c = b.sum(a); 578 assertEquals("(a-a)+a = a", c, a); 579 580 // comutativity 581 b = fac.random(500); 582 c = a.sum(b); 583 d = b.sum(a); 584 assertEquals("a+b = b+a", c, d); 585 586 // negation 587 c = a.subtract(b); 588 d = a.sum(b.negate()); 589 assertEquals("a-b = a+(-b)", c, d); 590 591 // associativity 592 c = fac.random(500); 593 d = a.sum(b.sum(c)); 594 e = a.sum(b).sum(c); 595 assertEquals("a+(b+c) = (a+b)+c", d, e); 596 } 597 598 599 //-------------------------------------------------------- 600 601 602 /** 603 * Test multiplication for Rational. 604 */ 605 public void testRationalMultiplication() { 606 BigRational a, b, c, d, e; 607 // neutral element 608 a = BigRational.ZERO.random(500); 609 d = a.multiply(BigRational.ONE); 610 assertEquals("a*1 = a", d, a); 611 d = a.divide(BigRational.ONE); 612 assertEquals("a/1 = a", d, a); 613 614 // inverse operations 615 b = a.multiply(a); 616 c = b.divide(a); 617 assertEquals("(a*a)/a = a", c, a); 618 b = a.divide(a); 619 c = b.multiply(a); 620 assertEquals("(a/a)*a = a", c, a); 621 622 // comutativity 623 b = BigRational.ZERO.random(500); 624 c = a.multiply(b); 625 d = b.multiply(a); 626 assertEquals("a*b = b*a", c, d); 627 628 // inverse 629 d = c.divide(b); 630 e = c.multiply(b.inverse()); 631 //e = a; 632 assertEquals("a/b = a*(1/b)", d, e); 633 634 // associativity 635 c = BigRational.ZERO.random(500); 636 d = a.multiply(b.multiply(c)); 637 e = a.multiply(b).multiply(c); 638 assertEquals("a*(b*c) = (a*b)*c", d, e); 639 } 640 641 642 /** 643 * Test multiplication for Complex. 644 */ 645 public void testComplexMultiplication() { 646 BigComplex a, b, c, d, e; 647 // neutral element 648 a = BigComplex.ZERO.random(500); 649 d = a.multiply(BigComplex.ONE); 650 assertEquals("a*1 = a", d, a); 651 d = a.divide(BigComplex.ONE); 652 assertEquals("a/1 = a", d, a); 653 654 // inverse operations 655 b = a.multiply(a); 656 c = b.divide(a); 657 assertEquals("(a*a)/a = a", c, a); 658 b = a.divide(a); 659 c = b.multiply(a); 660 assertEquals("(a/a)*a = a", c, a); 661 662 // comutativity 663 b = BigComplex.ZERO.random(500); 664 c = a.multiply(b); 665 d = b.multiply(a); 666 assertEquals("a*b = b*a", c, d); 667 668 // inverse 669 d = c.divide(b); 670 e = c.multiply(b.inverse()); 671 //e = a; 672 assertEquals("a/b = a*(1/b)", d, e); 673 674 // associativity 675 c = BigComplex.ZERO.random(500); 676 d = a.multiply(b.multiply(c)); 677 e = a.multiply(b).multiply(c); 678 assertEquals("a*(b*c) = (a*b)*c", d, e); 679 } 680 681 682 /** 683 * Test multiplication for Quaternion. 684 */ 685 public void testQuaternionMultiplication() { 686 BigQuaternionRing fac = new BigQuaternionRing(); 687 BigQuaternion a, b, c, d, e; 688 // neutral element 689 a = fac.random(500); 690 d = a.multiply(fac.ONE); 691 assertEquals("a*1 = a", d, a); 692 d = a.divide(fac.ONE); 693 assertEquals("a/1 = a", d, a); 694 695 // inverse operations 696 b = a.multiply(a); 697 c = b.divide(a); 698 assertEquals("(a*a)/a = a", c, a); 699 b = a.divide(a); 700 c = b.multiply(a); 701 assertEquals("(a/a)*a = a", c, a); 702 703 // inverse 704 b = fac.random(500); 705 c = b.multiply(a); 706 d = c.divide(b); 707 e = c.multiply(b.inverse()); 708 //e = a; 709 assertEquals("a/b = a*(1/b)", d, e); 710 711 // associativity 712 c = fac.random(500); 713 d = a.multiply(b.multiply(c)); 714 e = a.multiply(b).multiply(c); 715 assertEquals("a*(b*c) = (a*b)*c", d, e); 716 717 // non comutativity 718 a = fac.I; 719 b = fac.J; 720 c = a.multiply(b); 721 d = b.multiply(a); 722 assertEquals("I*J = -J*I", c, d.negate()); 723 a = fac.I; 724 b = fac.K; 725 c = a.multiply(b); 726 d = b.multiply(a); 727 assertEquals("I*K = -K*I", c, d.negate()); 728 a = fac.J; 729 b = fac.K; 730 c = a.multiply(b); 731 d = b.multiply(a); 732 assertEquals("J*K = -K*J", c, d.negate()); 733 } 734 735 736 /** 737 * Test power for Rational. 738 */ 739 public void testRationalPower() { 740 BigRational a, b, c, d; 741 a = BigRational.ZERO.random(100); 742 743 // power operations 744 b = Power.<BigRational> positivePower(a, 1); 745 assertEquals("a^1 = a", b, a); 746 747 Power<BigRational> pow = new Power<BigRational>(BigRational.ONE); 748 b = pow.power(a, 1); 749 assertEquals("a^1 = a", b, a); 750 751 b = pow.power(a, 2); 752 c = a.multiply(a); 753 assertEquals("a^2 = a*a", b, c); 754 755 d = pow.power(a, -2); 756 c = b.multiply(d); 757 assertTrue("a^2 * a^-2 = 1", c.isONE()); 758 759 b = pow.power(a, 3); 760 c = a.multiply(a).multiply(a); 761 assertEquals("a^3 = a*a*a", b, c); 762 763 d = pow.power(a, -3); 764 c = b.multiply(d); 765 assertTrue("a^3 * a^-3 = 1", c.isONE()); 766 767 //Java 8: 768 d = a.power(-3); 769 c = b.multiply(d); 770 assertTrue("a^3 * a^-3 = 1", c.isONE()); 771 } 772 773 774 /** 775 * Test power for Integer. 776 */ 777 public void testIntegerPower() { 778 BigInteger a, b, c, d, e; 779 a = BigInteger.ZERO.random(500); 780 781 // power operations 782 b = Power.<BigInteger> positivePower(a, 1); 783 assertEquals("a^1 = a", b, a); 784 785 Power<BigInteger> pow = new Power<BigInteger>(BigInteger.ONE); 786 b = pow.power(a, 1); 787 assertEquals("a^1 = a", b, a); 788 789 b = pow.power(a, 2); 790 c = a.multiply(a); 791 assertEquals("a^2 = a*a", b, c); 792 793 b = pow.power(a, 3); 794 c = a.multiply(a).multiply(a); 795 assertEquals("a^3 = a*a*a", b, c); 796 797 // mod power operations 798 a = new BigInteger(3); 799 b = Power.<BigInteger> positivePower(a, 1); 800 assertEquals("a^1 = a", b, a); 801 802 a = new BigInteger(11); 803 e = new BigInteger(2); 804 c = Power.<BigInteger> modPositivePower(a, 10, e); 805 assertTrue("3^n mod 2 = 1", c.isONE()); 806 807 // little fermat 808 a = BigInteger.ZERO.random(500); 809 b = new BigInteger(11); 810 c = Power.<BigInteger> modPositivePower(a, 11, b); 811 d = a.remainder(b); 812 assertEquals("a^p = a mod p", c, d); 813 814 c = pow.modPower(a, 11, b); 815 assertEquals("a^p = a mod p", c, d); 816 817 //Java 8: 818 a = BigInteger.ZERO.random(100); 819 d = a.power(1); 820 c = a; 821 assertEquals("a^1 == a", c, d); 822 823 d = a.power(0); 824 c = BigInteger.ONE; 825 assertEquals("a^0 == 1", c, d); 826 827 d = a.power(3); 828 c = a.multiply(a).multiply(a); 829 assertEquals("a^3 == a*a*a", c, d); 830 } 831 832 833 /** 834 * Test Combinatoric. 835 */ 836 public void testCombinatoric() { 837 BigInteger a, b, c; 838 839 a = Combinatoric.binCoeff(5, 0); 840 assertTrue("(5 0) == 1 ", a.isONE()); 841 842 a = Combinatoric.binCoeff(5, 7); 843 //System.out.println(5 + " over " + 7 + " = " + a); 844 assertTrue("(5 7) == 1 ", a.isONE()); 845 846 int n = 7; 847 for (int k = 0; k <= n; k++) { 848 a = Combinatoric.binCoeff(n, k); 849 b = Combinatoric.binCoeff(n, n - k); 850 assertEquals("(5 k) == (5 5-k) ", b, a); 851 //System.out.println(n + " over " + k + " = " + a); 852 } 853 assertTrue("(5 5) == 1 ", a.isONE()); 854 855 b = Combinatoric.binCoeffSum(n, n); 856 //System.out.println("sum( " + n + " over " + n + " ) = " + b); 857 c = Power.positivePower(new BigInteger(2), n); 858 assertEquals("sum(5 5) == 1 ", b, c); 859 860 b = Combinatoric.factorial(3); 861 assertEquals("3! == 6 ", b, new BigInteger(6)); 862 b = Combinatoric.factorial(0); 863 assertEquals("0! == 1 ", b, new BigInteger(1)); 864 } 865 866 867 /** 868 * Test square root. 869 */ 870 public void testSquareRoot() { 871 BigInteger a, b, c, d, e, f; 872 a = BigInteger.ONE; 873 874 b = a.random(47).abs(); 875 //b = c.multiply(c); 876 d = Roots.sqrtInt(b); 877 //System.out.println("b = " + b); 878 //System.out.println("root = " + d); 879 e = d.multiply(d); 880 //System.out.println("root^2 = " + e); 881 assertTrue("root^2 <= a ", e.compareTo(b) <= 0); 882 d = d.sum(BigInteger.ONE); 883 f = d.multiply(d); 884 //System.out.println("(root+1)^2 = " + f); 885 assertTrue("(root+1)^2 >= a ", f.compareTo(b) >= 0); 886 887 c = Roots.sqrt(b); 888 //System.out.println("b = " + b); 889 //System.out.println("root = " + c); 890 e = c.multiply(c); 891 //System.out.println("root^2 = " + e); 892 assertTrue("root^2 <= a ", e.compareTo(b) <= 0); 893 c = c.sum(BigInteger.ONE); 894 f = c.multiply(c); 895 //System.out.println("(root+1)^2 = " + f); 896 assertTrue("(root+1)^2 >= a ", f.compareTo(b) >= 0); 897 } 898 899 900 /** 901 * Test root. 902 */ 903 public void testRoot() { 904 BigInteger a, b, d, e, f; 905 a = BigInteger.ONE; 906 907 b = a.random(47).abs(); 908 //System.out.println("\nb = " + b); 909 //System.out.println("bitsize(b) = " + b.val.bitLength()); 910 for (int n = 2; n < 8; n++) { 911 d = Roots.root(b, n); 912 //System.out.println(n+"-th root = " + d); 913 e = Power.positivePower(d, n); 914 //System.out.println("root^"+n+" = " + e); 915 assertTrue("root^" + n + " <= a " + (b.subtract(e)), e.compareTo(b) <= 0); 916 d = d.sum(BigInteger.ONE); 917 f = Power.positivePower(d, n); 918 //System.out.println("(root+1)^"+n+" = " + f); 919 assertTrue("(root+1)^" + n + " >= a ", f.compareTo(b) >= 0); 920 } 921 } 922 923 924 /** 925 * Test root decimal. 926 */ 927 public void testRootDecimal() { 928 BigDecimal a, b, d, e; 929 a = BigDecimal.ONE; 930 931 b = a.random(17).abs(); 932 //System.out.println("\nb = " + b); 933 //System.out.println("ulp(b) = " + b.val.ulp()); 934 for (int n = 1; n < 8; n++) { 935 d = Roots.root(b, n); 936 //System.out.println(n+"-th root = " + d); 937 e = Power.positivePower(d, n); 938 //System.out.println("root^"+n+" = " + e); 939 if (b.compareTo(e) == 0) { 940 assertTrue("root^" + n + " == b: " + e, b.compareTo(e) == 0); 941 } else { 942 //System.out.println("b = " + b + ", root(b," + n +") = " + d); 943 System.out.print("b = " + b + ", "); 944 System.out.println("d^" + n + " = " + e + ", b-e = " + b.subtract(e).abs()); 945 //System.out.println("b~e = " + b.compareToAbsolute(e) + ", (b-e)/e = " + b.compareToRelative(e)); 946 } 947 } 948 } 949 950 951 /** 952 * Test root decimal. 953 */ 954 public void test2RootDecimal() { 955 BigDecimal a, b, c; 956 a = BigDecimal.ZERO; 957 b = Roots.sqrt(a); 958 assertTrue("sqrt(0) == 0: " + b, b.isZERO()); 959 960 a = BigDecimal.ONE; 961 b = Roots.sqrt(a); 962 assertTrue("sqrt(1) == 1: " + b, b.isONE()); 963 964 a = new BigDecimal("4"); 965 b = Roots.sqrt(a); 966 //b = Roots.root(a,2); 967 c = b.multiply(b); 968 assertTrue("sqrt(4)*sqrt(4) == 4: " + a.subtract(c), a.compareTo(c) == 0); 969 //System.out.println("DEFAULT_PRECISION = " + BigDecimal.DEFAULT_PRECISION); 970 971 a = new BigDecimal("0.5"); 972 b = Roots.sqrt(a); 973 //b = Roots.root(a,2); 974 c = b.multiply(b); 975 //System.out.println("a = " + a + ", sqrt(a) = " + b + ", b^2 = " + c); 976 assertTrue("sqrt(0.5)*sqrt(0.5) == 0.5: " + a.subtract(c), a.compareTo(c) == 0); 977 assertTrue("sqrt(0.5)*sqrt(0.5) == 0.5: " + b, a.compareTo(c) == 0); 978 979 a = a.random(5).abs(); 980 b = Roots.sqrt(a); 981 //b = Roots.root(a,2); 982 c = b.multiply(b); 983 //System.out.println("a = " + a + ", sqrt(a) = " + b + ", b^2 = " + c); 984 assertTrue("sqrt(a)*sqrt(a) == a: " + a.subtract(c), a.compareTo(c) == 0); 985 } 986 987 988 /** 989 * Test root complex decimal. 990 */ 991 public void testRootDecimalComplex() { 992 BigDecimalComplex a, b, c, d; 993 a = BigDecimalComplex.ZERO; 994 b = Roots.sqrt(a); 995 assertTrue("sqrt(0) == 0: " + b, b.isZERO()); 996 997 a = BigDecimalComplex.ONE; 998 b = Roots.sqrt(a); 999 assertTrue("sqrt(1) == 1: " + b, b.isONE()); 1000 1001 a = BigDecimalComplex.ONE.negate(); 1002 b = Roots.sqrt(a); 1003 d = b.multiply(b); 1004 //System.out.println("a = " + a + ", b = " + b + ", d = " + d); 1005 assertTrue("sqrt(-1) == I: " + b, b.isIMAG()); 1006 assertTrue("sqrt(-1)*sqrt(-1) == -1: " + a + ", b = " + b, a.compareTo(d) == 0); 1007 1008 b = BigDecimalComplex.I; 1009 c = Roots.sqrt(b); 1010 d = c.multiply(c); 1011 //System.out.println("b = " + b + ", c = " + c + ", d = " + d); 1012 assertTrue("sqrt(b)*sqrt(b) == b: " + c + ", b = " + b, b.compareTo(d) == 0); 1013 1014 b = a.fromInteger(4); 1015 c = Roots.sqrt(b); 1016 d = BigDecimalComplex.ONE.sum(BigDecimalComplex.ONE); 1017 //System.out.println("b = " + b + ", c = " + c + ", d = " + d); 1018 assertTrue("sqrt(4) == 2: " + c, c.compareTo(d) == 0); 1019 1020 b = b.multiply(BigDecimalComplex.I); 1021 c = Roots.sqrt(b); 1022 d = c.multiply(c); 1023 //System.out.println("b = " + b + ", c = " + c + ", d = " + d); 1024 assertTrue("sqrt(b)*sqrt(b) == b: " + c + ", b = " + b, b.compareTo(d) == 0); 1025 1026 b = a.random(5); 1027 c = Roots.sqrt(b); 1028 d = c.multiply(c); 1029 if (b.compareTo(d) != 0) { 1030 System.out.println("b = " + b + ", c = " + c + ", d = " + d); 1031 } 1032 assertTrue("sqrt(b)*sqrt(b) == b: b-d = " + b.subtract(d), b.compareTo(d) == 0); 1033 } 1034 1035}