001/*
002 * $Id: ProductTest.java 4858 2014-06-29 14:08:48Z kredel $
003 */
004
005package edu.jas.arith;
006
007
008import java.util.ArrayList;
009import java.util.List;
010
011import junit.framework.Test;
012import junit.framework.TestCase;
013import junit.framework.TestSuite;
014
015import org.apache.log4j.BasicConfigurator;
016// import org.apache.log4j.Logger;
017
018import edu.jas.structure.RingFactory;
019
020
021/**
022 * Product test with JUnit.
023 * @author Heinz Kredel.
024 */
025
026public class ProductTest extends TestCase {
027
028
029    /**
030     * main.
031     */
032    public static void main(String[] args) {
033        BasicConfigurator.configure();
034        junit.textui.TestRunner.run(suite());
035    }
036
037
038    /**
039     * Constructs a <CODE>ProductTest</CODE> object.
040     * @param name String.
041     */
042    public ProductTest(String name) {
043        super(name);
044    }
045
046
047    /**
048     * suite.
049     */
050    public static Test suite() {
051        TestSuite suite = new TestSuite(ProductTest.class);
052        return suite;
053    }
054
055
056    ProductRing<BigRational> fac;
057
058
059    ModIntegerRing pfac;
060
061
062    ProductRing<ModInteger> mfac;
063
064
065    ProductRing<BigInteger> ifac;
066
067
068    Product<BigRational> a;
069
070
071    Product<BigRational> b;
072
073
074    Product<BigRational> c;
075
076
077    Product<BigRational> d;
078
079
080    Product<BigRational> e;
081
082
083    Product<BigRational> f;
084
085
086    Product<ModInteger> ap;
087
088
089    Product<ModInteger> bp;
090
091
092    Product<ModInteger> cp;
093
094
095    Product<ModInteger> dp;
096
097
098    Product<ModInteger> ep;
099
100
101    Product<ModInteger> fp;
102
103
104    Product<BigInteger> ai;
105
106
107    Product<BigInteger> bi;
108
109
110    Product<BigInteger> ci;
111
112
113    Product<BigInteger> di;
114
115
116    Product<BigInteger> ei;
117
118
119    Product<BigInteger> fi;
120
121
122    int pl = 5;
123
124
125    int rl = 1;
126
127
128    int kl = 13;
129
130
131    int ll = 7;
132
133
134    int el = 3;
135
136
137    float q = 0.9f;
138
139
140    int il = 2;
141
142
143    //long p = 1152921504606846883L; // 2^60-93; 
144
145    @Override
146    protected void setUp() {
147        a = b = c = d = e = null;
148        ap = bp = cp = dp = ep = null;
149        ai = bi = ci = di = ei = null;
150        BigRational cfac = new BigRational(2, 3);
151        fac = new ProductRing<BigRational>(cfac, pl);
152        List<RingFactory<ModInteger>> lpfac = new ArrayList<RingFactory<ModInteger>>();
153        pfac = new ModIntegerRing(2);
154        lpfac.add(pfac);
155        pfac = new ModIntegerRing(3);
156        lpfac.add(pfac);
157        pfac = new ModIntegerRing(5);
158        lpfac.add(pfac);
159        pfac = new ModIntegerRing(7);
160        lpfac.add(pfac);
161        mfac = new ProductRing<ModInteger>(lpfac);
162        BigInteger cifac = new BigInteger(3);
163        ifac = new ProductRing<BigInteger>(cifac, pl);
164    }
165
166
167    @Override
168    protected void tearDown() {
169        a = b = c = d = e = null;
170        ap = bp = cp = dp = ep = null;
171        ai = bi = ci = di = ei = null;
172        fac = null;
173        pfac = null;
174        mfac = null;
175        ifac = null;
176    }
177
178
179    /**
180     * Test constructor for rational.
181     * 
182     */
183    public void testRatConstruction() {
184        c = fac.getONE();
185        //System.out.println("c = " + c);
186        assertTrue("isZERO( c )", !c.isZERO());
187        assertTrue("isONE( c )", c.isONE());
188
189        d = fac.getZERO();
190        //System.out.println("d = " + d);
191        assertTrue("isZERO( d )", d.isZERO());
192        assertTrue("isONE( d )", !d.isONE());
193    }
194
195
196    /**
197     * Test constructor for modular.
198     * 
199     */
200    public void testModConstruction() {
201        cp = mfac.getONE();
202        //System.out.println("cp = " + cp);
203        assertTrue("isZERO( cp )", !cp.isZERO());
204        assertTrue("isONE( cp )", cp.isONE());
205
206        dp = mfac.getZERO();
207        //System.out.println("dp = " + dp);
208        assertTrue("isZERO( dp )", dp.isZERO());
209        assertTrue("isONE( dp )", !dp.isONE());
210    }
211
212
213    /**
214     * Test random rational.
215     * 
216     */
217    public void testRatRandom() {
218        for (int i = 0; i < 7; i++) {
219            a = fac.random(kl * (i + 1));
220            if (a.isZERO()) {
221                continue;
222            }
223            assertTrue(" not isZERO( a" + i + " )", !a.isZERO());
224            assertTrue(" not isONE( a" + i + " )", !a.isONE());
225            a = fac.random(kl, q);
226            if (a.isZERO()) {
227                continue;
228            }
229            //System.out.println("a = " + a);
230            assertTrue(" not isZERO( a" + i + " )", !a.isZERO());
231            assertTrue(" not isONE( a" + i + " )", !a.isONE());
232        }
233    }
234
235
236    /**
237     * Test random modular.
238     * 
239     */
240    public void testModRandom() {
241        for (int i = 0; i < 7; i++) {
242            ap = mfac.random(kl, q);
243            if (ap.isZERO() || ap.isONE()) {
244                continue;
245            }
246            //System.out.println("ap = " + ap);
247            assertTrue(" not isZERO( ap" + i + " )", !ap.isZERO());
248            assertTrue(" not isONE( ap" + i + " )", !ap.isONE());
249        }
250    }
251
252
253    /**
254     * Test rational addition.
255     * 
256     */
257    public void testRatAddition() {
258
259        a = fac.random(kl, q);
260        b = fac.random(kl, q);
261
262        c = a.sum(b);
263        d = c.subtract(b);
264        assertEquals("a+b-b = a", a, d);
265
266        //System.out.println("a = " + a);
267        //System.out.println("b = " + b);
268        //System.out.println("c = " + c);
269        //System.out.println("d = " + d);
270
271        c = a.sum(b);
272        d = b.sum(a);
273        assertEquals("a+b = b+a", c, d);
274
275        //System.out.println("c = " + c);
276        //System.out.println("d = " + d);
277
278        c = fac.random(kl, q);
279        d = c.sum(a.sum(b));
280        e = c.sum(a).sum(b);
281        assertEquals("c+(a+b) = (c+a)+b", d, e);
282
283        //System.out.println("c = " + c);
284        //System.out.println("d = " + d);
285        //System.out.println("e = " + e);
286
287        c = a.sum(fac.getZERO());
288        d = a.subtract(fac.getZERO());
289        assertEquals("a+0 = a-0", c, d);
290
291        //System.out.println("c = " + c);
292        //System.out.println("d = " + d);
293
294        c = fac.getZERO().sum(a);
295        d = fac.getZERO().subtract(a.negate());
296        assertEquals("0+a = 0+(-a)", c, d);
297
298        //System.out.println("c = " + c);
299        //System.out.println("d = " + d);
300    }
301
302
303    /**
304     * Test integer addition.
305     * 
306     */
307    public void testIntAddition() {
308
309        ai = ifac.random(kl, q);
310        bi = ifac.random(kl, q);
311
312        ci = ai.sum(bi);
313        di = ci.subtract(bi);
314        assertEquals("a+b-b = a", ai, di);
315
316        //System.out.println("a = " + a);
317        //System.out.println("b = " + b);
318        //System.out.println("c = " + c);
319        //System.out.println("d = " + d);
320
321        ci = ai.sum(bi);
322        di = bi.sum(ai);
323        assertEquals("a+b = b+a", ci, di);
324
325        //System.out.println("c = " + c);
326        //System.out.println("d = " + d);
327
328        ci = ifac.random(kl, q);
329        di = ci.sum(ai.sum(bi));
330        ei = ci.sum(ai).sum(bi);
331        assertEquals("c+(a+b) = (c+a)+b", di, ei);
332
333        //System.out.println("c = " + c);
334        //System.out.println("d = " + d);
335        //System.out.println("e = " + e);
336
337        ci = ai.sum(ifac.getZERO());
338        di = ai.subtract(ifac.getZERO());
339        assertEquals("a+0 = a-0", ci, di);
340
341        //System.out.println("c = " + c);
342        //System.out.println("d = " + d);
343
344        ci = ifac.getZERO().sum(ai);
345        di = ifac.getZERO().subtract(ai.negate());
346        assertEquals("0+a = 0+(-a)", ci, di);
347
348        //System.out.println("c = " + c);
349        //System.out.println("d = " + d);
350    }
351
352
353    /**
354     * Test modular addition.
355     * 
356     */
357    public void testModAddition() {
358
359        ap = mfac.random(kl, q);
360        bp = mfac.random(kl, q);
361        //System.out.println("a = " + a);
362        //System.out.println("b = " + b);
363
364        cp = ap.sum(bp);
365        dp = cp.subtract(bp);
366        assertEquals("a+b-b = a", ap, dp);
367
368        cp = ap.sum(bp);
369        dp = bp.sum(ap);
370        //System.out.println("c = " + c);
371        //System.out.println("d = " + d);
372
373        assertEquals("a+b = b+a", cp, dp);
374
375        cp = mfac.random(kl, q);
376        dp = cp.sum(ap.sum(bp));
377        ep = cp.sum(ap).sum(bp);
378        assertEquals("c+(a+b) = (c+a)+b", dp, ep);
379
380
381        cp = ap.sum(mfac.getZERO());
382        dp = ap.subtract(mfac.getZERO());
383        assertEquals("a+0 = a-0", cp, dp);
384
385        cp = mfac.getZERO().sum(ap);
386        dp = mfac.getZERO().subtract(ap.negate());
387        assertEquals("0+a = 0+(-a)", cp, dp);
388    }
389
390
391    /**
392     * Test rational multiplication.
393     * 
394     */
395    public void testRatMultiplication() {
396
397        a = fac.random(kl);
398        if (a.isZERO()) {
399            return;
400        }
401        assertTrue("not isZERO( a )", !a.isZERO());
402
403        b = fac.random(kl, q);
404        if (b.isZERO()) {
405            return;
406        }
407        assertTrue("not isZERO( b )", !b.isZERO());
408
409        c = b.multiply(a);
410        d = a.multiply(b);
411        //assertTrue("not isZERO( c )", !c.isZERO() );
412        //assertTrue("not isZERO( d )", !d.isZERO() );
413
414        //System.out.println("a = " + a);
415        //System.out.println("b = " + b);
416        e = d.subtract(c);
417        assertTrue("isZERO( a*b-b*a ) " + e, e.isZERO());
418
419        assertTrue("a*b = b*a", c.equals(d));
420        assertEquals("a*b = b*a", c, d);
421
422        c = fac.random(kl, q);
423        //System.out.println("c = " + c);
424        d = a.multiply(b.multiply(c));
425        e = (a.multiply(b)).multiply(c);
426
427        //System.out.println("d = " + d);
428        //System.out.println("e = " + e);
429        //System.out.println("d-e = " + d.subtract(c) );
430
431        assertEquals("a(bc) = (ab)c", d, e);
432        assertTrue("a(bc) = (ab)c", d.equals(e));
433
434        c = a.divide(b);
435        d = a.remainder(b);
436        e = c.multiply(b).sum(d);
437        f = a.multiply(e.idempotent());
438
439        //System.out.println("c = " + c);
440        //System.out.println("d = " + d);
441        //System.out.println("e = " + e);
442        //System.out.println("f = " + f);
443        assertEquals("a = (a/b)c+d ", e, f);
444
445        c = a.multiply(fac.getONE());
446        d = fac.getONE().multiply(a);
447        assertEquals("a*1 = 1*a", c, d);
448
449        b = a.idempotent();
450        c = a.idemComplement();
451        d = b.multiply(c);
452        assertEquals("idem(a)*idemComp(a) = 0", d, fac.getZERO());
453        d = b.sum(c);
454        assertEquals("idem(a)+idemComp(a) = 1", d, fac.getONE());
455
456        if (a.isUnit()) {
457            c = a.inverse();
458            d = c.multiply(a);
459            e = a.idempotent();
460            //System.out.println("a = " + a);
461            //System.out.println("c = " + c);
462            //System.out.println("d = " + d);
463            //System.out.println("e = " + e);
464            assertEquals("a*1/a = 1", e, d);
465        }
466    }
467
468
469    /**
470     * Test integer multiplication.
471     * 
472     */
473    public void testIntMultiplication() {
474
475        ai = ifac.random(kl);
476        while (ai.isZERO()) {
477            ai = ifac.random(kl);
478        }
479        assertTrue("not isZERO( a )", !ai.isZERO());
480
481        bi = ifac.random(kl, q);
482        if (bi.isZERO()) {
483            bi = ifac.random(kl, q);
484        }
485        assertTrue("not isZERO( b )", !bi.isZERO());
486
487        ci = bi.multiply(ai);
488        di = ai.multiply(bi);
489        //assertTrue("not isZERO( c )", !c.isZERO() );
490        //assertTrue("not isZERO( d )", !d.isZERO() );
491
492        //System.out.println("a = " + ai);
493        //System.out.println("b = " + bi);
494        ei = di.subtract(ci);
495        assertTrue("isZERO( a*b-b*a ) " + ei, ei.isZERO());
496
497        assertTrue("a*b = b*a", ci.equals(di));
498        assertEquals("a*b = b*a", ci, di);
499
500        ci = ifac.random(kl, q);
501        //System.out.println("c = " + ci);
502        di = ai.multiply(bi.multiply(ci));
503        ei = (ai.multiply(bi)).multiply(ci);
504
505        //System.out.println("d = " + di);
506        //System.out.println("e = " + ei);
507        //System.out.println("d-e = " + di.subtract(ci) );
508
509        assertEquals("a(bc) = (ab)c", di, ei);
510        assertTrue("a(bc) = (ab)c", di.equals(ei));
511
512        ci = ai.divide(bi);
513        di = ai.remainder(bi);
514        ei = ci.multiply(bi).sum(di);
515        fi = ai.multiply(ei.idempotent());
516
517        //System.out.println("c = " + ci);
518        //System.out.println("d = " + di);
519        //System.out.println("e = " + ei);
520        //System.out.println("f = " + fi);
521        assertEquals("a = (a/b)c+d ", ei, fi);
522
523
524        ci = ai.gcd(bi);
525        di = ai.remainder(ci);
526        ei = bi.remainder(ci);
527
528        //System.out.println("c = " + ci);
529        //System.out.println("d = " + di);
530        //System.out.println("e = " + ei);
531        assertTrue("gcd(a,b) | a ", di.isZERO());
532        assertTrue("gcd(a,b) | b ", ei.isZERO());
533
534
535        Product<BigInteger>[] gcd;
536        gcd = ai.egcd(bi);
537        ci = gcd[0];
538        di = ai.remainder(ci);
539        ei = bi.remainder(ci);
540
541        //System.out.println();
542        //System.out.println("c = " + ci);
543        //System.out.println("d = " + di);
544        //System.out.println("e = " + ei);
545        assertTrue("gcd(a,b) | a ", di.isZERO());
546        assertTrue("gcd(a,b) | b ", ei.isZERO());
547
548        di = ai.multiply(gcd[1]);
549        ei = bi.multiply(gcd[2]);
550        fi = di.sum(ei);
551
552        //System.out.println("c = " + ci);
553        //System.out.println("c1= " + gcd[1]);
554        //System.out.println("c2= " + gcd[2]);
555        //System.out.println("d = " + di);
556        //System.out.println("e = " + ei);
557        //System.out.println("f = " + fi);
558        assertEquals("gcd(a,b) = c1*a + c2*b ", ci, fi);
559
560        ci = ai.multiply(ifac.getONE());
561        di = ifac.getONE().multiply(ai);
562        assertEquals("a*1 = 1*a", ci, di);
563
564        bi = ai.idempotent();
565        ci = ai.idemComplement();
566        di = bi.multiply(ci);
567        assertEquals("idem(a)*idemComp(a) = 0", di, ifac.getZERO());
568        di = bi.sum(ci);
569        assertEquals("idem(a)+idemComp(a) = 1", di, ifac.getONE());
570
571        if (ai.isUnit()) {
572            ci = ai.inverse();
573            di = ci.multiply(ai);
574            ei = ai.idempotent();
575            //System.out.println("a = " + a);
576            //System.out.println("c = " + c);
577            //System.out.println("d = " + d);
578            //System.out.println("e = " + e);
579            assertEquals("a*1/a = 1", ei, di);
580        }
581    }
582
583
584    /**
585     * Test modular multiplication.
586     * 
587     */
588    public void testModMultiplication() {
589
590        ap = mfac.random(kl, q);
591        if (ap.isZERO()) {
592            return;
593        }
594        assertTrue("not isZERO( a )", !ap.isZERO());
595
596        bp = mfac.random(kl, q);
597        if (bp.isZERO()) {
598            return;
599        }
600        assertTrue("not isZERO( b )", !bp.isZERO());
601
602        cp = bp.multiply(ap);
603        dp = ap.multiply(bp);
604        //assertTrue("not isZERO( c )", !cp.isZERO() );
605        //assertTrue("not isZERO( d )", !dp.isZERO() );
606
607        //System.out.println("a = " + a);
608        //System.out.println("b = " + b);
609        ep = dp.subtract(cp);
610        assertTrue("isZERO( a*b-b*a ) " + ep, ep.isZERO());
611
612        assertTrue("a*b = b*a", cp.equals(dp));
613        assertEquals("a*b = b*a", cp, dp);
614
615        cp = mfac.random(kl, q);
616        //System.out.println("c = " + c);
617        dp = ap.multiply(bp.multiply(cp));
618        ep = (ap.multiply(bp)).multiply(cp);
619
620        //System.out.println("d = " + d);
621        //System.out.println("e = " + e);
622
623        //System.out.println("d-e = " + d.subtract(c) );
624
625        assertEquals("a(bc) = (ab)c", dp, ep);
626        assertTrue("a(bc) = (ab)c", dp.equals(ep));
627
628        cp = ap.divide(bp);
629        dp = ap.remainder(bp);
630        ep = cp.multiply(bp).sum(dp);
631        fp = ap.multiply(ep.idempotent());
632
633        //System.out.println("cp = " + cp);
634        //System.out.println("dp = " + dp);
635        //System.out.println("ep = " + ep);
636        //System.out.println("fp = " + fp);
637        assertEquals("a = (a/b)c+d ", ep, fp);
638
639
640        cp = ap.multiply(mfac.getONE());
641        dp = mfac.getONE().multiply(ap);
642        assertEquals("a*1 = 1*a", cp, dp);
643
644        bp = ap.idempotent();
645        cp = ap.idemComplement();
646        dp = bp.multiply(cp);
647        assertEquals("idem(a)*idemComp(a) = 0", dp, mfac.getZERO());
648        dp = bp.sum(cp);
649        assertEquals("idem(a)+idemComp(a) = 1", dp, mfac.getONE());
650
651        if (ap.isUnit()) {
652            cp = ap.inverse();
653            dp = cp.multiply(ap);
654            ep = ap.idempotent();
655            //System.out.println("ap = " + ap);
656            //System.out.println("cp = " + cp);
657            //System.out.println("dp = " + dp);
658            //System.out.println("ep = " + ep);
659            assertEquals("a*1/a = 1", ep, dp);
660        }
661    }
662
663
664}