Source code

001
002/*
003 * $Id: ProductTest.java 3789 2011-10-01 18:54:43Z kredel $
004 */
005
006package edu.jas.arith;
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 * main.
030 */
031   public static void main (String[] args) {
032       BasicConfigurator.configure();
033       junit.textui.TestRunner.run( suite() );
034   }
035
036/**
037 * Constructs a <CODE>ProductTest</CODE> object.
038 * @param name String.
039 */
040   public ProductTest(String name) {
041          super(name);
042   }
043
044/**
045 * suite.
046 */ 
047 public static Test suite() {
048     TestSuite suite= new TestSuite(ProductTest.class);
049     return suite;
050   }
051
052   ProductRing<BigRational> fac;
053   ModIntegerRing pfac;
054   ProductRing<ModInteger> mfac;
055   ProductRing<BigInteger> ifac;
056
057   Product< BigRational > a;
058   Product< BigRational > b;
059   Product< BigRational > c;
060   Product< BigRational > d;
061   Product< BigRational > e;
062   Product< BigRational > f;
063
064   Product< ModInteger > ap;
065   Product< ModInteger > bp;
066   Product< ModInteger > cp;
067   Product< ModInteger > dp;
068   Product< ModInteger > ep;
069   Product< ModInteger > fp;
070
071   Product< BigInteger > ai;
072   Product< BigInteger > bi;
073   Product< BigInteger > ci;
074   Product< BigInteger > di;
075   Product< BigInteger > ei;
076   Product< BigInteger > fi;
077
078
079   int pl = 5; 
080   int rl = 1; 
081   int kl = 13;
082   int ll = 7;
083   int el = 3;
084   float q = 0.9f;
085   int il = 2; 
086   //long p = 1152921504606846883L; // 2^60-93; 
087
088   protected void setUp() {
089       a = b = c = d = e = null;
090       ap = bp = cp = dp = ep = null;
091       ai = bi = ci = di = ei = null;
092       BigRational cfac = new BigRational(2,3);
093       fac = new ProductRing<BigRational>( cfac, pl );
094       List<RingFactory<ModInteger>> lpfac 
095           = new ArrayList<RingFactory<ModInteger>>();
096       pfac = new ModIntegerRing( 2 );
097       lpfac.add(pfac);
098       pfac = new ModIntegerRing( 3 );
099       lpfac.add(pfac);
100       pfac = new ModIntegerRing( 5 );
101       lpfac.add(pfac);
102       pfac = new ModIntegerRing( 7 );
103       lpfac.add(pfac);
104       mfac = new ProductRing<ModInteger>( lpfac );
105       BigInteger cifac = new BigInteger(3);
106       ifac = new ProductRing<BigInteger>( cifac, pl );
107   }
108
109   protected void tearDown() {
110       a = b = c = d = e = null;
111       ap = bp = cp = dp = ep = null;
112       ai = bi = ci = di = ei = null;
113       fac = null;
114       pfac = null;
115       mfac = null;
116       ifac = null;
117   }
118
119
120/**
121 * Test constructor for rational.
122 * 
123 */
124 public void testRatConstruction() {
125     c = fac.getONE();
126     //System.out.println("c = " + c);
127     assertTrue("isZERO( c )", !c.isZERO() );
128     assertTrue("isONE( c )", c.isONE() );
129
130     d = fac.getZERO();
131     //System.out.println("d = " + d);
132     assertTrue("isZERO( d )", d.isZERO() );
133     assertTrue("isONE( d )", !d.isONE() );
134 }
135
136
137/**
138 * Test constructor for modular.
139 * 
140 */
141 public void testModConstruction() {
142     cp = mfac.getONE();
143     //System.out.println("cp = " + cp);
144     assertTrue("isZERO( cp )", !cp.isZERO() );
145     assertTrue("isONE( cp )", cp.isONE() );
146
147     dp = mfac.getZERO();
148     //System.out.println("dp = " + dp);
149     assertTrue("isZERO( dp )", dp.isZERO() );
150     assertTrue("isONE( dp )", !dp.isONE() );
151 }
152
153
154/**
155 * Test random rational.
156 * 
157 */
158 public void testRatRandom() {
159     for (int i = 0; i < 7; i++) {
160         a = fac.random(kl*(i+1));
161         if ( a.isZERO() ) {
162            continue;
163         }
164         assertTrue(" not isZERO( a"+i+" )", !a.isZERO() );
165         assertTrue(" not isONE( a"+i+" )", !a.isONE() );
166         a = fac.random( kl, q );
167         if ( a.isZERO() ) {
168            continue;
169         }
170         //System.out.println("a = " + a);
171         assertTrue(" not isZERO( a"+i+" )", !a.isZERO() );
172         assertTrue(" not isONE( a"+i+" )", !a.isONE() );
173     }
174 }
175
176
177/**
178 * Test random modular.
179 * 
180 */
181 public void testModRandom() {
182     for (int i = 0; i < 7; i++) {
183         ap = mfac.random(kl,q);
184         if ( ap.isZERO() || ap.isONE() ) {
185            continue;
186         }
187         //System.out.println("ap = " + ap);
188         assertTrue(" not isZERO( ap"+i+" )", !ap.isZERO() );
189         assertTrue(" not isONE( ap"+i+" )", !ap.isONE() );
190     }
191 }
192
193
194/**
195 * Test rational addition.
196 * 
197 */
198 public void testRatAddition() {
199
200     a = fac.random(kl,q);
201     b = fac.random(kl,q);
202
203     c = a.sum(b);
204     d = c.subtract(b);
205     assertEquals("a+b-b = a",a,d);
206
207     //System.out.println("a = " + a);
208     //System.out.println("b = " + b);
209     //System.out.println("c = " + c);
210     //System.out.println("d = " + d);
211
212     c = a.sum(b);
213     d = b.sum(a);
214     assertEquals("a+b = b+a",c,d);
215
216     //System.out.println("c = " + c);
217     //System.out.println("d = " + d);
218
219     c = fac.random(kl,q);
220     d = c.sum( a.sum(b) );
221     e = c.sum( a ).sum(b);
222     assertEquals("c+(a+b) = (c+a)+b",d,e);
223
224     //System.out.println("c = " + c);
225     //System.out.println("d = " + d);
226     //System.out.println("e = " + e);
227
228     c = a.sum( fac.getZERO() );
229     d = a.subtract( fac.getZERO() );
230     assertEquals("a+0 = a-0",c,d);
231
232     //System.out.println("c = " + c);
233     //System.out.println("d = " + d);
234
235     c = fac.getZERO().sum( a );
236     d = fac.getZERO().subtract( a.negate() );
237     assertEquals("0+a = 0+(-a)",c,d);
238
239     //System.out.println("c = " + c);
240     //System.out.println("d = " + d);
241 }
242
243
244/**
245 * Test integer addition.
246 * 
247 */
248 public void testIntAddition() {
249
250     ai = ifac.random(kl,q);
251     bi = ifac.random(kl,q);
252
253     ci = ai.sum(bi);
254     di = ci.subtract(bi);
255     assertEquals("a+b-b = a",ai,di);
256
257     //System.out.println("a = " + a);
258     //System.out.println("b = " + b);
259     //System.out.println("c = " + c);
260     //System.out.println("d = " + d);
261
262     ci = ai.sum(bi);
263     di = bi.sum(ai);
264     assertEquals("a+b = b+a",ci,di);
265
266     //System.out.println("c = " + c);
267     //System.out.println("d = " + d);
268
269     ci = ifac.random(kl,q);
270     di = ci.sum( ai.sum(bi) );
271     ei = ci.sum( ai ).sum(bi);
272     assertEquals("c+(a+b) = (c+a)+b",di,ei);
273
274     //System.out.println("c = " + c);
275     //System.out.println("d = " + d);
276     //System.out.println("e = " + e);
277
278     ci = ai.sum( ifac.getZERO() );
279     di = ai.subtract( ifac.getZERO() );
280     assertEquals("a+0 = a-0",ci,di);
281
282     //System.out.println("c = " + c);
283     //System.out.println("d = " + d);
284
285     ci = ifac.getZERO().sum( ai );
286     di = ifac.getZERO().subtract( ai.negate() );
287     assertEquals("0+a = 0+(-a)",ci,di);
288
289     //System.out.println("c = " + c);
290     //System.out.println("d = " + d);
291 }
292
293
294/**
295 * Test modular addition.
296 * 
297 */
298 public void testModAddition() {
299
300     ap = mfac.random(kl,q);
301     bp = mfac.random(kl,q);
302     //System.out.println("a = " + a);
303     //System.out.println("b = " + b);
304
305     cp = ap.sum(bp);
306     dp = cp.subtract(bp);
307     assertEquals("a+b-b = a",ap,dp);
308
309     cp = ap.sum(bp);
310     dp = bp.sum(ap);
311     //System.out.println("c = " + c);
312     //System.out.println("d = " + d);
313
314     assertEquals("a+b = b+a",cp,dp);
315
316     cp = mfac.random(kl,q);
317     dp = cp.sum( ap.sum(bp) );
318     ep = cp.sum( ap ).sum(bp);
319     assertEquals("c+(a+b) = (c+a)+b",dp,ep);
320
321
322     cp = ap.sum( mfac.getZERO() );
323     dp = ap.subtract( mfac.getZERO() );
324     assertEquals("a+0 = a-0",cp,dp);
325
326     cp = mfac.getZERO().sum( ap );
327     dp = mfac.getZERO().subtract( ap.negate() );
328     assertEquals("0+a = 0+(-a)",cp,dp);
329 }
330
331
332/**
333 * Test rational multiplication.
334 * 
335 */
336 public void testRatMultiplication() {
337
338     a = fac.random(kl);
339     if ( a.isZERO() ) {
340        return;
341     }
342     assertTrue("not isZERO( a )", !a.isZERO() );
343
344     b = fac.random(kl,q);
345     if ( b.isZERO() ) {
346        return;
347     }
348     assertTrue("not isZERO( b )", !b.isZERO() );
349
350     c = b.multiply(a);
351     d = a.multiply(b);
352     //assertTrue("not isZERO( c )", !c.isZERO() );
353     //assertTrue("not isZERO( d )", !d.isZERO() );
354
355     //System.out.println("a = " + a);
356     //System.out.println("b = " + b);
357     e = d.subtract(c);
358     assertTrue("isZERO( a*b-b*a ) " + e, e.isZERO() );
359
360     assertTrue("a*b = b*a", c.equals(d) );
361     assertEquals("a*b = b*a",c,d);
362
363     c = fac.random(kl,q);
364     //System.out.println("c = " + c);
365     d = a.multiply( b.multiply(c) );
366     e = (a.multiply(b)).multiply(c);
367
368     //System.out.println("d = " + d);
369     //System.out.println("e = " + e);
370     //System.out.println("d-e = " + d.subtract(c) );
371
372     assertEquals("a(bc) = (ab)c",d,e);
373     assertTrue("a(bc) = (ab)c", d.equals(e) );
374
375     c = a.divide(b);
376     d = a.remainder(b);
377     e = c.multiply(b).sum(d);
378     f = a.multiply( e.idempotent() );
379
380     //System.out.println("c = " + c);
381     //System.out.println("d = " + d);
382     //System.out.println("e = " + e);
383     //System.out.println("f = " + f);
384     assertEquals("a = (a/b)c+d ",e,f);
385
386     c = a.multiply( fac.getONE() );
387     d = fac.getONE().multiply( a );
388     assertEquals("a*1 = 1*a",c,d);
389
390     b = a.idempotent();
391     c = a.idemComplement();
392     d = b.multiply(c);
393     assertEquals("idem(a)*idemComp(a) = 0",d,fac.getZERO());
394     d = b.sum(c);
395     assertEquals("idem(a)+idemComp(a) = 1",d,fac.getONE());
396
397     if ( a.isUnit() ) {
398        c = a.inverse();
399        d = c.multiply(a);
400        e = a.idempotent();
401        //System.out.println("a = " + a);
402        //System.out.println("c = " + c);
403        //System.out.println("d = " + d);
404        //System.out.println("e = " + e);
405        assertEquals("a*1/a = 1",e,d); 
406     }
407 }
408
409
410/**
411 * Test integer multiplication.
412 * 
413 */
414 public void testIntMultiplication() {
415
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 */
529 public void testModMultiplication() {
530
531     ap = mfac.random(kl,q);
532     if ( ap.isZERO() ) {
533        return;
534     }
535     assertTrue("not isZERO( a )", !ap.isZERO() );
536
537     bp = mfac.random(kl,q);
538     if ( bp.isZERO() ) {
539        return;
540     }
541     assertTrue("not isZERO( b )", !bp.isZERO() );
542
543     cp = bp.multiply(ap);
544     dp = ap.multiply(bp);
545     //assertTrue("not isZERO( c )", !cp.isZERO() );
546     //assertTrue("not isZERO( d )", !dp.isZERO() );
547
548     //System.out.println("a = " + a);
549     //System.out.println("b = " + b);
550     ep = dp.subtract(cp);
551     assertTrue("isZERO( a*b-b*a ) " + ep, ep.isZERO() );
552
553     assertTrue("a*b = b*a", cp.equals(dp) );
554     assertEquals("a*b = b*a",cp,dp);
555
556     cp = mfac.random(kl,q);
557     //System.out.println("c = " + c);
558     dp = ap.multiply( bp.multiply(cp) );
559     ep = (ap.multiply(bp)).multiply(cp);
560
561     //System.out.println("d = " + d);
562     //System.out.println("e = " + e);
563
564     //System.out.println("d-e = " + d.subtract(c) );
565
566     assertEquals("a(bc) = (ab)c",dp,ep);
567     assertTrue("a(bc) = (ab)c", dp.equals(ep) );
568
569     cp = ap.divide(bp);
570     dp = ap.remainder(bp);
571     ep = cp.multiply(bp).sum(dp);
572     fp = ap.multiply( ep.idempotent() );
573
574     //System.out.println("cp = " + cp);
575     //System.out.println("dp = " + dp);
576     //System.out.println("ep = " + ep);
577     //System.out.println("fp = " + fp);
578     assertEquals("a = (a/b)c+d ",ep,fp);
579
580
581     cp = ap.multiply( mfac.getONE() );
582     dp = mfac.getONE().multiply( ap );
583     assertEquals("a*1 = 1*a",cp,dp);
584
585     bp = ap.idempotent();
586     cp = ap.idemComplement();
587     dp = bp.multiply(cp);
588     assertEquals("idem(a)*idemComp(a) = 0",dp,mfac.getZERO());
589     dp = bp.sum(cp);
590     assertEquals("idem(a)+idemComp(a) = 1",dp,mfac.getONE());
591
592     if ( ap.isUnit() ) {
593        cp = ap.inverse();
594        dp = cp.multiply(ap);
595        ep = ap.idempotent();
596        //System.out.println("ap = " + ap);
597        //System.out.println("cp = " + cp);
598        //System.out.println("dp = " + dp);
599        //System.out.println("ep = " + ep);
600        assertEquals("a*1/a = 1",ep,dp); 
601     }
602 }
603
604
605}