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