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