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