001/*
002 * $Id: ArithTest.java 5940 2018-10-19 08:53:13Z 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    @Override
050    protected void setUp() {
051        //a = b = c = d = e = null;
052    }
053
054
055    @Override
056    protected void tearDown() {
057        //a = b = c = d = e = null;
058    }
059
060
061    /**
062     * Test static initialization and constants for BigInteger.
063     */
064    public void testIntegerConstants() {
065        BigInteger a, b, c, d;
066        a = BigInteger.ZERO;
067        b = BigInteger.ONE;
068        c = b.subtract(b);
069
070        assertTrue("0.isZERO()", a.isZERO());
071        assertTrue("1.isONE", b.isONE());
072
073        assertEquals("1-1 = 0", c, a);
074        assertTrue("(1-1).isZERO()", c.isZERO());
075
076        d = b.multiply(b);
077        assertTrue("1*1 = 1", d.isONE());
078
079        d = b.multiply(a);
080        assertTrue("1*0 = 0", d.isZERO());
081    }
082
083
084    //--------------------------------------------------------
085
086
087    /**
088     * Test string constructor and toString for BigInteger.
089     */
090    public void testIntegerConstructor() {
091        BigInteger a, b, c, d;
092        a = new BigInteger(1);
093        b = new BigInteger(-1);
094        c = new BigInteger(0);
095
096        d = a.sum(b);
097        assertTrue("'1'.isONE()", a.isONE());
098        assertTrue("1+(-1) = 0", d.isZERO());
099        d = a.negate();
100        assertEquals("-1 = -(1)", d, b);
101
102        d = a.multiply(c);
103        assertTrue("'0'.isZERO()", d.isZERO());
104        d = b.multiply(b);
105        assertTrue("(-1)*(-1) = 1", d.isONE());
106
107        a = new BigInteger(3);
108        b = new BigInteger("3");
109        assertEquals("3 = '3'", a, b);
110
111        a = new BigInteger(-5);
112        b = new BigInteger("-5");
113        assertEquals("-5 = '-5'", a, b);
114
115        //          0         1         2         3         4 
116        //          0123456789012345678901234567890123456789012345
117        String s = "1111111111111111111111111111111111111111111111";
118        a = new BigInteger(s);
119        String t = a.toString();
120        assertEquals("stringConstr = toString", s, t);
121    }
122
123
124    //--------------------------------------------------------
125
126    /**
127     * Test random and compares Integer.
128     */
129    public void testIntegerRandom() {
130        BigInteger a, b, c;
131        a = BigInteger.ZERO.random(500);
132        b = new BigInteger("" + a);
133        c = b.subtract(a);
134
135        assertTrue("a-'a' = 0", c.isZERO());
136        assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a));
137        assertEquals("signum('a'-a) = 0", 0, c.signum());
138    }
139
140
141    //--------------------------------------------------------
142
143
144    /**
145     * Test addition for Integer.
146     */
147    public void testIntegerAddition() {
148        BigInteger a, b, c, d, e;
149        // neutral element
150        a = BigInteger.ZERO.random(500);
151        d = a.sum(BigInteger.ZERO);
152        assertEquals("a+0 = a", d, a);
153        d = a.subtract(BigInteger.ZERO);
154        assertEquals("a-0 = a", d, a);
155
156        // inverse operations
157        b = a.sum(a);
158        c = b.subtract(a);
159        assertEquals("(a+a)-a = a", c, a);
160        b = a.subtract(a);
161        c = b.sum(a);
162        assertEquals("(a-a)+a = a", c, a);
163
164        // comutativity
165        b = BigInteger.ZERO.random(500);
166        c = a.sum(b);
167        d = b.sum(a);
168        assertEquals("a+b = b+a", c, d);
169
170        // negation
171        c = a.subtract(b);
172        d = a.sum(b.negate());
173        assertEquals("a-b = a+(-b)", c, d);
174
175        // associativity
176        c = BigInteger.ZERO.random(500);
177        d = a.sum(b.sum(c));
178        e = a.sum(b).sum(c);
179        assertEquals("a+(b+c) = (a+b)+c", d, e);
180    }
181
182
183    //--------------------------------------------------------
184
185
186    /**
187     * Test multiplication for Integer.
188     */
189    public void testIntegerMultiplication() {
190        BigInteger a, b, c, d, e;
191        // neutral element
192        a = BigInteger.ZERO.random(500);
193        d = a.multiply(BigInteger.ONE);
194        assertEquals("a*1 = a", d, a);
195        d = a.divide(BigInteger.ONE);
196        assertEquals("a/1 = a", d, a);
197
198        // inverse operations
199        b = a.multiply(a);
200        c = b.divide(a);
201        assertEquals("(a*a)/a = a", c, a);
202        b = a.divide(a);
203        c = b.multiply(a);
204        assertEquals("(a/a)*a = a", c, a);
205
206        // comutativity
207        b = BigInteger.ZERO.random(500);
208        c = a.multiply(b);
209        d = b.multiply(a);
210        assertEquals("a*b = b*a", c, d);
211
212        // inverse
213        d = c.divide(b);
214        // e = c.multiply( b.inverse() );
215        e = a;
216        assertEquals("a/b = a*(1/b)", d, e);
217
218        // associativity
219        c = BigInteger.ZERO.random(500);
220        d = a.multiply(b.multiply(c));
221        e = a.multiply(b).multiply(c);
222        assertEquals("a*(b*c) = (a*b)*c", d, e);
223    }
224
225
226    /**
227     * Test static initialization and constants for BigRational.
228     */
229    public void testRationalConstants() {
230        BigRational a, b, c, d;
231        a = BigRational.ZERO;
232        b = BigRational.ONE;
233        //System.out.println("a = " + a);
234        //System.out.println("b = " + b);
235        c = b.subtract(b);
236
237        assertTrue("0.isZERO()", a.isZERO());
238        assertTrue("1.isONE", b.isONE());
239
240        assertEquals("1-1 = 0", c, a);
241        assertTrue("(1-1).isZERO()", c.isZERO());
242
243        d = b.multiply(b);
244        assertTrue("1*1 = 1", d.isONE());
245
246        d = b.multiply(a);
247        assertTrue("1*0 = 0", d.isZERO());
248    }
249
250
251    /**
252     * Test static initialization and constants for BigComplex.
253     */
254    public void testComplexConstants() {
255        BigComplex a, b, c, d;
256        a = BigComplex.ZERO;
257        b = BigComplex.ONE;
258        c = b.subtract(b);
259
260        assertTrue("0.isZERO()", a.isZERO());
261        assertTrue("1.isONE", b.isONE());
262
263        assertEquals("1-1 = 0", c, a);
264        assertTrue("(1-1).isZERO()", c.isZERO());
265
266        d = b.multiply(b);
267        assertTrue("1*1 = 1", d.isONE());
268
269        d = b.multiply(a);
270        assertTrue("1*0 = 0", d.isZERO());
271    }
272
273
274    /**
275     * Test static initialization and constants for BigQuaternion.
276     */
277    public void testQuaternionConstants() {
278        BigQuaternionRing fac = new BigQuaternionRing();
279        BigQuaternion a, b, c, d;
280        a = fac.ZERO;
281        b = fac.ONE;
282        c = b.subtract(b);
283
284        assertTrue("0.isZERO()", a.isZERO());
285        assertTrue("1.isONE", b.isONE());
286
287        assertEquals("1-1 = 0", c, a);
288        assertTrue("(1-1).isZERO()", c.isZERO());
289
290        d = b.multiply(b);
291        assertTrue("1*1 = 1", d.isONE());
292
293        d = b.multiply(a);
294        assertTrue("1*0 = 0", d.isZERO());
295    }
296
297
298    //--------------------------------------------------------
299
300
301    /**
302     * Test string constructor and toString for BigRational.
303     */
304    public void testRationalConstructor() {
305        BigRational a, b, c, d;
306        a = new BigRational(1);
307        b = new BigRational(-1);
308        c = new BigRational(0);
309
310        d = a.sum(b);
311        assertTrue("'1'.isONE()", a.isONE());
312        assertTrue("1+(-1) = 0", d.isZERO());
313        d = a.negate();
314        assertEquals("-1 = -(1)", d, b);
315
316        d = a.multiply(c);
317        assertTrue("'0'.isZERO()", d.isZERO());
318        d = b.multiply(b);
319        assertTrue("(-1)*(-1) = 1", d.isONE());
320
321        a = new BigRational(3);
322        b = new BigRational("3");
323        assertEquals("3 = '3'", a, b);
324
325        a = new BigRational(-5);
326        b = new BigRational("-5");
327        assertEquals("-5 = '-5'", a, b);
328
329        //          0         1         2         3         4 
330        //          0123456789012345678901234567890123456789012345
331        String s = "1111111111111111111111111111111111111111111111";
332        a = new BigRational(s);
333        String t = a.toString();
334        assertEquals("stringConstr = toString", s, t);
335
336        s = "2/4";
337        a = new BigRational(s);
338        t = a.toString(5);
339        //System.out.println("a = " + a);
340        //System.out.println("t = " + t);
341        String r = "0.5";
342        assertEquals("stringConstr = toString", r, t);
343    }
344
345
346    /**
347     * Test string constructor and toString for BigComplex.
348     */
349    public void testComplexConstructor() {
350        BigComplex a, b, c, d;
351        a = new BigComplex(1);
352        b = new BigComplex(-1);
353        c = new BigComplex(0);
354
355        d = a.sum(b);
356        assertTrue("'1'.isONE()", a.isONE());
357        assertTrue("1+(-1) = 0", d.isZERO());
358        d = a.negate();
359        assertEquals("-1 = -(1)", d, b);
360
361        d = a.multiply(c);
362        assertTrue("'0'.isZERO()", d.isZERO());
363        d = b.multiply(b);
364        assertTrue("(-1)*(-1) = 1", d.isONE());
365
366        a = new BigComplex(3);
367        b = new BigComplex("3");
368        assertEquals("3 = '3'", a, b);
369
370        a = new BigComplex(-5);
371        b = new BigComplex("-5");
372        assertEquals("-5 = '-5'", a, b);
373
374        //          0         1         2         3         4 
375        //          0123456789012345678901234567890123456789012345
376        String s = "1111111111111111111111111111111111111111111111";
377        a = new BigComplex(s);
378        String t = a.toString();
379        assertEquals("stringConstr = toString", s, t);
380    }
381
382
383    /**
384     * Test string constructor and toString for BigQuaternion.
385     */
386    public void testQuaternionConstructor() {
387        BigQuaternionRing fac = new BigQuaternionRing();
388        BigQuaternion a, b, c, d;
389        a = new BigQuaternion(fac, 1);
390        b = new BigQuaternion(fac, -1);
391        c = new BigQuaternion(fac, 0);
392
393        d = a.sum(b);
394        assertTrue("'1'.isONE()", a.isONE());
395        assertTrue("1+(-1) = 0", d.isZERO());
396        d = a.negate();
397        assertEquals("-1 = -(1)", d, b);
398
399        d = a.multiply(c);
400        assertTrue("'0'.isZERO()", d.isZERO());
401        d = b.multiply(b);
402        assertTrue("(-1)*(-1) = 1", d.isONE());
403
404        a = new BigQuaternion(fac, 3);
405        b = new BigQuaternion(fac, "3");
406        assertEquals("3 = '3'", a, b);
407
408        a = new BigQuaternion(fac, -5);
409        b = new BigQuaternion(fac, "-5");
410        assertEquals("-5 = '-5'", a, b);
411
412        //          0         1         2         3         4 
413        //          0123456789012345678901234567890123456789012345
414        String s = "1111111111111111111111111111111111111111111111";
415        a = new BigQuaternion(fac, s);
416        String t = a.toString();
417        assertEquals("stringConstr = toString", s, t);
418    }
419
420
421    //--------------------------------------------------------
422
423
424    /**
425     * Test random and compares Rational.
426     */
427    public void testRationalRandom() {
428        BigRational a, b, c;
429        a = BigRational.ZERO.random(500);
430        b = new BigRational("" + a);
431        c = b.subtract(a);
432
433        assertTrue("a-'a' = 0", c.isZERO());
434        assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a));
435        assertEquals("signum('a'-a) = 0", 0, c.signum());
436    }
437
438
439    /**
440     * Test random and compares Complex.
441     */
442    public void testComplexRandom() {
443        BigComplex a, b, c;
444        a = BigComplex.ZERO.random(500);
445        b = new BigComplex("" + a);
446        c = b.subtract(a);
447
448        assertTrue("a-'a' = 0", c.isZERO());
449        assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a));
450        assertEquals("signum('a'-a) = 0", 0, c.signum());
451    }
452
453
454    /**
455     * Test random and compares Quaternion.
456     */
457    public void testQuaternionRandom() {
458        BigQuaternionRing fac = new BigQuaternionRing();
459        BigQuaternion a, b, c;
460        a = fac.random(500);
461        b = new BigQuaternion(fac, a.toString());
462        c = b.subtract(a);
463
464        assertTrue("a-'a' = 0", c.isZERO());
465        assertEquals("signum('a'-a) = 0", 0, c.signum());
466        assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a));
467    }
468
469
470    //--------------------------------------------------------
471
472
473    /**
474     * Test addition for Rational.
475     */
476    public void testRationalAddition() {
477        BigRational a, b, c, d, e;
478        // neutral element
479        a = BigRational.ZERO.random(500);
480        d = a.sum(BigRational.ZERO);
481        assertEquals("a+0 = a", d, a);
482        d = a.subtract(BigRational.ZERO);
483        assertEquals("a-0 = a", d, a);
484
485        // inverse operations
486        b = a.sum(a);
487        c = b.subtract(a);
488        assertEquals("(a+a)-a = a", c, a);
489        b = a.subtract(a);
490        c = b.sum(a);
491        assertEquals("(a-a)+a = a", c, a);
492
493        // comutativity
494        b = BigRational.ZERO.random(500);
495        c = a.sum(b);
496        d = b.sum(a);
497        assertEquals("a+b = b+a", c, d);
498
499        // negation
500        c = a.subtract(b);
501        d = a.sum(b.negate());
502        assertEquals("a-b = a+(-b)", c, d);
503
504        // associativity
505        c = BigRational.ZERO.random(500);
506        d = a.sum(b.sum(c));
507        e = a.sum(b).sum(c);
508        assertEquals("a+(b+c) = (a+b)+c", d, e);
509    }
510
511
512    /**
513     * Test addition for Complex.
514     */
515    public void testComplexAddition() {
516        BigComplex a, b, c, d, e;
517        // neutral element
518        a = BigComplex.ZERO.random(500);
519        d = a.sum(BigComplex.ZERO);
520        assertEquals("a+0 = a", d, a);
521        d = a.subtract(BigComplex.ZERO);
522        assertEquals("a-0 = a", d, a);
523
524        // inverse operations
525        b = a.sum(a);
526        c = b.subtract(a);
527        assertEquals("(a+a)-a = a", c, a);
528        b = a.subtract(a);
529        c = b.sum(a);
530        assertEquals("(a-a)+a = a", c, a);
531
532        // comutativity
533        b = BigComplex.ZERO.random(500);
534        c = a.sum(b);
535        d = b.sum(a);
536        assertEquals("a+b = b+a", c, d);
537
538        // negation
539        c = a.subtract(b);
540        d = a.sum(b.negate());
541        assertEquals("a-b = a+(-b)", c, d);
542
543        // associativity
544        c = BigComplex.ZERO.random(500);
545        d = a.sum(b.sum(c));
546        e = a.sum(b).sum(c);
547        assertEquals("a+(b+c) = (a+b)+c", d, e);
548    }
549
550
551    /**
552     * Test addition for Quaternion.
553     */
554    public void testQuaternionAddition() {
555        BigQuaternionRing fac = new BigQuaternionRing();
556        BigQuaternion a, b, c, d, e;
557        // neutral element
558        a = fac.random(500);
559        d = a.sum(fac.ZERO);
560        assertEquals("a+0 = a", d, a);
561        d = a.subtract(fac.ZERO);
562        assertEquals("a-0 = a", d, a);
563
564        // inverse operations
565        b = a.sum(a);
566        c = b.subtract(a);
567        assertEquals("(a+a)-a = a", c, a);
568        b = a.subtract(a);
569        c = b.sum(a);
570        assertEquals("(a-a)+a = a", c, a);
571
572        // comutativity
573        b = fac.random(500);
574        c = a.sum(b);
575        d = b.sum(a);
576        assertEquals("a+b = b+a", c, d);
577
578        // negation
579        c = a.subtract(b);
580        d = a.sum(b.negate());
581        assertEquals("a-b = a+(-b)", c, d);
582
583        // associativity
584        c = fac.random(500);
585        d = a.sum(b.sum(c));
586        e = a.sum(b).sum(c);
587        assertEquals("a+(b+c) = (a+b)+c", d, e);
588    }
589
590
591    //--------------------------------------------------------
592
593
594    /**
595     * Test multiplication for Rational.
596     */
597    public void testRationalMultiplication() {
598        BigRational a, b, c, d, e;
599        // neutral element
600        a = BigRational.ZERO.random(500);
601        d = a.multiply(BigRational.ONE);
602        assertEquals("a*1 = a", d, a);
603        d = a.divide(BigRational.ONE);
604        assertEquals("a/1 = a", d, a);
605
606        // inverse operations
607        b = a.multiply(a);
608        c = b.divide(a);
609        assertEquals("(a*a)/a = a", c, a);
610        b = a.divide(a);
611        c = b.multiply(a);
612        assertEquals("(a/a)*a = a", c, a);
613
614        // comutativity
615        b = BigRational.ZERO.random(500);
616        c = a.multiply(b);
617        d = b.multiply(a);
618        assertEquals("a*b = b*a", c, d);
619
620        // inverse
621        d = c.divide(b);
622        e = c.multiply(b.inverse());
623        //e = a;
624        assertEquals("a/b = a*(1/b)", d, e);
625
626        // associativity
627        c = BigRational.ZERO.random(500);
628        d = a.multiply(b.multiply(c));
629        e = a.multiply(b).multiply(c);
630        assertEquals("a*(b*c) = (a*b)*c", d, e);
631    }
632
633
634    /**
635     * Test multiplication for Complex.
636     */
637    public void testComplexMultiplication() {
638        BigComplex a, b, c, d, e;
639        // neutral element
640        a = BigComplex.ZERO.random(500);
641        d = a.multiply(BigComplex.ONE);
642        assertEquals("a*1 = a", d, a);
643        d = a.divide(BigComplex.ONE);
644        assertEquals("a/1 = a", d, a);
645
646        // inverse operations
647        b = a.multiply(a);
648        c = b.divide(a);
649        assertEquals("(a*a)/a = a", c, a);
650        b = a.divide(a);
651        c = b.multiply(a);
652        assertEquals("(a/a)*a = a", c, a);
653
654        // comutativity
655        b = BigComplex.ZERO.random(500);
656        c = a.multiply(b);
657        d = b.multiply(a);
658        assertEquals("a*b = b*a", c, d);
659
660        // inverse
661        d = c.divide(b);
662        e = c.multiply(b.inverse());
663        //e = a;
664        assertEquals("a/b = a*(1/b)", d, e);
665
666        // associativity
667        c = BigComplex.ZERO.random(500);
668        d = a.multiply(b.multiply(c));
669        e = a.multiply(b).multiply(c);
670        assertEquals("a*(b*c) = (a*b)*c", d, e);
671    }
672
673
674    /**
675     * Test multiplication for Quaternion.
676     */
677    public void testQuaternionMultiplication() {
678        BigQuaternionRing fac = new BigQuaternionRing();
679        BigQuaternion a, b, c, d, e;
680        // neutral element
681        a = fac.random(500);
682        d = a.multiply(fac.ONE);
683        assertEquals("a*1 = a", d, a);
684        d = a.divide(fac.ONE);
685        assertEquals("a/1 = a", d, a);
686
687        // inverse operations
688        b = a.multiply(a);
689        c = b.divide(a);
690        assertEquals("(a*a)/a = a", c, a);
691        b = a.divide(a);
692        c = b.multiply(a);
693        assertEquals("(a/a)*a = a", c, a);
694
695        // inverse
696        b = fac.random(500);
697        c = b.multiply(a);
698        d = c.divide(b);
699        e = c.multiply(b.inverse());
700        //e = a;
701        assertEquals("a/b = a*(1/b)", d, e);
702
703        // associativity
704        c = fac.random(500);
705        d = a.multiply(b.multiply(c));
706        e = a.multiply(b).multiply(c);
707        assertEquals("a*(b*c) = (a*b)*c", d, e);
708
709        // non comutativity
710        a = fac.I;
711        b = fac.J;
712        c = a.multiply(b);
713        d = b.multiply(a);
714        assertEquals("I*J = -J*I", c, d.negate());
715        a = fac.I;
716        b = fac.K;
717        c = a.multiply(b);
718        d = b.multiply(a);
719        assertEquals("I*K = -K*I", c, d.negate());
720        a = fac.J;
721        b = fac.K;
722        c = a.multiply(b);
723        d = b.multiply(a);
724        assertEquals("J*K = -K*J", c, d.negate());
725    }
726
727
728    /**
729     * Test power for Rational.
730     */
731    public void testRationalPower() {
732        BigRational a, b, c, d;
733        a = BigRational.ZERO.random(100);
734
735        // power operations
736        b = Power.<BigRational> positivePower(a, 1);
737        assertEquals("a^1 = a", b, a);
738
739        Power<BigRational> pow = new Power<BigRational>(BigRational.ONE);
740        b = pow.power(a, 1);
741        assertEquals("a^1 = a", b, a);
742
743        b = pow.power(a, 2);
744        c = a.multiply(a);
745        assertEquals("a^2 = a*a", b, c);
746
747        d = pow.power(a, -2);
748        c = b.multiply(d);
749        assertTrue("a^2 * a^-2 = 1", c.isONE());
750
751        b = pow.power(a, 3);
752        c = a.multiply(a).multiply(a);
753        assertEquals("a^3 = a*a*a", b, c);
754
755        d = pow.power(a, -3);
756        c = b.multiply(d);
757        assertTrue("a^3 * a^-3 = 1", c.isONE());
758
759        //Java 8:
760        d = a.power(-3);
761        c = b.multiply(d);
762        assertTrue("a^3 * a^-3 = 1", c.isONE());
763    }
764
765
766    /**
767     * Test power for Integer.
768     */
769    public void testIntegerPower() {
770        BigInteger a, b, c, d, e;
771        a = BigInteger.ZERO.random(500);
772
773        // power operations
774        b = Power.<BigInteger> positivePower(a, 1);
775        assertEquals("a^1 = a", b, a);
776
777        Power<BigInteger> pow = new Power<BigInteger>(BigInteger.ONE);
778        b = pow.power(a, 1);
779        assertEquals("a^1 = a", b, a);
780
781        b = pow.power(a, 2);
782        c = a.multiply(a);
783        assertEquals("a^2 = a*a", b, c);
784
785        b = pow.power(a, 3);
786        c = a.multiply(a).multiply(a);
787        assertEquals("a^3 = a*a*a", b, c);
788
789        // mod power operations
790        a = new BigInteger(3);
791        b = Power.<BigInteger> positivePower(a, 1);
792        assertEquals("a^1 = a", b, a);
793
794        a = new BigInteger(11);
795        e = new BigInteger(2);
796        c = Power.<BigInteger> modPositivePower(a, 10, e);
797        assertTrue("3^n mod 2 = 1", c.isONE());
798
799        // little fermat
800        a = BigInteger.ZERO.random(500);
801        b = new BigInteger(11);
802        c = Power.<BigInteger> modPositivePower(a, 11, b);
803        d = a.remainder(b);
804        assertEquals("a^p = a mod p", c, d);
805
806        c = pow.modPower(a, 11, b);
807        assertEquals("a^p = a mod p", c, d);
808
809        //Java 8:
810        a = BigInteger.ZERO.random(100);
811        d = a.power(1);
812        c = a;
813        assertEquals("a^1 == a", c, d);
814
815        d = a.power(0);
816        c = BigInteger.ONE;
817        assertEquals("a^0 == 1", c, d);
818
819        d = a.power(3);
820        c = a.multiply(a).multiply(a);
821        assertEquals("a^3 == a*a*a", c, d);
822    }
823
824
825    /**
826     * Test Combinatoric.
827     */
828    public void testCombinatoric() {
829        BigInteger a, b, c;
830
831        a = Combinatoric.binCoeff(5, 0);
832        assertTrue("(5 0) == 1 ", a.isONE());
833
834        a = Combinatoric.binCoeff(5, 7);
835        //System.out.println(5 + " over " + 7 + " = " + a);
836        assertTrue("(5 7) == 1 ", a.isONE());
837
838        int n = 7;
839        for (int k = 0; k <= n; k++) {
840            a = Combinatoric.binCoeff(n, k);
841            b = Combinatoric.binCoeff(n, n - k);
842            assertEquals("(5 k) == (5 5-k) ", b, a);
843            //System.out.println(n + " over " + k + " = " + a);
844        }
845        assertTrue("(5 5) == 1 ", a.isONE());
846
847        b = Combinatoric.binCoeffSum(n, n);
848        //System.out.println("sum( " + n + " over " + n + " ) = " + b);
849        c = Power.positivePower(new BigInteger(2), n);
850        assertEquals("sum(5 5) == 1 ", b, c);
851
852        b = Combinatoric.factorial(3);
853        assertEquals("3! == 6 ", b, new BigInteger(6));
854        b = Combinatoric.factorial(0);
855        assertEquals("0! == 1 ", b, new BigInteger(1));
856    }
857
858
859    /**
860     * Test square root.
861     */
862    public void testSquareRoot() {
863        BigInteger a, b, c, d, e, f;
864        a = BigInteger.ONE;
865
866        b = a.random(47).abs();
867        //b = c.multiply(c);
868        d = Roots.sqrtInt(b);
869        //System.out.println("b          = " + b);
870        //System.out.println("root       = " + d);
871        e = d.multiply(d);
872        //System.out.println("root^2     = " + e);
873        assertTrue("root^2 <= a ", e.compareTo(b) <= 0);
874        d = d.sum(BigInteger.ONE);
875        f = d.multiply(d);
876        //System.out.println("(root+1)^2 = " + f);
877        assertTrue("(root+1)^2 >= a ", f.compareTo(b) >= 0);
878
879        c = Roots.sqrt(b);
880        //System.out.println("b          = " + b);
881        //System.out.println("root       = " + c);
882        e = c.multiply(c);
883        //System.out.println("root^2     = " + e);
884        assertTrue("root^2 <= a ", e.compareTo(b) <= 0);
885        c = c.sum(BigInteger.ONE);
886        f = c.multiply(c);
887        //System.out.println("(root+1)^2 = " + f);
888        assertTrue("(root+1)^2 >= a ", f.compareTo(b) >= 0);
889    }
890
891
892    /**
893     * Test root.
894     */
895    public void testRoot() {
896        BigInteger a, b, d, e, f;
897        a = BigInteger.ONE;
898
899        b = a.random(47).abs();
900        //System.out.println("\nb          = " + b);
901        //System.out.println("bitsize(b) = " + b.val.bitLength());
902        for (int n = 2; n < 8; n++) {
903            d = Roots.root(b, n);
904            //System.out.println(n+"-th root  = " + d);
905            e = Power.positivePower(d, n);
906            //System.out.println("root^"+n+"     = " + e);
907            assertTrue("root^" + n + " <= a " + (b.subtract(e)), e.compareTo(b) <= 0);
908            d = d.sum(BigInteger.ONE);
909            f = Power.positivePower(d, n);
910            //System.out.println("(root+1)^"+n+" = " + f);
911            assertTrue("(root+1)^" + n + " >= a ", f.compareTo(b) >= 0);
912        }
913    }
914
915
916    /**
917     * Test root decimal.
918     */
919    public void testRootDecimal() {
920        BigDecimal a, b, d, e;
921        a = BigDecimal.ONE;
922        BigRational eps = new BigRational(1,10).power(BigDecimal.DEFAULT_PRECISION-2);
923        BigDecimal epsd = new BigDecimal(eps);
924        
925        b = a.random(17).abs();
926        //System.out.println("\nb         = " + b);
927        //System.out.println("ulp(b)     = " + b.val.ulp());
928        for (int n = 1; n < 8; n++) {
929            d = Roots.root(b, n);
930            //System.out.println(n+"-th root = " + d);
931            e = Power.positivePower(d, n);
932            //System.out.println("root^"+n+"    = " + e);
933            if (b.compareTo(e) == 0) {
934                assertTrue("root^" + n + " == b: " + e, b.compareTo(e) == 0);
935                continue;
936            }
937            BigDecimal r = b.subtract(e).abs().divide(b.abs().sum(e.abs()));
938            assertTrue("root(a,n)**n == a: " + r, r.compareTo(epsd) <= 0);
939        }
940    }
941
942
943    /**
944     * Test root decimal.
945     */
946    public void test2RootDecimal() {
947        BigDecimal a, b, c;
948        a = BigDecimal.ZERO;
949        b = Roots.sqrt(a);
950        assertTrue("sqrt(0) == 0: " + b, b.isZERO());
951
952        a = BigDecimal.ONE;
953        b = Roots.sqrt(a);
954        assertTrue("sqrt(1) == 1: " + b, b.isONE());
955
956        a = new BigDecimal("4");
957        b = Roots.sqrt(a);
958        //b = Roots.root(a,2);
959        c = b.multiply(b);
960        assertTrue("sqrt(4)*sqrt(4) == 4: " + a.subtract(c), a.compareTo(c) == 0);
961        //System.out.println("DEFAULT_PRECISION = " + BigDecimal.DEFAULT_PRECISION);
962
963        a = new BigDecimal("0.5");
964        b = Roots.sqrt(a);
965        //b = Roots.root(a,2);
966        c = b.multiply(b);
967        //System.out.println("a = " + a + ", sqrt(a) = " + b + ", b^2 = " + c);
968        assertTrue("sqrt(0.5)*sqrt(0.5) == 0.5: " + a.subtract(c), a.compareTo(c) == 0);
969        assertTrue("sqrt(0.5)*sqrt(0.5) == 0.5: " + b, a.compareTo(c) == 0);
970
971        a = a.random(5).abs();
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(a)*sqrt(a) == a: " + a.subtract(c), a.compareTo(c) == 0);
977    }
978
979
980    /**
981     * Test root complex decimal.
982     */
983    public void testRootDecimalComplex() {
984        BigDecimalComplex a, b, c, d, e;
985        a = BigDecimalComplex.ZERO;
986        b = Roots.sqrt(a);
987        assertTrue("sqrt(0) == 0: " + b, b.isZERO());
988
989        a = BigDecimalComplex.ONE;
990        b = Roots.sqrt(a);
991        assertTrue("sqrt(1) == 1: " + b, b.isONE());
992
993        a = BigDecimalComplex.ONE.negate();
994        b = Roots.sqrt(a);
995        d = b.multiply(b);
996        //System.out.println("a = " + a + ", b = " + b + ", d = " + d);
997        assertTrue("sqrt(-1) == I: " + b, b.isIMAG());
998        assertTrue("sqrt(-1)*sqrt(-1) == -1: " + a + ", b = " + b, a.compareTo(d) == 0);
999
1000        b = BigDecimalComplex.I;
1001        c = Roots.sqrt(b);
1002        d = c.multiply(c);
1003        //System.out.println("b = " + b + ", c = " + c + ", d = " + d);
1004        assertTrue("sqrt(b)*sqrt(b) == b: " + c + ", b = " + b, b.compareTo(d) == 0);
1005
1006        b = a.fromInteger(4);
1007        c = Roots.sqrt(b);
1008        d = BigDecimalComplex.ONE.sum(BigDecimalComplex.ONE);
1009        //System.out.println("b = " + b + ", c = " + c + ", d = " + d);
1010        assertTrue("sqrt(4) == 2: " + c, c.compareTo(d) == 0);
1011
1012        b = b.multiply(BigDecimalComplex.I);
1013        c = Roots.sqrt(b);
1014        d = c.multiply(c);
1015        //System.out.println("b = " + b + ", c = " + c + ", d = " + d);
1016        assertTrue("sqrt(b)*sqrt(b) == b: " + c + ", b = " + b, b.compareTo(d) == 0);
1017
1018        b = a.random(5);
1019        c = b.norm();
1020        d = b.multiply(b.conjugate());
1021        assertTrue("norm(b) == b*b^: b-d = " + c.subtract(d), c.compareTo(d) == 0);
1022
1023        BigRational eps = new BigRational(1,10).power(BigDecimal.DEFAULT_PRECISION-1);
1024        //System.out.println("eps = " + eps + ", epsd = " + new BigDecimal(eps));
1025        BigDecimal epsd = new BigDecimal(eps);
1026        BigDecimal dd;
1027        
1028        //System.out.println("b = " + b + ", c = " + c);
1029        //c = b.norm();
1030        d = b.abs();
1031        e = d.multiply(d);
1032        dd = e.re.subtract(c.re).abs().divide(e.re.abs().sum(c.re.abs()));
1033        //System.out.println("dd = " + dd + ", d = " + d + ", e = " + e);
1034        assertTrue("abs()*abs() == norm(): " + dd, dd.compareTo(epsd) <= 0);
1035    }
1036
1037
1038    /**
1039     * Test root rational.
1040     */
1041    public void test2RootRational() {
1042        BigRational a, b, c, d;
1043        a = BigRational.ZERO;
1044        b = Roots.sqrt(a);
1045        assertTrue("sqrt(0) == 0: " + b, b.isZERO());
1046
1047        a = BigRational.ONE;
1048        b = Roots.sqrt(a);
1049        assertTrue("sqrt(1) == 1: " + b, b.isONE());
1050
1051        a = BigRational.ONE.negate();
1052        try {
1053            b = Roots.sqrt(a);
1054            fail("sqrt(-1) illegal: " + b);
1055        } catch (ArithmeticException e) {
1056            // pass
1057        }
1058
1059        a = new BigRational("4");
1060        b = Roots.sqrt(a);
1061        c = b.multiply(b);
1062        assertTrue("sqrt(4)*sqrt(4) == 4: " + a.subtract(c), a.compareTo(c) == 0);
1063        BigRational eps = new BigRational(1,10).power(BigDecimal.DEFAULT_PRECISION-1);
1064        //System.out.println("eps = " + eps + ", epsd = " + new BigDecimal(eps));
1065        
1066        a = new BigRational("0.5");
1067        b = Roots.sqrt(a);
1068        c = b.multiply(b);
1069        //System.out.println("a = " + a + ", sqrt(a) = " + b + ", b^2 = " + c);
1070        d = a.subtract(c).abs().divide(a.abs().sum(c.abs()));
1071        //System.out.println("d = " + d + ", dd = " + new BigDecimal(d));
1072        assertTrue("sqrt(0.5)*sqrt(0.5) == 0.5: " + c, d.compareTo(eps) <= 0);
1073
1074        a = a.random(5).abs();
1075        b = Roots.sqrt(a);
1076        c = b.multiply(b);
1077        //System.out.println("a = " + a + ", sqrt(a) = " + b + ", b^2 = " + c);
1078        d = a.subtract(c).abs().divide(a.abs().sum(c.abs()));
1079        //System.out.println("d = " + d + ", dd = " + new BigDecimal(d));
1080        assertTrue("sqrt(0.5)*sqrt(0.5) == 0.5: " + c, d.compareTo(eps) <= 0);
1081    }
1082
1083    
1084    /**
1085     * Test root/norm complex.
1086     */
1087    public void test2NormComplex() {
1088        BigComplex a, b, c, d;
1089        a = BigComplex.ZERO;
1090        b = a.abs();
1091        assertTrue("abs(0) == 0: " + b, b.isZERO());
1092
1093        a = BigComplex.ONE;
1094        b = a.abs();
1095        assertTrue("abs(1) == 1: " + b, b.isONE());
1096
1097        a = BigComplex.ONE.negate();
1098        b = a.abs();
1099        assertTrue("abs(-1): " + b, b.isONE());
1100
1101        BigRational eps = new BigRational(1,10).power(BigDecimal.DEFAULT_PRECISION-1);
1102        //System.out.println("eps = " + eps); // + ", epsd = " + new BigDecimal(eps));
1103
1104        BigRational r, s, t;
1105        a = a.random(5);
1106        b = a.abs();
1107        //System.out.println("a = " + a + ", b = " + b);
1108        r = b.multiply(b).re;
1109        s = a.multiply(a.conjugate()).re;
1110        //System.out.println("r = " + r + ", s = " + s);
1111        t = r.subtract(s).abs().divide(r.abs().sum(s.abs()));
1112        //System.out.println("t = " + t + ", eps = " + eps);
1113        assertTrue("abs()*abs() == norm(): " + b, t.compareTo(eps) <= 0);
1114    }
1115
1116
1117    /**
1118     * Test root/norm quaternion.
1119     */
1120    public void test2NormQuaternion() {
1121        BigQuaternion a, b, c, d;
1122        BigQuaternionRing fac = new BigQuaternionRing();
1123        a = fac.ZERO;
1124        b = a.abs();
1125        assertTrue("abs(0) == 0: " + b, b.isZERO());
1126
1127        a = fac.ONE;
1128        b = a.abs();
1129        assertTrue("abs(1) == 1: " + b, b.isONE());
1130
1131        a = fac.ONE.negate();
1132        b = a.abs();
1133        assertTrue("abs(-1): " + b, b.isONE());
1134
1135        BigRational eps = new BigRational(1,10).power(BigDecimal.DEFAULT_PRECISION-1);
1136        //System.out.println("eps = " + eps); // + ", epsd = " + new BigDecimal(eps));
1137
1138        BigRational r, s, t;
1139        a = fac.random(5);
1140        b = a.abs();
1141        //System.out.println("\na = " + a + ", b = " + b);
1142        r = b.multiply(b).re;
1143        s = a.multiply(a.conjugate()).re;
1144        //System.out.println("r = " + r + ", s = " + s);
1145        t = r.subtract(s).abs().divide(r.abs().sum(s.abs()));
1146        //System.out.println("t = " + t + ", eps = " + eps);
1147
1148        assertTrue("sqrt(x)*sqrt(x): " + b, t.compareTo(eps) <= 0);
1149    }
1150
1151
1152    /**
1153     * Test root/norm octonion.
1154     */
1155    public void test2NormOctonion() {
1156        BigOctonion a, b, c, d;
1157        BigQuaternionRing fac = new BigQuaternionRing();
1158        BigOctonion ofac = new BigOctonion(fac);
1159            
1160        a = ofac.getZERO();
1161        b = a.abs();
1162        assertTrue("abs(0) == 0: " + b, b.isZERO());
1163
1164        a = ofac.getONE();
1165        b = a.abs();
1166        assertTrue("abs(1) == 1: " + b, b.isONE());
1167
1168        a = ofac.getONE().negate();
1169        b = a.abs();
1170        assertTrue("abs(-1): " + b, b.isONE());
1171
1172        BigRational eps = new BigRational(1,10).power(BigDecimal.DEFAULT_PRECISION-1);
1173        //System.out.println("eps = " + eps); // + ", epsd = " + new BigDecimal(eps));
1174
1175        BigRational r, s, t;
1176        a = ofac.random(5);
1177        b = a.abs();
1178        //System.out.println("\na = " + a + ", b = " + b);
1179        r = b.multiply(b).or.re;
1180        s = a.multiply(a.conjugate()).or.re;
1181        //System.out.println("r = " + r + ", s = " + s);
1182        t = r.subtract(s).abs().divide(r.abs().sum(s.abs()));
1183        //System.out.println("t = " + t + ", eps = " + eps);
1184
1185        assertTrue("sqrt(x)*sqrt(x): " + b, t.compareTo(eps) <= 0);
1186    }
1187
1188}