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}