Source code

001/*
002 * $Id: FactorRationalTest.java 5863 2018-07-20 11:13:34Z kredel $
003 */
004
005package edu.jas.ufd;
006
007import java.util.SortedMap;
008
009
010import junit.framework.Test;
011import junit.framework.TestCase;
012import junit.framework.TestSuite;
013
014import edu.jas.arith.BigRational;
015import edu.jas.kern.ComputerThreads;
016import edu.jas.poly.GenPolynomial;
017import edu.jas.poly.GenPolynomialRing;
018import edu.jas.poly.TermOrder;
019
020
021/**
022 * Factor rational tests with JUnit.
023 * @author Heinz Kredel
024 */
025
026public class FactorRationalTest extends TestCase {
027
028
029    /**
030     * main.
031     */
032    public static void main(String[] args) {
033        junit.textui.TestRunner.run(suite());
034    }
035
036
037    /**
038     * Constructs a <CODE>FactorRationalTest</CODE> object.
039     * @param name String.
040     */
041    public FactorRationalTest(String name) {
042        super(name);
043    }
044
045
046    /**
047     */
048    public static Test suite() {
049        TestSuite suite = new TestSuite(FactorRationalTest.class);
050        return suite;
051    }
052
053
054    int rl = 3;
055
056
057    int kl = 5;
058
059
060    int ll = 5;
061
062
063    int el = 3;
064
065
066    float q = 0.3f;
067
068
069    @Override
070    protected void setUp() {
071    }
072
073
074    @Override
075    protected void tearDown() {
076        ComputerThreads.terminate();
077    }
078
079
080    /**
081     * Test dummy for Junit.
082     */
083    public void testDummy() {
084    }
085
086
087    /**
088     * Test rational univariate factorization.
089     */
090    public void testRationalFactorization() {
091        TermOrder to = new TermOrder(TermOrder.INVLEX);
092        BigRational cfac = new BigRational(1);
093        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 1, to);
094        FactorRational fac = new FactorRational();
095
096        for (int i = 1; i < 3; i++) {
097            int facs = 0;
098            GenPolynomial<BigRational> a;
099            GenPolynomial<BigRational> c = pfac.random(kl - 2, ll * i, el + i, q);
100            // a = a.monic();
101            GenPolynomial<BigRational> b = pfac.random(kl - 2, ll, el, q);
102            //b = b.monic();
103            //         if ( false && ! a.leadingBaseCoefficient().isONE() ) {
104            //continue;
105            //ExpVector e = a.leadingExpVector();
106            //a.doPutToMap(e,cfac.getONE());
107            //}
108            if (b.isZERO() || c.isZERO()) {
109                continue;
110            }
111            if (c.degree() > 0) {
112                facs++;
113            }
114            if (b.degree() > 0) {
115                facs++;
116            }
117            a = c.multiply(b);
118            //System.out.println("\na = " + a);
119            //System.out.println("b = " + b);
120            //System.out.println("c = " + c);
121
122            SortedMap<GenPolynomial<BigRational>, Long> sm = fac.baseFactors(a);
123            //System.out.println("\na   = " + a);
124            //System.out.println("sm = " + sm);
125            if (sm.size() >= facs) {
126                assertTrue("#facs < " + facs, sm.size() >= facs);
127            } else {
128                long sf = 0;
129                for (Long e : sm.values()) {
130                    sf += e;
131                }
132                assertTrue("#facs < " + facs + ", b = " + b + ", c = " + c + ", sm = " + sm, sf >= facs);
133            }
134            boolean t = fac.isFactorization(a, sm);
135            //System.out.println("t        = " + t);
136            assertTrue("prod(factor(a)) = a", t);
137        }
138    }
139
140
141    /**
142     * Test rational multivariate factorization.
143     */
144    public void testRationalMultiFactorization() {
145        TermOrder to = new TermOrder(TermOrder.INVLEX);
146        BigRational cfac = new BigRational(1);
147        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 2, to);
148        FactorRational fac = new FactorRational();
149
150        for (int i = 1; i < 3; i++) {
151            int facs = 0;
152            GenPolynomial<BigRational> a;
153            GenPolynomial<BigRational> c = pfac.random(kl - 2, ll * i, el + i, q);
154            // a = a.monic();
155            GenPolynomial<BigRational> b = pfac.random(kl - 2, ll, el, q);
156            //b = b.monic();
157            //         if ( false && ! a.leadingBaseCoefficient().isONE() ) {
158            //continue;
159            //ExpVector e = a.leadingExpVector();
160            //a.doPutToMap(e,cfac.getONE());
161            //}
162            if (b.isZERO() || c.isZERO()) {
163                continue;
164            }
165            if (c.degree() > 0) {
166                facs++;
167            }
168            if (b.degree() > 0) {
169                facs++;
170            }
171            a = c.multiply(b);
172            //System.out.println("\na = " + a);
173            //System.out.println("b = " + b);
174            //System.out.println("c = " + c);
175
176            SortedMap<GenPolynomial<BigRational>, Long> sm = fac.factors(a);
177            //System.out.println("\na   = " + a);
178            //System.out.println("sm = " + sm);
179            if (sm.size() >= facs) {
180                assertTrue("#facs < " + facs, sm.size() >= facs);
181            } else {
182                long sf = 0;
183                for (Long e : sm.values()) {
184                    sf += e;
185                }
186                assertTrue("#facs < " + facs + ", b = " + b + ", c = " + c + ", sm = " + sm, sf >= facs);
187            }
188            boolean t = fac.isFactorization(a, sm);
189            //System.out.println("t        = " + t);
190            assertTrue("prod(factor(a)) = a", t);
191        }
192    }
193
194
195    /**
196     * Test rational absolute factorization.
197     */
198    public void testBaseRationalAbsoluteFactorization() {
199        TermOrder to = new TermOrder(TermOrder.INVLEX);
200        BigRational cfac = new BigRational(1);
201        String[] alpha = new String[] { "alpha" };
202        //String[] vars = new String[] { "z" };
203        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 1, to, alpha);
204        GenPolynomial<BigRational> agen = pfac.univariate(0, 4);
205        agen = agen.sum(pfac.fromInteger(4)); // x^4 + 4
206
207        FactorRational engine = new FactorRational();
208
209        FactorsMap<BigRational> F
210        //= engine.baseFactorsAbsoluteSquarefree(agen);
211        //= engine.baseFactorsAbsoluteIrreducible(agen);
212        = engine.baseFactorsAbsolute(agen);
213        //System.out.println("agen     = " + agen);
214        //System.out.println("F        = " + F);
215
216        boolean t = engine.isAbsoluteFactorization(F);
217        //System.out.println("t        = " + t);
218        assertTrue("prod(factor(a)) = a", t);
219    }
220
221
222    /**
223     * Test rational absolute factorization.
224     */
225    public void testRationalAbsoluteFactorization() {
226        TermOrder to = new TermOrder(TermOrder.INVLEX);
227        BigRational cfac = new BigRational(1);
228        String[] vars = new String[] { "x", "y" };
229        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 2, to, vars);
230        GenPolynomial<BigRational> xp = pfac.univariate(0, 2);
231        GenPolynomial<BigRational> yp = pfac.univariate(1, 2);
232        GenPolynomial<BigRational> g = xp.sum(yp); // x^2 + y^2
233        //GenPolynomial<BigRational> g = xp.subtract(yp); // x^2 - y^2
234
235        FactorRational engine = new FactorRational();
236
237        FactorsMap<BigRational> F
238        //= engine.baseFactorsAbsoluteSquarefree(agen);
239        //= engine.baseFactorsAbsoluteIrreducible(agen);
240        = engine.factorsAbsolute(g);
241        //System.out.println("g    = " + g);
242        //System.out.println("F    = " + F);
243
244        boolean t = engine.isAbsoluteFactorization(F);
245        //System.out.println("t        = " + t);
246        assertTrue("prod(factor(a)) = a", t);
247    }
248
249}