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