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