Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.ufd;
006
007
008import java.util.SortedMap;
009
010import edu.jas.arith.BigRational;
011import edu.jas.kern.ComputerThreads;
012import edu.jas.poly.ExpVector;
013import edu.jas.poly.GenPolynomial;
014import edu.jas.poly.GenPolynomialRing;
015import edu.jas.poly.PolyUtil;
016import edu.jas.poly.TermOrder;
017
018import junit.framework.Test;
019import junit.framework.TestCase;
020import junit.framework.TestSuite;
021
022
023/**
024 * Squarefree factorization BigRational coefficients tests with JUnit.
025 * @author Heinz Kredel
026 */
027
028public class SquarefreeRatTest extends TestCase {
029
030
031    /**
032     * main.
033     */
034    public static void main(String[] args) {
035        junit.textui.TestRunner.run(suite());
036        ComputerThreads.terminate();
037    }
038
039
040    /**
041     * Constructs a <CODE>SquarefreeRatTest</CODE> object.
042     * @param name String.
043     */
044    public SquarefreeRatTest(String name) {
045        super(name);
046    }
047
048
049    /**
050     */
051    public static Test suite() {
052        TestSuite suite = new TestSuite(SquarefreeRatTest.class);
053        return suite;
054    }
055
056
057    TermOrder to = new TermOrder(TermOrder.INVLEX);
058
059
060    int rl = 3;
061
062
063    int kl = 3;
064
065
066    int ll = 4;
067
068
069    int el = 3;
070
071
072    float q = 0.25f;
073
074
075    String[] vars;
076
077
078    String[] cvars;
079
080
081    String[] c1vars;
082
083
084    String[] rvars;
085
086
087    BigRational fac;
088
089
090    GreatestCommonDivisorAbstract<BigRational> ufd;
091
092
093    SquarefreeFieldChar0<BigRational> sqf, sqfy;
094
095
096    GenPolynomialRing<BigRational> dfac;
097
098
099    GenPolynomial<BigRational> a, b, c, d, e;
100
101
102    GenPolynomialRing<BigRational> cfac;
103
104
105    GenPolynomialRing<GenPolynomial<BigRational>> rfac;
106
107
108    GenPolynomial<GenPolynomial<BigRational>> ar, br, cr, dr, er;
109
110
111    @Override
112    protected void setUp() {
113        vars = ExpVector.STDVARS(rl);
114        cvars = ExpVector.STDVARS(rl - 1);
115        c1vars = new String[] { cvars[0] };
116        rvars = new String[] { vars[rl - 1] };
117        fac = new BigRational(1);
118        //ufd = new GreatestCommonDivisorSubres<BigRational>();
119        //ufd = GCDFactory.<BigRational> getImplementation(fac);
120        ufd = GCDFactory.getProxy(fac);
121        sqf = new SquarefreeFieldChar0<BigRational>(fac);
122        sqfy = new SquarefreeFieldChar0Yun<BigRational>(fac);
123
124        SquarefreeAbstract<BigRational> sqff = SquarefreeFactory.getImplementation(fac);
125        //System.out.println("sqf  = " + sqf);
126        //System.out.println("sqfy = " + sqfy);
127        //System.out.println("sqff = " + sqff);
128        assertEquals("sqf/y == sqff ", sqfy.getClass(), sqff.getClass());
129
130        a = b = c = d = e = null;
131        ar = br = cr = dr = er = null;
132    }
133
134
135    @Override
136    protected void tearDown() {
137        a = b = c = d = e = null;
138        ar = br = cr = dr = er = null;
139        // ComputerThreads.terminate();
140    }
141
142
143    /**
144     * Test base squarefree.
145     */
146    public void testBaseSquarefree() {
147        //System.out.println("\nbase:");
148        dfac = new GenPolynomialRing<BigRational>(fac, 1, to, rvars);
149
150        a = dfac.random(kl, ll, el + 2, q);
151        b = dfac.random(kl, ll, el + 2, q);
152        c = dfac.random(kl, ll, el, q);
153        //System.out.println("a  = " + a);
154        //System.out.println("b  = " + b);
155        //System.out.println("c  = " + c);
156        if (a.isZERO() || b.isZERO() || c.isZERO()) {
157            // skip for this turn
158            return;
159        }
160
161        // a a b b b c
162        d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c);
163        c = a.multiply(b).multiply(c);
164        //System.out.println("d  = " + d);
165        //System.out.println("c  = " + c);
166
167        c = sqf.baseSquarefreePart(c);
168        d = sqf.baseSquarefreePart(d);
169        //System.out.println("d  = " + d);
170        //System.out.println("c  = " + c);
171        assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
172        assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
173
174        e = PolyUtil.<BigRational> baseSparsePseudoRemainder(d, c);
175        //System.out.println("e  = " + e);
176        assertTrue("squarefree(abc) | squarefree(aabbbc) " + e, e.isZERO());
177    }
178
179
180    /**
181     * Test base squarefree factors.
182     */
183    public void testBaseSquarefreeFactors() {
184        dfac = new GenPolynomialRing<BigRational>(fac, 1, to, rvars);
185
186        a = dfac.random(kl, ll, el + 2, q);
187        b = dfac.random(kl, ll, el + 1, q);
188        c = dfac.random(kl, ll, el + 2, q);
189        //System.out.println("a  = " + a);
190        //System.out.println("b  = " + b);
191        //System.out.println("c  = " + c);
192        if (a.isZERO() || b.isZERO() || c.isZERO()) {
193            // skip for this turn
194            return;
195        }
196
197        // a a b b b c
198        d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c);
199        //System.out.println("d  = " + d);
200
201        SortedMap<GenPolynomial<BigRational>, Long> sfactors;
202        sfactors = sqf.baseSquarefreeFactors(d);
203        //System.out.println("sfactors = " + sfactors);
204
205        assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
206    }
207
208
209    /**
210     * Test base squarefree factors, Yun.
211     */
212    public void testBaseSquarefreeFactorsYun() {
213        dfac = new GenPolynomialRing<BigRational>(fac, 1, to, rvars);
214
215        a = dfac.random(kl, ll, el + 3, q);
216        b = dfac.random(kl, ll, el + 3, q);
217        c = dfac.random(kl, ll, el + 2, q);
218        //System.out.println("a  = " + a);
219        //System.out.println("b  = " + b);
220        //System.out.println("c  = " + c);
221        if (a.isZERO() || b.isZERO() || c.isZERO()) {
222            // skip for this turn
223            return;
224        }
225
226        // a a b b b c
227        d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c);
228        //System.out.println("d  = " + d);
229
230        SortedMap<GenPolynomial<BigRational>, Long> sfactors;
231        long t = System.currentTimeMillis();
232        sfactors = sqf.baseSquarefreeFactors(d);
233        t = System.currentTimeMillis() - t;
234        //System.out.println("sqf_t  = " + t + " ms"); //, sfactors = " + sfactors);
235
236        t = System.currentTimeMillis();
237        sfactors = sqfy.baseSquarefreeFactors(d);
238        t = System.currentTimeMillis() - t;
239        //System.out.println("sqfy_t = " + t + " ms"); //, sfactors = " + sfactors);
240        assertTrue("dummy ", t >= 0L);
241        assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
242    }
243
244
245    /**
246     * Test recursive squarefree part.
247     */
248    public void testRecursiveSquarefreePart() {
249        //System.out.println("\nrecursive:");
250        cfac = new GenPolynomialRing<BigRational>(fac, 2 - 1, to, c1vars);
251        rfac = new GenPolynomialRing<GenPolynomial<BigRational>>(cfac, 1, to, rvars);
252
253        ar = rfac.random(kl, ll, el, q);
254        br = rfac.random(kl, ll, el, q);
255        cr = rfac.random(kl, ll, el, q);
256        //System.out.println("ar = " + ar);
257        //System.out.println("br = " + br);
258        //System.out.println("cr = " + cr);
259        if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
260            // skip for this turn
261            return;
262        }
263
264        dr = ar.multiply(ar).multiply(br).multiply(br);
265        cr = ar.multiply(br);
266        //System.out.println("dr  = " + dr);
267        //System.out.println("cr  = " + cr);
268
269        cr = sqf.recursiveUnivariateSquarefreePart(cr);
270        dr = sqf.recursiveUnivariateSquarefreePart(dr);
271        //System.out.println("dr  = " + dr);
272        //System.out.println("cr  = " + cr);
273        assertTrue("isSquarefree(cr) " + cr, sqf.isRecursiveSquarefree(cr));
274        assertTrue("isSquarefree(dr) " + dr, sqf.isRecursiveSquarefree(dr));
275
276        er = PolyUtil.<BigRational> recursiveSparsePseudoRemainder(dr, cr);
277        //System.out.println("er  = " + er);
278        assertTrue("squarefree(abc) | squarefree(aabbc) " + er, er.isZERO());
279    }
280
281
282    /**
283     * Test recursive squarefree factors.
284     */
285    public void testRecursiveSquarefreeFactors() {
286        cfac = new GenPolynomialRing<BigRational>(fac, 2 - 1, to, c1vars);
287        rfac = new GenPolynomialRing<GenPolynomial<BigRational>>(cfac, 1, to, rvars);
288
289        ar = rfac.random(kl, 3, 2, q);
290        br = rfac.random(kl, 3, 2, q);
291        cr = rfac.random(kl, 3, 2, q);
292        //System.out.println("ar = " + ar);
293        //System.out.println("br = " + br);
294        //System.out.println("cr = " + cr);
295        if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
296            // skip for this turn
297            return;
298        }
299
300        dr = ar.multiply(cr).multiply(br).multiply(br);
301        //System.out.println("dr  = " + dr);
302
303        SortedMap<GenPolynomial<GenPolynomial<BigRational>>, Long> sfactors;
304        sfactors = sqf.recursiveUnivariateSquarefreeFactors(dr);
305        //System.out.println("sfactors = " + sfactors);
306        assertTrue("isFactorization(d,sfactors) ", sqf.isRecursiveFactorization(dr, sfactors));
307    }
308
309
310    /**
311     * Test recursive squarefree factors, Yun.
312     */
313    public void testRecursiveSquarefreeFactorsYun() {
314        cfac = new GenPolynomialRing<BigRational>(fac, 2 - 1, to, c1vars);
315        rfac = new GenPolynomialRing<GenPolynomial<BigRational>>(cfac, 1, to, rvars);
316
317        ar = rfac.random(kl, 3, 2, q);
318        br = rfac.random(kl, 3, 2, q);
319        cr = rfac.random(kl, 3, 2, q);
320        //System.out.println("ar = " + ar);
321        //System.out.println("br = " + br);
322        //System.out.println("cr = " + cr);
323        if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
324            // skip for this turn
325            return;
326        }
327
328        // a b b b c c
329        dr = ar.multiply(cr).multiply(cr).multiply(br).multiply(br).multiply(br);
330        //System.out.println("dr  = " + dr);
331
332        SortedMap<GenPolynomial<GenPolynomial<BigRational>>, Long> sfactors;
333        long t = System.currentTimeMillis();
334        sfactors = sqf.recursiveUnivariateSquarefreeFactors(dr);
335        t = System.currentTimeMillis() - t;
336        //System.out.println("r-sqf_t  = " + t + " ms"); //, sfactors = " + sfactors);
337
338        t = System.currentTimeMillis();
339        sfactors = sqfy.recursiveUnivariateSquarefreeFactors(dr);
340        t = System.currentTimeMillis() - t;
341        //System.out.println("r-sqfy_t = " + t + " ms"); //, sfactors = " + sfactors);
342        assertTrue("dummy ", t >= 0L);
343        assertTrue("isFactorization(d,sfactors) ", sqf.isRecursiveFactorization(dr, sfactors));
344    }
345
346
347    /**
348     * Test squarefree part.
349     */
350    public void testSquarefreePart() {
351        //System.out.println("\nfull:");
352        dfac = new GenPolynomialRing<BigRational>(fac, rl, to, vars);
353
354        a = dfac.random(kl, ll, 2, q);
355        b = dfac.random(kl, ll, 2, q);
356        c = dfac.random(kl, ll, 2, q);
357        //System.out.println("a  = " + a);
358        //System.out.println("b  = " + b);
359        //System.out.println("c  = " + c);
360        if (a.isZERO() || b.isZERO() || c.isZERO()) {
361            // skip for this turn
362            return;
363        }
364
365        d = a.multiply(a).multiply(b).multiply(b).multiply(c);
366        c = a.multiply(b).multiply(c);
367        //System.out.println("d  = " + d);
368        //System.out.println("c  = " + c);
369
370        c = sqf.squarefreePart(c);
371        d = sqf.squarefreePart(d);
372        //System.out.println("c  = " + c);
373        //System.out.println("d  = " + d);
374        assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
375        assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
376
377        e = PolyUtil.<BigRational> baseSparsePseudoRemainder(d, c);
378        //System.out.println("e  = " + e);
379        assertTrue("squarefree(abc) | squarefree(aabbc) " + e, e.isZERO());
380    }
381
382
383    /**
384     * Test squarefree factors.
385     */
386    public void testSquarefreeFactors() {
387        dfac = new GenPolynomialRing<BigRational>(fac, rl, to, vars);
388
389        a = dfac.random(kl, 3, 2, q);
390        b = dfac.random(kl, 3, 2, q);
391        c = dfac.random(kl, 3, 2, q);
392        //System.out.println("a  = " + a);
393        //System.out.println("b  = " + b);
394        //System.out.println("c  = " + c);
395        if (a.isZERO() || b.isZERO() || c.isZERO()) {
396            // skip for this turn
397            return;
398        }
399
400        d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c);
401        //System.out.println("d  = " + d);
402
403        SortedMap<GenPolynomial<BigRational>, Long> sfactors;
404        sfactors = sqf.squarefreeFactors(d);
405        //System.out.println("sfactors = " + sfactors);
406        assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
407    }
408
409}