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