Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.ufd;
006
007
008import java.util.ArrayList;
009import java.util.List;
010import java.util.SortedMap;
011
012import edu.jas.arith.BigInteger;
013import edu.jas.arith.BigRational;
014import edu.jas.kern.ComputerThreads;
015import edu.jas.poly.AlgebraicNumber;
016import edu.jas.poly.AlgebraicNumberRing;
017import edu.jas.poly.GenPolynomial;
018import edu.jas.poly.GenPolynomialRing;
019import edu.jas.poly.PolyUtil;
020import edu.jas.poly.TermOrder;
021import edu.jas.vector.GenMatrix;
022import edu.jas.vector.GenMatrixRing;
023
024
025/**
026 * Examples for ufd and elementaty integration usage.
027 * @author Heinz Kredel
028 */
029
030public class Examples {
031
032
033    /**
034     * main.
035     */
036    public static void main(String[] args) {
037        //// no go: example6();
038        //example9(); 
039        example1();
040        example2();
041        example10();
042        example11();
043        ComputerThreads.terminate();
044    }
045
046
047    /**
048     * example1 with GenMatrix.
049     */
050    public static void example1() {
051        System.out.println("\n\n example 1");
052
053        BigInteger cfac;
054        GenPolynomialRing<BigInteger> fac;
055        QuotientRing<BigInteger> efac;
056        GenPolynomialRing<Quotient<BigInteger>> qfac;
057        GenMatrixRing<GenPolynomial<Quotient<BigInteger>>> mfac;
058
059        cfac = new BigInteger();
060        System.out.println("cfac = " + cfac);
061
062        String[] vc = new String[] { "a", "b" };
063        fac = new GenPolynomialRing<BigInteger>(cfac, vc);
064        System.out.println(" fac = " + fac.toScript());
065
066        efac = new QuotientRing<BigInteger>(fac);
067        System.out.println("efac = " + efac.toScript());
068
069        String[] v = new String[] { "x", "y", "z" };
070        qfac = new GenPolynomialRing<Quotient<BigInteger>>(efac, 3, v);
071        System.out.println("qfac = " + qfac.toScript());
072
073        mfac = new GenMatrixRing<GenPolynomial<Quotient<BigInteger>>>(qfac, 3, 3);
074        System.out.println("mfac = " + mfac.toScript());
075
076        GenPolynomial<Quotient<BigInteger>> p;
077        p = qfac.random(3, 4, 2, 0.3f);
078        System.out.println("\np = " + p);
079
080        GenMatrix<GenPolynomial<Quotient<BigInteger>>> m;
081        m = mfac.random(3, 0.4f);
082        System.out.println("\nm = " + m.toScript());
083    }
084
085
086    /**
087     * example2 with GenPolynomial.
088     */
089    public static void example2() {
090        System.out.println("\n\n example 2");
091
092        BigInteger fac = new BigInteger();
093        String[] var = new String[] { "a", "b", "c", "d" };
094        int numvars = var.length;
095        //not needed: TermOrder tord = new TermOrder(TermOrder.INVLEX);
096        GenPolynomialRing<BigInteger> ring = new GenPolynomialRing<BigInteger>(fac, var);
097        List<GenPolynomial<BigInteger>> vars = new ArrayList<GenPolynomial<BigInteger>>();
098
099        // Build up the polynomial from vars.
100        for (int i = 0; i < numvars; i++)
101            vars.add(ring.univariate(i));
102        System.out.println("vars = " + vars);
103
104        // Silly demo one first. 
105        //  ab+ac+db+dc   ->  (a+d)(b+c)
106        GenPolynomial<BigInteger> tmp = (vars.get(0).multiply(vars.get(1)))
107                        .sum(vars.get(0).multiply(vars.get(2))).sum(vars.get(3).multiply(vars.get(1)))
108                        .sum(vars.get(3).multiply(vars.get(2)));
109
110        //alternative: tmp = ring.parse("a b + a c + d b + d c");
111        System.out.println("tmp = " + tmp);
112
113        Factorization<BigInteger> engine = FactorFactory.getImplementation(fac);
114        SortedMap<GenPolynomial<BigInteger>, Long> factors = engine.factors(tmp);
115
116        System.out.println("factors = " + factors);
117    }
118
119
120    /**
121     * example6. Partial fraction decomposition.
122     */
123    public static void example6() {
124        System.out.println("\n\nexample 6");
125        // http://www.apmaths.uwo.ca/~rcorless/AM563/NOTES/Nov_16_95/node13.html
126
127        TermOrder to = new TermOrder(TermOrder.INVLEX);
128        BigRational cfac = new BigRational(1);
129        //String[] alpha = new String[] { "alpha" };
130        String[] vars = new String[] { "x" };
131        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 1, to, vars);
132
133        // ( 7 x^6 + 1 ) /  ( x^7 + x + 1 )
134        GenPolynomial<BigRational> D = pfac.parse("x^7 + x + 1");
135        GenPolynomial<BigRational> N = PolyUtil.<BigRational> baseDerivative(D);
136
137        FactorRational engine = new FactorRational();
138
139        PartialFraction<BigRational> F = engine.baseAlgebraicPartialFraction(N, D);
140        System.out.println("\nintegral " + F);
141    }
142
143
144    /**
145     * example9. Rothstein-Trager and absolute factorization algorithm.
146     */
147    public static void example9() {
148        System.out.println("\n\nexample 9");
149
150        TermOrder to = new TermOrder(TermOrder.INVLEX);
151        BigRational cfac = new BigRational(1);
152        //String[] alpha = new String[] { "alpha" };
153        String[] vars = new String[] { "x" };
154        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 1, to, vars);
155
156        // 1 / ( x^5 + x - 7 ) 
157        GenPolynomial<BigRational> D = pfac.parse("( x^5 + x - 7 )");
158        GenPolynomial<BigRational> N = pfac.getONE();
159
160        FactorRational engine = new FactorRational();
161
162        PartialFraction<BigRational> F = engine.baseAlgebraicPartialFraction(N, D);
163        System.out.println("\nintegral " + F);
164
165        //PartialFraction<BigRational> Fa = engine.baseAlgebraicPartialFractionIrreducibleAbsolute(N,D);
166        //System.out.println("\nintegral_a " + Fa);
167
168    }
169
170
171    /**
172     * example10. factorization in Q(sqrt(2))(x)(sqrt(x))[y].
173     */
174    public static void example10() {
175        System.out.println("\n\nexample 10");
176
177        TermOrder to = new TermOrder(TermOrder.INVLEX);
178        BigRational cfac = new BigRational(1);
179
180        String[] var_w2 = new String[] { "w2" };
181        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 1, to, var_w2);
182        System.out.println("pfac   = " + pfac.toScript());
183
184        GenPolynomial<BigRational> w2 = pfac.parse(" w2^2 - 2 ");
185        System.out.println("w2     = " + w2);
186
187        AlgebraicNumberRing<BigRational> a2fac = new AlgebraicNumberRing<BigRational>(w2, true);
188        System.out.println("a2fac  = " + a2fac.toScript());
189
190        String[] var_x = new String[] { "x" };
191        GenPolynomialRing<AlgebraicNumber<BigRational>> apfac = new GenPolynomialRing<AlgebraicNumber<BigRational>>(
192                        a2fac, 1, to, var_x);
193        System.out.println("apfac  = " + apfac.toScript());
194
195        QuotientRing<AlgebraicNumber<BigRational>> qfac = new QuotientRing<AlgebraicNumber<BigRational>>(
196                        apfac);
197        System.out.println("qfac   = " + qfac.toScript());
198
199        String[] var_wx = new String[] { "wx" };
200        GenPolynomialRing<Quotient<AlgebraicNumber<BigRational>>> pqfac = new GenPolynomialRing<Quotient<AlgebraicNumber<BigRational>>>(
201                        qfac, 1, to, var_wx);
202        System.out.println("pqfac  = " + pqfac.toScript());
203
204        GenPolynomial<Quotient<AlgebraicNumber<BigRational>>> wx = pqfac.parse(" wx^2 - { x } ");
205        System.out.println("wx     = " + wx);
206
207        AlgebraicNumberRing<Quotient<AlgebraicNumber<BigRational>>> axfac = new AlgebraicNumberRing<Quotient<AlgebraicNumber<BigRational>>>(
208                        wx, true);
209        System.out.println("axfac  = " + axfac.toScript());
210
211        String[] var_y = new String[] { "y" };
212        GenPolynomialRing<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>> apqfac = new GenPolynomialRing<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>>(
213                        axfac, 1, to, var_y);
214        System.out.println("apqfac = " + apqfac.toScript());
215
216        //  ( y^2 - x ) * ( y^2 - 2 ), need {} for recursive coefficients
217        GenPolynomial<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>> f;
218        f = apqfac.parse(" ( y^2 - { { x } } ) * ( y^2 - 2 )^2 ");
219        System.out.println("f      = " + f);
220
221        FactorAbstract<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>> engine = FactorFactory
222                        .getImplementation(axfac);
223        System.out.println("engine = " + engine);
224
225        SortedMap<GenPolynomial<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>>, Long> F = engine
226                        .factors(f);
227        System.out.println("factors(f) = " + F);
228    }
229
230
231    /**
232     * example11. factorization in Z[a,c,d,e,x].
233     */
234    public static void example11() {
235        System.out.println("\n\nexample 11");
236        for (int i = 0; i < 10; i++) { //100000
237            String[] vars = new String[] { "a", "c", "d", "e", "x" };
238            GenPolynomialRing<edu.jas.arith.BigInteger> fac;
239            fac = new GenPolynomialRing<edu.jas.arith.BigInteger>(edu.jas.arith.BigInteger.ZERO, vars.length,
240                            new TermOrder(TermOrder.INVLEX), vars);
241
242            GenPolynomial<edu.jas.arith.BigInteger> poly = fac.parse("a*d*e + c*d^2*x + a*e^2*x + c*d*e*x^2");
243            //System.out.println("Run " + i + ": " + poly.toString());
244            FactorAbstract<edu.jas.arith.BigInteger> factorAbstract = FactorFactory
245                            .getImplementation(edu.jas.arith.BigInteger.ZERO);
246            long ts = System.currentTimeMillis();
247            SortedMap<GenPolynomial<edu.jas.arith.BigInteger>, Long> map = factorAbstract.factors(poly);
248            ts = System.currentTimeMillis() - ts;
249            //System.out.println("Run Factors " + ts + "ms: " + map.toString());
250            boolean t = factorAbstract.isFactorization(poly, map);
251            if (!t) {
252                System.out.println("Run " + i + ": " + poly.toString());
253                System.out.println("Run not Factors " + ts + "ms: " + map.toString());
254            }
255        }
256    }
257
258}