Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.arith;
006
007
008import java.util.List;
009
010import edu.jas.structure.Power;
011
012import junit.framework.Test;
013import junit.framework.TestCase;
014import junit.framework.TestSuite;
015
016
017/**
018 * Basic arithmetic tests with JUnit.
019 * @author Heinz Kredel
020 */
021
022public class ArithTest extends TestCase {
023
024
025    /**
026     * main.
027     */
028    public static void main(String[] args) {
029        junit.textui.TestRunner.run(suite());
030    }
031
032
033    /**
034     * Constructs a <CODE>ArithTest</CODE> object.
035     * @param name String.
036     */
037    public ArithTest(String name) {
038        super(name);
039    }
040
041
042    /**
043     * suite.
044     */
045    public static Test suite() {
046        TestSuite suite = new TestSuite(ArithTest.class);
047        return suite;
048    }
049
050
051    @Override
052    protected void setUp() {
053        //a = b = c = d = e = null;
054    }
055
056
057    @Override
058    protected void tearDown() {
059        //a = b = c = d = e = null;
060    }
061
062
063    /**
064     * Test static initialization and constants for BigInteger.
065     */
066    public void testIntegerConstants() {
067        BigInteger a, b, c, d;
068        a = BigInteger.ZERO;
069        b = BigInteger.ONE;
070        c = b.subtract(b);
071
072        assertTrue("0.isZERO()", a.isZERO());
073        assertTrue("1.isONE", b.isONE());
074
075        assertEquals("1-1 = 0", c, a);
076        assertTrue("(1-1).isZERO()", c.isZERO());
077
078        d = b.multiply(b);
079        assertTrue("1*1 = 1", d.isONE());
080
081        d = b.multiply(a);
082        assertTrue("1*0 = 0", d.isZERO());
083    }
084
085
086    //--------------------------------------------------------
087
088
089    /**
090     * Test string constructor and toString for BigInteger.
091     */
092    public void testIntegerConstructor() {
093        BigInteger a, b, c, d;
094        a = new BigInteger(1);
095        b = new BigInteger(-1);
096        c = new BigInteger(0);
097
098        d = a.sum(b);
099        assertTrue("'1'.isONE()", a.isONE());
100        assertTrue("1+(-1) = 0", d.isZERO());
101        d = a.negate();
102        assertEquals("-1 = -(1)", d, b);
103
104        d = a.multiply(c);
105        assertTrue("'0'.isZERO()", d.isZERO());
106        d = b.multiply(b);
107        assertTrue("(-1)*(-1) = 1", d.isONE());
108
109        a = new BigInteger(3);
110        b = new BigInteger("3");
111        assertEquals("3 = '3'", a, b);
112
113        a = new BigInteger(-5);
114        b = new BigInteger("-5");
115        assertEquals("-5 = '-5'", a, b);
116
117        //          0         1         2         3         4 
118        //          0123456789012345678901234567890123456789012345
119        String s = "1111111111111111111111111111111111111111111111";
120        a = new BigInteger(s);
121        String t = a.toString();
122        assertEquals("stringConstr = toString", s, t);
123    }
124
125
126    //--------------------------------------------------------
127
128
129    /**
130     * Test random and compares Integer.
131     */
132    public void testIntegerRandom() {
133        BigInteger a, b, c;
134        a = BigInteger.ZERO.random(500);
135        b = new BigInteger("" + a);
136        c = b.subtract(a);
137
138        assertTrue("a-'a' = 0", c.isZERO());
139        assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a));
140        assertEquals("signum('a'-a) = 0", 0, c.signum());
141    }
142
143
144    //--------------------------------------------------------
145
146
147    /**
148     * Test addition for Integer.
149     */
150    public void testIntegerAddition() {
151        BigInteger a, b, c, d, e;
152        // neutral element
153        a = BigInteger.ZERO.random(500);
154        d = a.sum(BigInteger.ZERO);
155        assertEquals("a+0 = a", d, a);
156        d = a.subtract(BigInteger.ZERO);
157        assertEquals("a-0 = a", d, a);
158
159        // inverse operations
160        b = a.sum(a);
161        c = b.subtract(a);
162        assertEquals("(a+a)-a = a", c, a);
163        b = a.subtract(a);
164        c = b.sum(a);
165        assertEquals("(a-a)+a = a", c, a);
166
167        // comutativity
168        b = BigInteger.ZERO.random(500);
169        c = a.sum(b);
170        d = b.sum(a);
171        assertEquals("a+b = b+a", c, d);
172
173        // negation
174        c = a.subtract(b);
175        d = a.sum(b.negate());
176        assertEquals("a-b = a+(-b)", c, d);
177
178        // associativity
179        c = BigInteger.ZERO.random(500);
180        d = a.sum(b.sum(c));
181        e = a.sum(b).sum(c);
182        assertEquals("a+(b+c) = (a+b)+c", d, e);
183    }
184
185
186    //--------------------------------------------------------
187
188
189    /**
190     * Test multiplication for Integer.
191     */
192    public void testIntegerMultiplication() {
193        BigInteger a, b, c, d, e;
194        // neutral element
195        a = BigInteger.ZERO.random(500);
196        d = a.multiply(BigInteger.ONE);
197        assertEquals("a*1 = a", d, a);
198        d = a.divide(BigInteger.ONE);
199        assertEquals("a/1 = a", d, a);
200
201        // inverse operations
202        b = a.multiply(a);
203        c = b.divide(a);
204        assertEquals("(a*a)/a = a", c, a);
205        b = a.divide(a);
206        c = b.multiply(a);
207        assertEquals("(a/a)*a = a", c, a);
208
209        // comutativity
210        b = BigInteger.ZERO.random(500);
211        c = a.multiply(b);
212        d = b.multiply(a);
213        assertEquals("a*b = b*a", c, d);
214
215        // inverse
216        d = c.divide(b);
217        // e = c.multiply( b.inverse() );
218        e = a;
219        assertEquals("a/b = a*(1/b)", d, e);
220
221        // associativity
222        c = BigInteger.ZERO.random(500);
223        d = a.multiply(b.multiply(c));
224        e = a.multiply(b).multiply(c);
225        assertEquals("a*(b*c) = (a*b)*c", d, e);
226    }
227
228
229    /**
230     * Test static initialization and constants for BigRational.
231     */
232    public void testRationalConstants() {
233        BigRational a, b, c, d;
234        a = BigRational.ZERO;
235        b = BigRational.ONE;
236        //System.out.println("a = " + a);
237        //System.out.println("b = " + b);
238        c = b.subtract(b);
239
240        assertTrue("0.isZERO()", a.isZERO());
241        assertTrue("1.isONE", b.isONE());
242
243        assertEquals("1-1 = 0", c, a);
244        assertTrue("(1-1).isZERO()", c.isZERO());
245
246        d = b.multiply(b);
247        assertTrue("1*1 = 1", d.isONE());
248
249        d = b.multiply(a);
250        assertTrue("1*0 = 0", d.isZERO());
251    }
252
253
254    /**
255     * Test static initialization and constants for BigComplex.
256     */
257    public void testComplexConstants() {
258        BigComplex a, b, c, d;
259        a = BigComplex.ZERO;
260        b = BigComplex.ONE;
261        c = b.subtract(b);
262
263        assertTrue("0.isZERO()", a.isZERO());
264        assertTrue("1.isONE", b.isONE());
265
266        assertEquals("1-1 = 0", c, a);
267        assertTrue("(1-1).isZERO()", c.isZERO());
268
269        d = b.multiply(b);
270        assertTrue("1*1 = 1", d.isONE());
271
272        d = b.multiply(a);
273        assertTrue("1*0 = 0", d.isZERO());
274    }
275
276
277    /**
278     * Test static initialization and constants for BigQuaternion.
279     */
280    public void testQuaternionConstants() {
281        BigQuaternionRing fac = new BigQuaternionRing();
282        BigQuaternion a, b, c, d;
283        a = fac.ZERO;
284        b = fac.ONE;
285        c = b.subtract(b);
286
287        assertTrue("0.isZERO()", a.isZERO());
288        assertTrue("1.isONE", b.isONE());
289
290        assertEquals("1-1 = 0", c, a);
291        assertTrue("(1-1).isZERO()", c.isZERO());
292
293        d = b.multiply(b);
294        assertTrue("1*1 = 1", d.isONE());
295
296        d = b.multiply(a);
297        assertTrue("1*0 = 0", d.isZERO());
298    }
299
300
301    //--------------------------------------------------------
302
303
304    /**
305     * Test string constructor and toString for BigRational.
306     */
307    public void testRationalConstructor() {
308        BigRational a, b, c, d;
309        a = new BigRational(1);
310        b = new BigRational(-1);
311        c = new BigRational(0);
312
313        d = a.sum(b);
314        assertTrue("'1'.isONE()", a.isONE());
315        assertTrue("1+(-1) = 0", d.isZERO());
316        d = a.negate();
317        assertEquals("-1 = -(1)", d, b);
318
319        d = a.multiply(c);
320        assertTrue("'0'.isZERO()", d.isZERO());
321        d = b.multiply(b);
322        assertTrue("(-1)*(-1) = 1", d.isONE());
323
324        a = new BigRational(3);
325        b = new BigRational("3");
326        assertEquals("3 = '3'", a, b);
327
328        a = new BigRational(-5);
329        b = new BigRational("-5");
330        assertEquals("-5 = '-5'", a, b);
331
332        //          0         1         2         3         4 
333        //          0123456789012345678901234567890123456789012345
334        String s = "1111111111111111111111111111111111111111111111";
335        a = new BigRational(s);
336        String t = a.toString();
337        assertEquals("stringConstr = toString", s, t);
338
339        s = "2/4";
340        a = new BigRational(s);
341        t = a.toString(5);
342        //System.out.println("a = " + a);
343        //System.out.println("t = " + t);
344        String r = "0.5";
345        assertEquals("stringConstr = toString", r, t);
346    }
347
348
349    /**
350     * Test string constructor and toString for BigComplex.
351     */
352    public void testComplexConstructor() {
353        BigComplex a, b, c, d;
354        a = new BigComplex(1);
355        b = new BigComplex(-1);
356        c = new BigComplex(0);
357
358        d = a.sum(b);
359        assertTrue("'1'.isONE()", a.isONE());
360        assertTrue("1+(-1) = 0", d.isZERO());
361        d = a.negate();
362        assertEquals("-1 = -(1)", d, b);
363
364        d = a.multiply(c);
365        assertTrue("'0'.isZERO()", d.isZERO());
366        d = b.multiply(b);
367        assertTrue("(-1)*(-1) = 1", d.isONE());
368
369        a = new BigComplex(3);
370        b = new BigComplex("3");
371        assertEquals("3 = '3'", a, b);
372
373        a = new BigComplex(-5);
374        b = new BigComplex("-5");
375        assertEquals("-5 = '-5'", a, b);
376
377        //          0         1         2         3         4 
378        //          0123456789012345678901234567890123456789012345
379        String s = "1111111111111111111111111111111111111111111111";
380        a = new BigComplex(s);
381        String t = a.toString();
382        assertEquals("stringConstr = toString", s, t);
383    }
384
385
386    /**
387     * Test string constructor and toString for BigQuaternion.
388     */
389    public void testQuaternionConstructor() {
390        BigQuaternionRing fac = new BigQuaternionRing();
391        BigQuaternion a, b, c, d;
392        a = new BigQuaternion(fac, 1);
393        b = new BigQuaternion(fac, -1);
394        c = new BigQuaternion(fac, 0);
395
396        d = a.sum(b);
397        assertTrue("'1'.isONE()", a.isONE());
398        assertTrue("1+(-1) = 0", d.isZERO());
399        d = a.negate();
400        assertEquals("-1 = -(1)", d, b);
401
402        d = a.multiply(c);
403        assertTrue("'0'.isZERO()", d.isZERO());
404        d = b.multiply(b);
405        assertTrue("(-1)*(-1) = 1", d.isONE());
406
407        a = new BigQuaternion(fac, 3);
408        b = new BigQuaternion(fac, "3");
409        assertEquals("3 = '3'", a, b);
410
411        a = new BigQuaternion(fac, -5);
412        b = new BigQuaternion(fac, "-5");
413        assertEquals("-5 = '-5'", a, b);
414
415        //          0         1         2         3         4 
416        //          0123456789012345678901234567890123456789012345
417        String s = "1111111111111111111111111111111111111111111111";
418        a = new BigQuaternion(fac, s);
419        String t = a.toString();
420        assertEquals("stringConstr = toString", s, t);
421    }
422
423
424    //--------------------------------------------------------
425
426
427    /**
428     * Test random and compares Rational.
429     */
430    public void testRationalRandom() {
431        BigRational a, b, c;
432        a = BigRational.ZERO.random(500);
433        b = new BigRational("" + a);
434        c = b.subtract(a);
435
436        assertTrue("a-'a' = 0", c.isZERO());
437        assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a));
438        assertEquals("signum('a'-a) = 0", 0, c.signum());
439    }
440
441
442    /**
443     * Test random and compares Complex.
444     */
445    public void testComplexRandom() {
446        BigComplex a, b, c;
447        a = BigComplex.ZERO.random(500);
448        b = new BigComplex("" + a);
449        c = b.subtract(a);
450
451        assertTrue("a-'a' = 0", c.isZERO());
452        assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a));
453        assertEquals("signum('a'-a) = 0", 0, c.signum());
454    }
455
456
457    /**
458     * Test random and compares Quaternion.
459     */
460    public void testQuaternionRandom() {
461        BigQuaternionRing fac = new BigQuaternionRing();
462        BigQuaternion a, b, c;
463        a = fac.random(500);
464        b = new BigQuaternion(fac, a.toString());
465        c = b.subtract(a);
466
467        assertTrue("a-'a' = 0", c.isZERO());
468        assertEquals("signum('a'-a) = 0", 0, c.signum());
469        assertEquals("compareTo('a',a) = 0", 0, b.compareTo(a));
470    }
471
472
473    //--------------------------------------------------------
474
475
476    /**
477     * Test addition for Rational.
478     */
479    public void testRationalAddition() {
480        BigRational a, b, c, d, e;
481        // neutral element
482        a = BigRational.ZERO.random(500);
483        d = a.sum(BigRational.ZERO);
484        assertEquals("a+0 = a", d, a);
485        d = a.subtract(BigRational.ZERO);
486        assertEquals("a-0 = a", d, a);
487
488        // inverse operations
489        b = a.sum(a);
490        c = b.subtract(a);
491        assertEquals("(a+a)-a = a", c, a);
492        b = a.subtract(a);
493        c = b.sum(a);
494        assertEquals("(a-a)+a = a", c, a);
495
496        // comutativity
497        b = BigRational.ZERO.random(500);
498        c = a.sum(b);
499        d = b.sum(a);
500        assertEquals("a+b = b+a", c, d);
501
502        // negation
503        c = a.subtract(b);
504        d = a.sum(b.negate());
505        assertEquals("a-b = a+(-b)", c, d);
506
507        // associativity
508        c = BigRational.ZERO.random(500);
509        d = a.sum(b.sum(c));
510        e = a.sum(b).sum(c);
511        assertEquals("a+(b+c) = (a+b)+c", d, e);
512    }
513
514
515    /**
516     * Test addition for Complex.
517     */
518    public void testComplexAddition() {
519        BigComplex a, b, c, d, e;
520        // neutral element
521        a = BigComplex.ZERO.random(500);
522        d = a.sum(BigComplex.ZERO);
523        assertEquals("a+0 = a", d, a);
524        d = a.subtract(BigComplex.ZERO);
525        assertEquals("a-0 = a", d, a);
526
527        // inverse operations
528        b = a.sum(a);
529        c = b.subtract(a);
530        assertEquals("(a+a)-a = a", c, a);
531        b = a.subtract(a);
532        c = b.sum(a);
533        assertEquals("(a-a)+a = a", c, a);
534
535        // comutativity
536        b = BigComplex.ZERO.random(500);
537        c = a.sum(b);
538        d = b.sum(a);
539        assertEquals("a+b = b+a", c, d);
540
541        // negation
542        c = a.subtract(b);
543        d = a.sum(b.negate());
544        assertEquals("a-b = a+(-b)", c, d);
545
546        // associativity
547        c = BigComplex.ZERO.random(500);
548        d = a.sum(b.sum(c));
549        e = a.sum(b).sum(c);
550        assertEquals("a+(b+c) = (a+b)+c", d, e);
551    }
552
553
554    /**
555     * Test addition for Quaternion.
556     */
557    public void testQuaternionAddition() {
558        BigQuaternionRing fac = new BigQuaternionRing();
559        BigQuaternion a, b, c, d, e;
560        // neutral element
561        a = fac.random(500);
562        d = a.sum(fac.ZERO);
563        assertEquals("a+0 = a", d, a);
564        d = a.subtract(fac.ZERO);
565        assertEquals("a-0 = a", d, a);
566
567        // inverse operations
568        b = a.sum(a);
569        c = b.subtract(a);
570        assertEquals("(a+a)-a = a", c, a);
571        b = a.subtract(a);
572        c = b.sum(a);
573        assertEquals("(a-a)+a = a", c, a);
574
575        // comutativity
576        b = fac.random(500);
577        c = a.sum(b);
578        d = b.sum(a);
579        assertEquals("a+b = b+a", c, d);
580
581        // negation
582        c = a.subtract(b);
583        d = a.sum(b.negate());
584        assertEquals("a-b = a+(-b)", c, d);
585
586        // associativity
587        c = fac.random(500);
588        d = a.sum(b.sum(c));
589        e = a.sum(b).sum(c);
590        assertEquals("a+(b+c) = (a+b)+c", d, e);
591    }
592
593
594    //--------------------------------------------------------
595
596
597    /**
598     * Test multiplication for Rational.
599     */
600    public void testRationalMultiplication() {
601        BigRational a, b, c, d, e;
602        // neutral element
603        a = BigRational.ZERO.random(500);
604        d = a.multiply(BigRational.ONE);
605        assertEquals("a*1 = a", d, a);
606        d = a.divide(BigRational.ONE);
607        assertEquals("a/1 = a", d, a);
608
609        // inverse operations
610        b = a.multiply(a);
611        c = b.divide(a);
612        assertEquals("(a*a)/a = a", c, a);
613        b = a.divide(a);
614        c = b.multiply(a);
615        assertEquals("(a/a)*a = a", c, a);
616
617        // comutativity
618        b = BigRational.ZERO.random(500);
619        c = a.multiply(b);
620        d = b.multiply(a);
621        assertEquals("a*b = b*a", c, d);
622
623        // inverse
624        d = c.divide(b);
625        e = c.multiply(b.inverse());
626        //e = a;
627        assertEquals("a/b = a*(1/b)", d, e);
628
629        // associativity
630        c = BigRational.ZERO.random(500);
631        d = a.multiply(b.multiply(c));
632        e = a.multiply(b).multiply(c);
633        assertEquals("a*(b*c) = (a*b)*c", d, e);
634    }
635
636
637    /**
638     * Test multiplication for Complex.
639     */
640    public void testComplexMultiplication() {
641        BigComplex a, b, c, d, e;
642        // neutral element
643        a = BigComplex.ZERO.random(500);
644        d = a.multiply(BigComplex.ONE);
645        assertEquals("a*1 = a", d, a);
646        d = a.divide(BigComplex.ONE);
647        assertEquals("a/1 = a", d, a);
648
649        // inverse operations
650        b = a.multiply(a);
651        c = b.divide(a);
652        assertEquals("(a*a)/a = a", c, a);
653        b = a.divide(a);
654        c = b.multiply(a);
655        assertEquals("(a/a)*a = a", c, a);
656
657        // comutativity
658        b = BigComplex.ZERO.random(500);
659        c = a.multiply(b);
660        d = b.multiply(a);
661        assertEquals("a*b = b*a", c, d);
662
663        // inverse
664        d = c.divide(b);
665        e = c.multiply(b.inverse());
666        //e = a;
667        assertEquals("a/b = a*(1/b)", d, e);
668
669        // associativity
670        c = BigComplex.ZERO.random(500);
671        d = a.multiply(b.multiply(c));
672        e = a.multiply(b).multiply(c);
673        assertEquals("a*(b*c) = (a*b)*c", d, e);
674    }
675
676
677    /**
678     * Test multiplication for Quaternion.
679     */
680    public void testQuaternionMultiplication() {
681        BigQuaternionRing fac = new BigQuaternionRing();
682        BigQuaternion a, b, c, d, e;
683        // neutral element
684        a = fac.random(500);
685        d = a.multiply(fac.ONE);
686        assertEquals("a*1 = a", d, a);
687        d = a.divide(fac.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 = fac.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 = fac.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 = fac.I;
714        b = fac.J;
715        c = a.multiply(b);
716        d = b.multiply(a);
717        assertEquals("I*J = -J*I", c, d.negate());
718        a = fac.I;
719        b = fac.K;
720        c = a.multiply(b);
721        d = b.multiply(a);
722        assertEquals("I*K = -K*I", c, d.negate());
723        a = fac.J;
724        b = fac.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        BigRational eps = new BigRational(1, 10).power(BigDecimal.DEFAULT_PRECISION - 2);
926        BigDecimal epsd = new BigDecimal(eps);
927
928        b = a.random(17).abs();
929        //System.out.println("\nb         = " + b);
930        //System.out.println("ulp(b)     = " + b.val.ulp());
931        for (int n = 1; n < 8; n++) {
932            d = Roots.root(b, n);
933            //System.out.println(n+"-th root = " + d);
934            e = Power.positivePower(d, n);
935            //System.out.println("root^"+n+"    = " + e);
936            if (b.compareTo(e) == 0) {
937                assertTrue("root^" + n + " == b: " + e, b.compareTo(e) == 0);
938                continue;
939            }
940            BigDecimal r = b.subtract(e).abs().divide(b.abs().sum(e.abs()));
941            assertTrue("root(a,n)**n == a: " + r, r.compareTo(epsd) <= 0);
942        }
943    }
944
945
946    /**
947     * Test root decimal.
948     */
949    public void test2RootDecimal() {
950        BigDecimal a, b, c, d;
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        BigDecimal eps = new BigDecimal("0.1").power(BigDecimal.DEFAULT_PRECISION - 2);
980        d = a.subtract(c).abs().divide(a.abs().sum(BigDecimal.ONE));
981        assertTrue("sqrt(a)*sqrt(a) == a: " + d, d.compareTo(eps) <= 0);
982    }
983
984
985    /**
986     * Test root complex decimal.
987     */
988    public void testRootDecimalComplex() {
989        BigDecimalComplex a, b, c, d, e;
990        a = BigDecimalComplex.ZERO;
991        b = Roots.sqrt(a);
992        assertTrue("sqrt(0) == 0: " + b, b.isZERO());
993
994        a = BigDecimalComplex.ONE;
995        b = Roots.sqrt(a);
996        assertTrue("sqrt(1) == 1: " + b, b.isONE());
997
998        a = BigDecimalComplex.ONE.negate();
999        b = Roots.sqrt(a);
1000        d = b.multiply(b);
1001        //System.out.println("a = " + a + ", b = " + b + ", d = " + d);
1002        assertTrue("sqrt(-1) == I: " + b, b.isIMAG());
1003        assertTrue("sqrt(-1)*sqrt(-1) == -1: " + a + ", b = " + b, a.compareTo(d) == 0);
1004
1005        b = BigDecimalComplex.I;
1006        c = Roots.sqrt(b);
1007        d = c.multiply(c);
1008        //System.out.println("b = " + b + ", c = " + c + ", d = " + d);
1009        assertTrue("sqrt(b)*sqrt(b) == b: " + c + ", b = " + b, b.compareTo(d) == 0);
1010
1011        b = a.fromInteger(4);
1012        c = Roots.sqrt(b);
1013        d = BigDecimalComplex.ONE.sum(BigDecimalComplex.ONE);
1014        //System.out.println("b = " + b + ", c = " + c + ", d = " + d);
1015        assertTrue("sqrt(4) == 2: " + c, c.compareTo(d) == 0);
1016
1017        b = b.multiply(BigDecimalComplex.I);
1018        c = Roots.sqrt(b);
1019        d = c.multiply(c);
1020        //System.out.println("b = " + b + ", c = " + c + ", d = " + d);
1021        assertTrue("sqrt(b)*sqrt(b) == b: " + c + ", b = " + b, b.compareTo(d) == 0);
1022
1023        b = a.random(5);
1024        c = b.norm();
1025        d = b.multiply(b.conjugate());
1026        assertTrue("norm(b) == b*b^: b-d = " + c.subtract(d), c.compareTo(d) == 0);
1027
1028        BigRational eps = new BigRational(1, 10).power(BigDecimal.DEFAULT_PRECISION - 1);
1029        //System.out.println("eps = " + eps + ", epsd = " + new BigDecimal(eps));
1030        BigDecimal epsd = new BigDecimal(eps);
1031        BigDecimal dd;
1032
1033        //System.out.println("b = " + b + ", c = " + c);
1034        //c = b.norm();
1035        d = b.abs();
1036        e = d.multiply(d);
1037        dd = e.re.subtract(c.re).abs().divide(e.re.abs().sum(c.re.abs()));
1038        //System.out.println("dd = " + dd + ", d = " + d + ", e = " + e);
1039        assertTrue("abs()*abs() == norm(): " + dd, dd.compareTo(epsd) <= 0);
1040    }
1041
1042
1043    /**
1044     * Test root rational.
1045     */
1046    public void test2RootRational() {
1047        BigRational a, b, c, d;
1048        a = BigRational.ZERO;
1049        b = Roots.sqrt(a);
1050        assertTrue("sqrt(0) == 0: " + b, b.isZERO());
1051
1052        a = BigRational.ONE;
1053        b = Roots.sqrt(a);
1054        assertTrue("sqrt(1) == 1: " + b, b.isONE());
1055
1056        a = BigRational.ONE.negate();
1057        try {
1058            b = Roots.sqrt(a);
1059            fail("sqrt(-1) illegal: " + b);
1060        } catch (ArithmeticException e) {
1061            // pass
1062        }
1063
1064        a = new BigRational("4");
1065        b = Roots.sqrt(a);
1066        c = b.multiply(b);
1067        assertTrue("sqrt(4)*sqrt(4) == 4: " + a.subtract(c), a.compareTo(c) == 0);
1068        BigRational eps = new BigRational(1, 10).power(BigDecimal.DEFAULT_PRECISION - 1);
1069        //System.out.println("eps = " + eps + ", epsd = " + new BigDecimal(eps));
1070
1071        a = new BigRational("0.5");
1072        b = Roots.sqrt(a);
1073        c = b.multiply(b);
1074        //System.out.println("a = " + a + ", sqrt(a) = " + b + ", b^2 = " + c);
1075        d = a.subtract(c).abs().divide(a.abs().sum(c.abs()));
1076        //System.out.println("d = " + d + ", dd = " + new BigDecimal(d));
1077        assertTrue("sqrt(0.5)*sqrt(0.5) == 0.5: " + c, d.compareTo(eps) <= 0);
1078
1079        a = a.random(5).abs();
1080        b = Roots.sqrt(a);
1081        c = b.multiply(b);
1082        //System.out.println("a = " + a + ", sqrt(a) = " + b + ", b^2 = " + c);
1083        d = a.subtract(c).abs().divide(a.abs().sum(c.abs()));
1084        //System.out.println("d = " + d + ", dd = " + new BigDecimal(d));
1085        assertTrue("sqrt(0.5)*sqrt(0.5) == 0.5: " + c, d.compareTo(eps) <= 0);
1086    }
1087
1088
1089    /**
1090     * Test root/norm complex.
1091     */
1092    public void test2NormComplex() {
1093        BigComplex a, b;
1094        a = BigComplex.ZERO;
1095        b = a.abs();
1096        assertTrue("abs(0) == 0: " + b, b.isZERO());
1097
1098        a = BigComplex.ONE;
1099        b = a.abs();
1100        assertTrue("abs(1) == 1: " + b, b.isONE());
1101
1102        a = BigComplex.ONE.negate();
1103        b = a.abs();
1104        assertTrue("abs(-1): " + b, b.isONE());
1105
1106        BigRational eps = new BigRational(1, 10).power(BigDecimal.DEFAULT_PRECISION - 1);
1107        //System.out.println("eps = " + eps); // + ", epsd = " + new BigDecimal(eps));
1108
1109        BigRational r, s, t;
1110        a = a.random(5);
1111        b = a.abs();
1112        //System.out.println("a = " + a + ", b = " + b);
1113        r = b.multiply(b).re;
1114        s = a.multiply(a.conjugate()).re;
1115        //System.out.println("r = " + r + ", s = " + s);
1116        t = r.subtract(s).abs().divide(r.abs().sum(s.abs()));
1117        //System.out.println("t = " + t + ", eps = " + eps);
1118        assertTrue("abs()*abs() == norm(): " + b, t.compareTo(eps) <= 0);
1119    }
1120
1121
1122    /**
1123     * Test root/norm quaternion.
1124     */
1125    public void test2NormQuaternion() {
1126        BigQuaternion a, b;
1127        BigQuaternionRing fac = new BigQuaternionRing();
1128        a = fac.ZERO;
1129        b = a.abs();
1130        assertTrue("abs(0) == 0: " + b, b.isZERO());
1131
1132        a = fac.ONE;
1133        b = a.abs();
1134        assertTrue("abs(1) == 1: " + b, b.isONE());
1135
1136        a = fac.ONE.negate();
1137        b = a.abs();
1138        assertTrue("abs(-1): " + b, b.isONE());
1139
1140        BigRational eps = new BigRational(1, 10).power(BigDecimal.DEFAULT_PRECISION - 1);
1141        //System.out.println("eps = " + eps); // + ", epsd = " + new BigDecimal(eps));
1142
1143        BigRational r, s, t;
1144        a = fac.random(5);
1145        b = a.abs();
1146        //System.out.println("\na = " + a + ", b = " + b);
1147        r = b.multiply(b).re;
1148        s = a.multiply(a.conjugate()).re;
1149        //System.out.println("r = " + r + ", s = " + s);
1150        t = r.subtract(s).abs().divide(r.abs().sum(s.abs()));
1151        //System.out.println("t = " + t + ", eps = " + eps);
1152
1153        assertTrue("sqrt(x)*sqrt(x): " + b, t.compareTo(eps) <= 0);
1154    }
1155
1156
1157    /**
1158     * Test root/norm octonion.
1159     */
1160    public void test2NormOctonion() {
1161        BigOctonion a, b;
1162        BigQuaternionRing fac = new BigQuaternionRing();
1163        BigOctonion ofac = new BigOctonion(fac);
1164
1165        a = ofac.getZERO();
1166        b = a.abs();
1167        assertTrue("abs(0) == 0: " + b, b.isZERO());
1168
1169        a = ofac.getONE();
1170        b = a.abs();
1171        assertTrue("abs(1) == 1: " + b, b.isONE());
1172
1173        a = ofac.getONE().negate();
1174        b = a.abs();
1175        assertTrue("abs(-1): " + b, b.isONE());
1176
1177        BigRational eps = new BigRational(1, 10).power(BigDecimal.DEFAULT_PRECISION - 1);
1178        //System.out.println("eps = " + eps); // + ", epsd = " + new BigDecimal(eps));
1179
1180        BigRational r, s, t;
1181        a = ofac.random(5);
1182        b = a.abs();
1183        //System.out.println("\na = " + a + ", b = " + b);
1184        r = b.multiply(b).or.re;
1185        s = a.multiply(a.conjugate()).or.re;
1186        //System.out.println("r = " + r + ", s = " + s);
1187        t = r.subtract(s).abs().divide(r.abs().sum(s.abs()));
1188        //System.out.println("t = " + t + ", eps = " + eps);
1189
1190        assertTrue("sqrt(x)*sqrt(x): " + b, t.compareTo(eps) <= 0);
1191    }
1192
1193
1194    /**
1195     * Test continued fraction.
1196     */
1197    public void testContinuedFraction() {
1198        BigRational fac = BigRational.ONE;
1199        BigRational x = fac.random(35);
1200        //x = fac.parse("5/12");
1201        //x = fac.parse("-1");
1202
1203        List<BigInteger> cf = ArithUtil.continuedFraction(x);
1204        //System.out.println("cf(" + x + ") = " + cf);
1205
1206        BigRational a = ArithUtil.continuedFractionApprox(cf);
1207        //System.out.println("a = " + a);
1208        assertEquals("a = approx(cf(a)): ", x, a);
1209    }
1210
1211}