001/*
002 * $Id: Examples.java 4960 2014-10-17 18:46:22Z kredel $
003 */
004
005package edu.jas.application;
006
007
008import java.io.IOException;
009import java.io.Reader;
010import java.io.StringReader;
011import java.util.ArrayList;
012import java.util.List;
013
014import org.apache.log4j.BasicConfigurator;
015
016import edu.jas.arith.BigDecimal;
017import edu.jas.arith.BigInteger;
018import edu.jas.arith.BigRational;
019import edu.jas.arith.ModInteger;
020import edu.jas.arith.ModIntegerRing;
021import edu.jas.arith.Product;
022import edu.jas.arith.ProductRing;
023import edu.jas.gb.GroebnerBase;
024import edu.jas.gb.GroebnerBaseAbstract;
025import edu.jas.gbufd.GBFactory;
026import edu.jas.gbufd.RGroebnerBasePseudoSeq;
027import edu.jas.gbufd.RReductionSeq;
028import edu.jas.kern.ComputerThreads;
029import edu.jas.kern.Scripting;
030import edu.jas.poly.AlgebraicNumber;
031import edu.jas.poly.AlgebraicNumberRing;
032import edu.jas.poly.GenPolynomial;
033import edu.jas.poly.GenPolynomialRing;
034import edu.jas.poly.GenPolynomialTokenizer;
035import edu.jas.poly.PolynomialList;
036import edu.jas.poly.TermOrder;
037import edu.jas.ufd.Quotient;
038import edu.jas.ufd.QuotientRing;
039
040
041/**
042 * Examples for application usage.
043 * @author Christoph Zengler.
044 * @author Heinz Kredel.
045 */
046
047public class Examples {
048
049
050    /**
051     * main.
052     */
053    public static void main(String[] args) {
054        BasicConfigurator.configure();
055        if (args.length > 0) {
056            example1();
057            example2();
058            example3();
059            example4();
060        }
061        example5();
062        example6();
063        example10();
064        example11();
065        example12();
066        ComputerThreads.terminate();
067    }
068
069
070    /**
071     * example1. cyclic n-th roots polynomial systems.
072     */
073    public static void example1() {
074        int n = 4;
075
076        BigInteger fac = new BigInteger();
077        GenPolynomialRing<BigInteger> ring = new GenPolynomialRing<BigInteger>(fac, n); //,var);
078        System.out.println("ring = " + ring + "\n");
079
080        List<GenPolynomial<BigInteger>> cp = new ArrayList<GenPolynomial<BigInteger>>(n);
081        for (int i = 1; i <= n; i++) {
082            GenPolynomial<BigInteger> p = cyclicPoly(ring, n, i);
083            cp.add(p);
084            System.out.println("p[" + i + "] = " + p);
085            System.out.println();
086        }
087        System.out.println("cp = " + cp + "\n");
088
089        List<GenPolynomial<BigInteger>> gb;
090        //GroebnerBase<BigInteger> sgb = new GroebnerBaseSeq<BigInteger>();
091        GroebnerBase<BigInteger> sgb = GBFactory.getImplementation(fac);
092        gb = sgb.GB(cp);
093        System.out.println("gb = " + gb);
094
095    }
096
097
098    static GenPolynomial<BigInteger> cyclicPoly(GenPolynomialRing<BigInteger> ring, int n, int i) {
099
100        List<? extends GenPolynomial<BigInteger>> X = /*(List<GenPolynomial<BigInteger>>)*/ring
101                        .univariateList();
102
103        GenPolynomial<BigInteger> p = ring.getZERO();
104        for (int j = 1; j <= n; j++) {
105            GenPolynomial<BigInteger> pi = ring.getONE();
106            for (int k = j; k < j + i; k++) {
107                pi = pi.multiply(X.get(k % n));
108            }
109            p = p.sum(pi);
110            if (i == n) {
111                p = p.subtract(ring.getONE());
112                break;
113            }
114        }
115        return p;
116    }
117
118
119    /**
120     * example2. abtract types:
121     * List<GenPolynomial<Product<Residue<BigRational>>>>.
122     */
123    public static void example2() {
124        List<GenPolynomial<Product<Residue<BigRational>>>> L = null;
125        L = new ArrayList<GenPolynomial<Product<Residue<BigRational>>>>();
126
127        BigRational bfac = new BigRational(1);
128        GenPolynomialRing<BigRational> pfac = null;
129        pfac = new GenPolynomialRing<BigRational>(bfac, 3);
130
131        List<GenPolynomial<BigRational>> F = null;
132        F = new ArrayList<GenPolynomial<BigRational>>();
133
134        GenPolynomial<BigRational> p = null;
135        for (int i = 0; i < 2; i++) {
136            p = pfac.random(5, 4, 3, 0.4f);
137            if (!p.isConstant()) {
138                F.add(p);
139            }
140        }
141        //System.out.println("F = " + F);
142
143        Ideal<BigRational> id = new Ideal<BigRational>(pfac, F);
144        id.doGB();
145        if (id.isONE() || id.isZERO()) {
146            System.out.println("id zero or one = " + id);
147            return;
148        }
149        ResidueRing<BigRational> rr = new ResidueRing<BigRational>(id);
150        System.out.println("rr = " + rr);
151
152        ProductRing<Residue<BigRational>> pr = null;
153        pr = new ProductRing<Residue<BigRational>>(rr, 3);
154
155        String[] vars = new String[] { "a", "b" };
156        GenPolynomialRing<Product<Residue<BigRational>>> fac;
157        fac = new GenPolynomialRing<Product<Residue<BigRational>>>(pr, 2, vars);
158
159        GenPolynomial<Product<Residue<BigRational>>> pp;
160        for (int i = 0; i < 1; i++) {
161            pp = fac.random(2, 4, 4, 0.4f);
162            if (!pp.isConstant()) {
163                L.add(pp);
164            }
165        }
166        System.out.println("L = " + L);
167
168        //PolynomialList<Product<Residue<BigRational>>> Lp = null;
169        //Lp = new PolynomialList<Product<Residue<BigRational>>>(fac,L);
170        //System.out.println("Lp = " + Lp);
171
172        GroebnerBase<Product<Residue<BigRational>>> bb = new RGroebnerBasePseudoSeq<Product<Residue<BigRational>>>(
173                        pr);
174
175        System.out.println("isGB(L) = " + bb.isGB(L));
176
177        List<GenPolynomial<Product<Residue<BigRational>>>> G = null;
178
179        G = bb.GB(L);
180        System.out.println("G = " + G);
181        System.out.println("isGB(G) = " + bb.isGB(G));
182    }
183
184
185    /**
186     * example3. abtract types: GB of List<GenPolynomial<Residue<BigRational>>>.
187     */
188    public static void example3() {
189        List<GenPolynomial<Residue<BigRational>>> L = null;
190        L = new ArrayList<GenPolynomial<Residue<BigRational>>>();
191
192        BigRational bfac = new BigRational(1);
193        GenPolynomialRing<BigRational> pfac = null;
194        pfac = new GenPolynomialRing<BigRational>(bfac, 2);
195
196        List<GenPolynomial<BigRational>> F = null;
197        F = new ArrayList<GenPolynomial<BigRational>>();
198
199        GenPolynomial<BigRational> p = null;
200        for (int i = 0; i < 2; i++) {
201            p = pfac.random(5, 5, 5, 0.4f);
202            //p = pfac.parse("x0^2 -2" );
203            if (!p.isConstant()) {
204                F.add(p);
205            }
206        }
207        //System.out.println("F = " + F);
208
209        Ideal<BigRational> id = new Ideal<BigRational>(pfac, F);
210        id.doGB();
211        if (id.isONE() || id.isZERO()) {
212            System.out.println("id zero or one = " + id);
213            return;
214        }
215        ResidueRing<BigRational> rr = new ResidueRing<BigRational>(id);
216        System.out.println("rr = " + rr);
217
218        String[] vars = new String[] { "a", "b" };
219        GenPolynomialRing<Residue<BigRational>> fac;
220        fac = new GenPolynomialRing<Residue<BigRational>>(rr, 2, vars);
221
222        GenPolynomial<Residue<BigRational>> pp;
223        for (int i = 0; i < 2; i++) {
224            pp = fac.random(2, 4, 6, 0.2f);
225            if (!pp.isConstant()) {
226                L.add(pp);
227            }
228        }
229        System.out.println("L = " + L);
230
231        GroebnerBase<Residue<BigRational>> bb;
232        //bb = new GroebnerBasePseudoSeq<Residue<BigRational>>(rr);
233        bb = GBFactory.getImplementation(rr);
234
235        System.out.println("isGB(L) = " + bb.isGB(L));
236
237        List<GenPolynomial<Residue<BigRational>>> G = null;
238
239        G = bb.GB(L);
240        System.out.println("G = " + G);
241        System.out.println("isGB(G) = " + bb.isGB(G));
242    }
243
244
245    /**
246     * example4. abtract types: comprehensive GB of
247     * List<GenPolynomial<GenPolynomial<BigRational>>>.
248     */
249    public static void example4() {
250        int kl = 2;
251        int ll = 3;
252        int el = 3;
253        float q = 0.2f; //0.4f
254        GenPolynomialRing<BigRational> cfac;
255        GenPolynomialRing<GenPolynomial<BigRational>> fac;
256
257        List<GenPolynomial<GenPolynomial<BigRational>>> L;
258
259        ComprehensiveGroebnerBaseSeq<BigRational> bb;
260
261        GenPolynomial<GenPolynomial<BigRational>> a;
262        GenPolynomial<GenPolynomial<BigRational>> b;
263        GenPolynomial<GenPolynomial<BigRational>> c;
264
265        BigRational coeff = new BigRational(kl);
266        String[] cv = { "a", "b" };
267        cfac = new GenPolynomialRing<BigRational>(coeff, 2, cv);
268        String[] v = { "x", "y" };
269        fac = new GenPolynomialRing<GenPolynomial<BigRational>>(cfac, 2, v);
270        bb = new ComprehensiveGroebnerBaseSeq<BigRational>(coeff);
271
272        L = new ArrayList<GenPolynomial<GenPolynomial<BigRational>>>();
273
274        a = fac.random(kl, ll, el, q);
275        b = fac.random(kl, ll, el, q);
276        c = a; //c = fac.random(kl, ll, el, q );
277
278        if (a.isZERO() || b.isZERO() || c.isZERO()) {
279            return;
280        }
281
282        L.add(a);
283        System.out.println("CGB exam L = " + L);
284        L = bb.GB(L);
285        System.out.println("CGB( L )   = " + L);
286        System.out.println("isCGB( L ) = " + bb.isGB(L));
287
288        L.add(b);
289        System.out.println("CGB exam L = " + L);
290        L = bb.GB(L);
291        System.out.println("CGB( L )   = " + L);
292        System.out.println("isCGB( L ) = " + bb.isGB(L));
293
294        L.add(c);
295        System.out.println("CGB exam L = " + L);
296        L = bb.GB(L);
297        System.out.println("CGB( L )   = " + L);
298        System.out.println("isCGB( L ) = " + bb.isGB(L));
299    }
300
301
302    /**
303     * example5. comprehensive GB of
304     * List<GenPolynomial<GenPolynomial<BigRational>>> and GB for regular ring.
305     */
306    public static void example5() {
307        int kl = 2;
308        int ll = 4;
309        int el = 3;
310        float q = 0.3f; //0.4f
311        GenPolynomialRing<BigRational> cfac;
312        GenPolynomialRing<GenPolynomial<BigRational>> fac;
313
314        List<GenPolynomial<GenPolynomial<BigRational>>> L;
315
316        ComprehensiveGroebnerBaseSeq<BigRational> bb;
317
318        GenPolynomial<GenPolynomial<BigRational>> a;
319        GenPolynomial<GenPolynomial<BigRational>> b;
320        GenPolynomial<GenPolynomial<BigRational>> c;
321
322        BigRational coeff = new BigRational(kl);
323        String[] cv = { "a", "b" };
324        cfac = new GenPolynomialRing<BigRational>(coeff, 2, cv);
325        String[] v = { "x", "y" };
326        fac = new GenPolynomialRing<GenPolynomial<BigRational>>(cfac, 2, v);
327        bb = new ComprehensiveGroebnerBaseSeq<BigRational>(coeff);
328
329        L = new ArrayList<GenPolynomial<GenPolynomial<BigRational>>>();
330
331        a = fac.random(kl, ll, el, q);
332        b = fac.random(kl, ll, el, q);
333        c = a; //c = fac.random(kl, ll, el, q );
334
335        if (a.isZERO() || b.isZERO() || c.isZERO()) {
336            return;
337        }
338
339        L.add(a);
340        L.add(b);
341        L.add(c);
342        System.out.println("CGB exam L = " + L);
343        GroebnerSystem<BigRational> sys = bb.GBsys(L);
344        boolean ig = bb.isGB(sys.getCGB());
345        System.out.println("CGB( L )   = " + sys.getCGB());
346        System.out.println("isCGB( L ) = " + ig);
347
348        List<GenPolynomial<Product<Residue<BigRational>>>> Lr, bLr;
349        RReductionSeq<Product<Residue<BigRational>>> res = new RReductionSeq<Product<Residue<BigRational>>>();
350
351        Lr = PolyUtilApp.<BigRational> toProductRes(sys.list);
352        bLr = res.booleanClosure(Lr);
353
354        System.out.println("booleanClosed(Lr)   = " + bLr);
355
356        if (bLr.size() > 0) {
357            GroebnerBase<Product<Residue<BigRational>>> rbb = new RGroebnerBasePseudoSeq<Product<Residue<BigRational>>>(
358                            bLr.get(0).ring.coFac);
359            System.out.println("isRegularGB(Lr) = " + rbb.isGB(bLr));
360        }
361    }
362
363
364    /**
365     * Example GBase and real root.
366     */
367    @SuppressWarnings("cast")
368    public static void example6() {
369        BigRational coeff = new BigRational();
370        GroebnerBase<BigRational> gb = GBFactory.getImplementation(coeff);
371
372        String exam = "(x,y,z) L " + "( " + "( x^2 - 2 ), ( y^2 - 3 ), ( z^2 + x * y )" + ") ";
373        Reader source = new StringReader(exam);
374        GenPolynomialTokenizer parser = new GenPolynomialTokenizer(source);
375        PolynomialList<BigRational> F = null;
376
377        try {
378            F = (PolynomialList<BigRational>) parser.nextPolynomialSet();
379        } catch (ClassCastException e) {
380            e.printStackTrace();
381            return;
382        } catch (IOException e) {
383            e.printStackTrace();
384            return;
385        }
386        System.out.println("F = " + F);
387
388        List<GenPolynomial<BigRational>> G = gb.GB(F.list);
389
390        PolynomialList<BigRational> Gp = new PolynomialList<BigRational>(F.ring, G);
391        System.out.println("G = " + Gp);
392
393        // compute real roots of the ideal
394        Ideal<BigRational> I = new Ideal<BigRational>(Gp);
395        List<IdealWithRealAlgebraicRoots<BigRational>> Ir = PolyUtilApp.<BigRational> realAlgebraicRoots(I);
396        for (IdealWithRealAlgebraicRoots<BigRational> R : Ir) {
397            R.doDecimalApproximation();
398            for (List<BigDecimal> Dr : R.decimalApproximation()) {
399                System.out.println(Dr.toString());
400            }
401            System.out.println();
402        }
403    }
404
405
406    /**
407     * example7. Coefficients in Boolean residue class ring.
408     */
409    public static void example7() {
410        String[] vars = { "v3", "v2", "v1" };
411
412        ModIntegerRing z2 = new ModIntegerRing(2);
413        GenPolynomialRing<ModInteger> z2p = new GenPolynomialRing<ModInteger>(z2, vars.length, new TermOrder(
414                        TermOrder.INVLEX), vars);
415        List<GenPolynomial<ModInteger>> fieldPolynomials = new ArrayList<GenPolynomial<ModInteger>>();
416
417        //add v1^2 + v1, v2^2 + v2, v3^2 + v3 to fieldPolynomials
418        for (int i = 0; i < vars.length; i++) {
419            GenPolynomial<ModInteger> var = z2p.univariate(i);
420            fieldPolynomials.add(var.multiply(var).sum(var));
421        }
422
423
424        Ideal<ModInteger> fieldPolys = new Ideal<ModInteger>(z2p, fieldPolynomials);
425        ResidueRing<ModInteger> ring = new ResidueRing<ModInteger>(fieldPolys);
426        String[] mvars = { "mv3", "mv2", "mv1" };
427        GenPolynomialRing<Residue<ModInteger>> ringp = new GenPolynomialRing<Residue<ModInteger>>(ring,
428                        mvars.length, mvars);
429
430        List<GenPolynomial<Residue<ModInteger>>> polynomials = new ArrayList<GenPolynomial<Residue<ModInteger>>>();
431
432        GenPolynomial<Residue<ModInteger>> v1 = ringp.univariate(0);
433        GenPolynomial<Residue<ModInteger>> v2 = ringp.univariate(1);
434        GenPolynomial<Residue<ModInteger>> v3 = ringp.univariate(2);
435        GenPolynomial<Residue<ModInteger>> notV1 = v1.sum(ringp.ONE);
436        GenPolynomial<Residue<ModInteger>> notV2 = v2.sum(ringp.ONE);
437        GenPolynomial<Residue<ModInteger>> notV3 = v3.sum(ringp.ONE);
438
439        //v1*v2
440        GenPolynomial<Residue<ModInteger>> p1 = v1.multiply(v2);
441
442        //v1*v2 + v1 + v2 + 1
443        GenPolynomial<Residue<ModInteger>> p2 = notV1.multiply(notV2);
444
445        //v1*v3 + v1 + v3 + 1
446        GenPolynomial<Residue<ModInteger>> p3 = notV1.multiply(notV3);
447
448        polynomials.add(p1);
449        polynomials.add(p2);
450        polynomials.add(p3);
451
452        //GroebnerBase<Residue<ModInteger>> gb = new GroebnerBasePseudoSeq<Residue<ModInteger>>(ring);
453        GroebnerBase<Residue<ModInteger>> gb = GBFactory.getImplementation(ring);
454        List<GenPolynomial<Residue<ModInteger>>> G = gb.GB(polynomials);
455
456        System.out.println(G);
457    }
458
459
460    /**
461     * example8. Coefficients in Boolean residue class ring with cuppling of
462     * variables.
463     */
464    public static void example8() {
465        String[] vars = { "v3", "v2", "v1" };
466
467        ModIntegerRing z2 = new ModIntegerRing(2);
468        GenPolynomialRing<ModInteger> z2p = new GenPolynomialRing<ModInteger>(z2, vars.length, new TermOrder(
469                        TermOrder.INVLEX), vars);
470        List<GenPolynomial<ModInteger>> fieldPolynomials = new ArrayList<GenPolynomial<ModInteger>>();
471
472        //add v1^2 + v1, v2^2 + v2, v3^2 + v3 to fieldPolynomials
473        for (int i = 0; i < vars.length; i++) {
474            GenPolynomial<ModInteger> var = z2p.univariate(i);
475            fieldPolynomials.add(var.multiply(var).sum(var));
476        }
477
478
479        Ideal<ModInteger> fieldPolys = new Ideal<ModInteger>(z2p, fieldPolynomials);
480        ResidueRing<ModInteger> ring = new ResidueRing<ModInteger>(fieldPolys);
481        String[] mvars = { "mv3", "mv2", "mv1" };
482        GenPolynomialRing<Residue<ModInteger>> ringp = new GenPolynomialRing<Residue<ModInteger>>(ring,
483                        mvars.length, mvars);
484
485        List<GenPolynomial<Residue<ModInteger>>> polynomials = new ArrayList<GenPolynomial<Residue<ModInteger>>>();
486
487        GenPolynomial<Residue<ModInteger>> v1 = ringp.univariate(0);
488        GenPolynomial<Residue<ModInteger>> v2 = ringp.univariate(1);
489        GenPolynomial<Residue<ModInteger>> v3 = ringp.univariate(2);
490        GenPolynomial<Residue<ModInteger>> notV1 = v1.sum(ringp.ONE);
491        GenPolynomial<Residue<ModInteger>> notV2 = v2.sum(ringp.ONE);
492        GenPolynomial<Residue<ModInteger>> notV3 = v3.sum(ringp.ONE);
493
494        //v1*v2
495        GenPolynomial<Residue<ModInteger>> p1 = v1.multiply(v2);
496
497        //v1*v2 + v1 + v2 + 1
498        GenPolynomial<Residue<ModInteger>> p2 = notV1.multiply(notV2);
499
500        //v1*v3 + v1 + v3 + 1
501        GenPolynomial<Residue<ModInteger>> p3 = notV1.multiply(notV3);
502
503        polynomials.add(p1);
504        polynomials.add(p2);
505        polynomials.add(p3);
506
507        List<Residue<ModInteger>> gens = ring.generators();
508        System.out.println("gens = " + gens);
509        GenPolynomial<Residue<ModInteger>> mv3v3 = v3.subtract(gens.get(1));
510        GenPolynomial<Residue<ModInteger>> mv2v2 = v2.subtract(gens.get(2));
511        GenPolynomial<Residue<ModInteger>> mv1v1 = v1.subtract(gens.get(3));
512
513        System.out.println("mv3v3 = " + mv3v3);
514        System.out.println("mv2v2 = " + mv2v2);
515        System.out.println("mv1v1 = " + mv1v1);
516
517        polynomials.add(mv3v3);
518        polynomials.add(mv2v2);
519        polynomials.add(mv1v1);
520
521        //GroebnerBase<Residue<ModInteger>> gb = new GroebnerBasePseudoSeq<Residue<ModInteger>>(ring);
522        GroebnerBase<Residue<ModInteger>> gb = GBFactory.getImplementation(ring);
523
524        List<GenPolynomial<Residue<ModInteger>>> G = gb.GB(polynomials);
525
526        System.out.println(G);
527    }
528
529
530    /**
531     * example9. Groebner base and dimension.
532     */
533    public static void example9() {
534        String[] vars = { "d1", "d2", "d3", "p1a", "p1b", "p1c", "p2a", "p2b", "p2c", "p3a", "p3b", "p3c",
535                "p4a", "p4b", "p4c", "A", "B", "C", "D" };
536
537        BigRational br = new BigRational();
538        GenPolynomialRing<BigRational> pring = new GenPolynomialRing<BigRational>(br, vars);
539        //GenPolynomialRing<BigRational> pring = new GenPolynomialRing<BigRational>(br, vars.length, new TermOrder(TermOrder.INVLEX), vars);
540
541        GenPolynomial<BigRational> e1 = pring.parse("A*p1a+B*p1b+C*p1c+D"); // (1)
542        GenPolynomial<BigRational> e2 = pring.parse("A*p2a+B*p2b+C*p2c+D"); // (2)
543        GenPolynomial<BigRational> e3 = pring.parse("A*p3a+B*p3b+C*p3c+D"); // (3)
544        GenPolynomial<BigRational> e4 = pring.parse("A*p4a+B*p4b+C*p4c+D"); // (4)
545        GenPolynomial<BigRational> e5 = pring.parse("p2a-p3a"); // (5)
546        GenPolynomial<BigRational> e6 = pring.parse("p2b-p3b"); // (6)
547        GenPolynomial<BigRational> e7 = pring.parse("p2c-p3c"); // (7)
548        GenPolynomial<BigRational> e8 = pring.parse("(p2a-p1a)^2+(p2b-p1b)^2+(p2c-p1c)^2-d1^2"); // (8)
549        GenPolynomial<BigRational> e9 = pring.parse("(p4a-p3a)^2+(p4b-p3b)^2+(p4c-p3c)^2-d2^2"); // (9)
550
551        List<GenPolynomial<BigRational>> cp = new ArrayList<GenPolynomial<BigRational>>(9);
552        cp.add(e1);
553        cp.add(e2);
554        cp.add(e3);
555        cp.add(e4);
556        cp.add(e5);
557        cp.add(e6);
558        cp.add(e7);
559        cp.add(e8);
560        cp.add(e9);
561
562        GenPolynomial<BigRational> e10 = pring.parse("(p4a-p1a)^2+(p4b-p1b)^2+(p4c-p1c)^2-d3^2"); // (10)
563        cp.add(e10);
564
565        List<GenPolynomial<BigRational>> gb;
566        GroebnerBase<BigRational> sgb = GBFactory.getImplementation(br);
567        gb = sgb.GB(cp);
568        //System.out.println("gb = " + gb);
569
570        PolynomialList<BigRational> pl = new PolynomialList<BigRational>(pring, gb);
571        Ideal<BigRational> id = new Ideal<BigRational>(pl, true);
572        System.out.println("cp = " + cp);
573        System.out.println("id = " + id);
574
575        Dimension dim = id.dimension();
576        System.out.println("dim = " + dim);
577    }
578
579
580    /**
581     * example10. abtract types: GB of
582     * List<GenPolynomial<AlgebraicNumber<Quotient
583     * <AlgebraicNumber<BigRational>>>>>.
584     */
585    public static void example10() {
586        Scripting.setLang(Scripting.Lang.Ruby);
587        BigRational bfac = new BigRational(1);
588        GenPolynomialRing<BigRational> pfac;
589        pfac = new GenPolynomialRing<BigRational>(bfac, new String[] { "w2" });
590        System.out.println("pfac = " + pfac.toScript());
591
592        // p = w2^2 - 2
593        GenPolynomial<BigRational> p = pfac.univariate(0, 2).subtract(pfac.fromInteger(2L));
594        System.out.println("p = " + p.toScript());
595
596        AlgebraicNumberRing<BigRational> afac;
597        afac = new AlgebraicNumberRing<BigRational>(p, true);
598        System.out.println("afac = " + afac.toScript());
599
600        GenPolynomialRing<AlgebraicNumber<BigRational>> pafac;
601        pafac = new GenPolynomialRing<AlgebraicNumber<BigRational>>(afac, new String[] { "x" });
602        System.out.println("pafac = " + pafac.toScript());
603
604        QuotientRing<AlgebraicNumber<BigRational>> qafac;
605        qafac = new QuotientRing<AlgebraicNumber<BigRational>>(pafac);
606        System.out.println("qafac = " + qafac.toScript());
607
608        GenPolynomialRing<Quotient<AlgebraicNumber<BigRational>>> pqafac;
609        pqafac = new GenPolynomialRing<Quotient<AlgebraicNumber<BigRational>>>(qafac, new String[] { "wx" });
610        System.out.println("pqafac = " + pqafac.toScript());
611        List<GenPolynomial<Quotient<AlgebraicNumber<BigRational>>>> qgen = pqafac.generators();
612        System.out.println("qgen = " + qgen);
613
614        // q = wx^2 - x
615        GenPolynomial<Quotient<AlgebraicNumber<BigRational>>> q;
616        q = pqafac.univariate(0, 2).subtract(qgen.get(2));
617        System.out.println("q = " + q.toScript());
618
619        AlgebraicNumberRing<Quotient<AlgebraicNumber<BigRational>>> aqafac;
620        aqafac = new AlgebraicNumberRing<Quotient<AlgebraicNumber<BigRational>>>(q, true);
621        System.out.println("aqafac = " + aqafac.toScript());
622
623        GenPolynomialRing<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>> paqafac;
624        paqafac = new GenPolynomialRing<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>>(aqafac,
625                        new String[] { "y", "z" });
626        System.out.println("paqafac = " + paqafac.toScript());
627
628        List<GenPolynomial<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>>> L;
629        L = new ArrayList<GenPolynomial<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>>>();
630
631        GenPolynomial<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>> pp;
632        /*
633        for (int i = 0; i < 2; i++) {
634            pp = paqafac.random(2, 3, 3, 0.2f);
635            System.out.println("pp = " + pp.toScript());
636            if (pp.isConstant()) {
637                pp = paqafac.univariate(0,3);
638            }
639            L.add(pp);
640        }
641        */
642        pp = paqafac.parse("(( y^2 - x )*( z^2 - 2 ) )");
643        System.out.println("pp = " + pp.toScript());
644        L.add(pp);
645        pp = paqafac.parse("( y^2 z - x^3 z - w2*wx )");
646        System.out.println("pp = " + pp.toScript());
647        L.add(pp);
648        //System.out.println("L = " + L);
649
650        GroebnerBaseAbstract<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>> bb;
651        //bb = new GroebnerBaseSeq<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>>(); //aqafac);
652        bb = GBFactory.getImplementation(aqafac);
653        //bb = GBFactory.getProxy(aqafac);
654
655        System.out.println("isGB(L) = " + bb.isGB(L));
656
657        long t = System.currentTimeMillis();
658        List<GenPolynomial<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>>> G = bb.GB(L);
659        t = System.currentTimeMillis() - t;
660        System.out.println("time = " + t + " milliseconds");
661        //System.out.println("G = " + G);
662        for (GenPolynomial<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>> g : G) {
663            System.out.println("g = " + g.toScript());
664        }
665        System.out.println("isGB(G) = " + bb.isGB(G));
666        bb.terminate();
667    }
668
669
670    /**
671     * example11. abtract types: GB of List<GenPolynomial<BigRational>>>.
672     */
673    public static void example11() {
674        Scripting.setLang(Scripting.Lang.Ruby);
675        BigRational bfac = new BigRational(1);
676        GenPolynomialRing<BigRational> pfac;
677        String[] vars = new String[] { "w2", "xi", "x", "wx", "y", "z" };
678        TermOrder to = new TermOrder(TermOrder.INVLEX);
679        pfac = new GenPolynomialRing<BigRational>(bfac, vars, to);
680        System.out.println("pfac = " + pfac.toScript());
681
682        List<GenPolynomial<BigRational>> L = new ArrayList<GenPolynomial<BigRational>>();
683        GenPolynomial<BigRational> pp;
684        pp = pfac.parse("( w2^2 - 2 )");
685        System.out.println("pp = " + pp.toScript());
686        L.add(pp);
687        pp = pfac.parse("( wx^2 - x )");
688        System.out.println("pp = " + pp.toScript());
689        L.add(pp);
690        pp = pfac.parse("( xi * x - 1 )");
691        System.out.println("pp = " + pp.toScript());
692        L.add(pp);
693        pp = pfac.parse("(( y^2 - x )*( z^2 - 2 ) )");
694        System.out.println("pp = " + pp.toScript());
695        L.add(pp);
696        pp = pfac.parse("( y^2 z - x^3 z - w2*wx )");
697        System.out.println("pp = " + pp.toScript());
698        L.add(pp);
699
700        GroebnerBaseAbstract<BigRational> bb;
701        //bb = new GroebnerBaseSeq<BigRational>(); //bfac);
702        bb = GBFactory.getImplementation(bfac);
703        //bb = GBFactory.getProxy(bfac);
704
705        System.out.println("isGB(L) = " + bb.isGB(L));
706        long t = System.currentTimeMillis();
707        List<GenPolynomial<BigRational>> G = bb.GB(L);
708        t = System.currentTimeMillis() - t;
709        System.out.println("time = " + t + " milliseconds");
710        for (GenPolynomial<BigRational> g : G) {
711            System.out.println("g = " + g.toScript());
712        }
713        System.out.println("isGB(G) = " + bb.isGB(G));
714        bb.terminate();
715    }
716
717
718    /**
719     * example12. abtract types: GB of
720     * List<GenPolynomial<Quotient<BigRational>>>>.
721     */
722    public static void example12() {
723        Scripting.setLang(Scripting.Lang.Ruby);
724        BigRational bfac = new BigRational(1);
725        GenPolynomialRing<BigRational> cfac;
726        String[] cvars = new String[] { "x" };
727        TermOrder to = new TermOrder(TermOrder.INVLEX);
728        cfac = new GenPolynomialRing<BigRational>(bfac, cvars, to);
729        System.out.println("cfac = " + cfac.toScript());
730
731        QuotientRing<BigRational> qfac;
732        qfac = new QuotientRing<BigRational>(cfac);
733        System.out.println("qfac = " + qfac.toScript());
734
735        String[] vars = new String[] { "w2", "wx", "y", "z" };
736        GenPolynomialRing<Quotient<BigRational>> pfac;
737        pfac = new GenPolynomialRing<Quotient<BigRational>>(qfac, vars, to);
738        System.out.println("pfac = " + pfac.toScript());
739
740        List<GenPolynomial<Quotient<BigRational>>> L = new ArrayList<GenPolynomial<Quotient<BigRational>>>();
741        GenPolynomial<Quotient<BigRational>> pp;
742        pp = pfac.parse("( w2^2 - 2 )");
743        System.out.println("pp = " + pp.toScript());
744        L.add(pp);
745        pp = pfac.parse("( wx^2 - x )");
746        System.out.println("pp = " + pp.toScript());
747        L.add(pp);
748        pp = pfac.parse("(( y^2 - x )*( z^2 - 2 ) )");
749        System.out.println("pp = " + pp.toScript());
750        L.add(pp);
751        pp = pfac.parse("( y^2 z - x^3 z - w2*wx )");
752        System.out.println("pp = " + pp.toScript());
753        L.add(pp);
754
755        GroebnerBaseAbstract<Quotient<BigRational>> bb;
756        //bb = new GroebnerBaseSeq<Quotient<BigRational>>(); //bfac);
757
758        // sequential
759        bb = GBFactory.getImplementation(qfac);
760        System.out.println("isGB(L) = " + bb.isGB(L));
761        long t = System.currentTimeMillis();
762        List<GenPolynomial<Quotient<BigRational>>> G = bb.GB(L);
763        t = System.currentTimeMillis() - t;
764        System.out.println("time = " + t + " milliseconds");
765        for (GenPolynomial<Quotient<BigRational>> g : G) {
766            System.out.println("g = " + g.toScript());
767        }
768        System.out.println("isGB(G) = " + bb.isGB(G));
769        bb.terminate();
770
771        // parallel
772        bb = GBFactory.getProxy(qfac);
773        System.out.println("isGB(L) = " + bb.isGB(L));
774        t = System.currentTimeMillis();
775        G = bb.GB(L);
776        t = System.currentTimeMillis() - t;
777        System.out.println("time = " + t + " milliseconds");
778        for (GenPolynomial<Quotient<BigRational>> g : G) {
779            System.out.println("g = " + g.toScript());
780        }
781        System.out.println("isGB(G) = " + bb.isGB(G));
782        bb.terminate();
783
784        // builder
785        bb = GBAlgorithmBuilder.polynomialRing(pfac).fractionFree().syzygyPairlist().parallel(3).build();
786        System.out.println("isGB(L) = " + bb.isGB(L));
787        t = System.currentTimeMillis();
788        G = bb.GB(L);
789        t = System.currentTimeMillis() - t;
790        System.out.println("time = " + t + " milliseconds");
791        for (GenPolynomial<Quotient<BigRational>> g : G) {
792            System.out.println("g = " + g.toScript());
793        }
794        System.out.println("isGB(G) = " + bb.isGB(G));
795        bb.terminate();
796    }
797}