Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.ufd;
006
007
008import java.util.SortedMap;
009
010import edu.jas.arith.ModInteger;
011import edu.jas.arith.ModIntegerRing;
012import edu.jas.kern.ComputerThreads;
013import edu.jas.poly.ExpVector;
014import edu.jas.poly.GenPolynomial;
015import edu.jas.poly.GenPolynomialRing;
016import edu.jas.poly.PolyUtil;
017import edu.jas.poly.TermOrder;
018import edu.jas.structure.Power;
019
020import junit.framework.Test;
021import junit.framework.TestCase;
022import junit.framework.TestSuite;
023
024
025/**
026 * Squarefree factorization ModInteger coefficients tests with JUnit.
027 * @author Heinz Kredel
028 */
029
030public class SquarefreeModTest extends TestCase {
031
032
033    /**
034     * main.
035     */
036    public static void main(String[] args) {
037        junit.textui.TestRunner.run(suite());
038        ComputerThreads.terminate();
039    }
040
041
042    /**
043     * Constructs a <CODE>SquarefreeModTest</CODE> object.
044     * @param name String.
045     */
046    public SquarefreeModTest(String name) {
047        super(name);
048    }
049
050
051    /**
052     */
053    public static Test suite() {
054        TestSuite suite = new TestSuite(SquarefreeModTest.class);
055        return suite;
056    }
057
058
059    TermOrder to = new TermOrder(TermOrder.INVLEX);
060
061
062    int rl = 3;
063
064
065    int kl = 3;
066
067
068    int ll = 4;
069
070
071    int el = 3;
072
073
074    float q = 0.25f;
075
076
077    String[] vars;
078
079
080    String[] cvars;
081
082
083    String[] c1vars;
084
085
086    String[] rvars;
087
088
089    ModIntegerRing fac;
090
091
092    GreatestCommonDivisorAbstract<ModInteger> ufd;
093
094
095    SquarefreeFiniteFieldCharP<ModInteger> sqf;
096
097
098    GenPolynomialRing<ModInteger> dfac;
099
100
101    GenPolynomial<ModInteger> a, b, c, d, e;
102
103
104    GenPolynomialRing<ModInteger> cfac;
105
106
107    GenPolynomialRing<GenPolynomial<ModInteger>> rfac;
108
109
110    GenPolynomial<GenPolynomial<ModInteger>> ar, br, cr, dr, er;
111
112
113    @Override
114    protected void setUp() {
115        vars = ExpVector.STDVARS(rl);
116        cvars = ExpVector.STDVARS(rl - 1);
117        c1vars = new String[] { cvars[0] };
118        rvars = new String[] { vars[rl - 1] };
119
120        fac = new ModIntegerRing(11);
121        //ufd = new GreatestCommonDivisorSubres<ModInteger>();
122        //ufd = GCDFactory.<ModInteger> getImplementation(fac);
123        ufd = GCDFactory.getProxy(fac);
124        sqf = new SquarefreeFiniteFieldCharP<ModInteger>(fac);
125
126        a = b = c = d = e = null;
127        ar = br = cr = dr = er = null;
128    }
129
130
131    @Override
132    protected void tearDown() {
133        a = b = c = d = e = null;
134        ar = br = cr = dr = er = null;
135        //ComputerThreads.terminate();
136    }
137
138
139    /**
140     * Test base squarefree.
141     */
142    public void testBaseSquarefree() {
143        //System.out.println("\nbase:");
144        dfac = new GenPolynomialRing<ModInteger>(fac, 1, to, rvars);
145
146        a = dfac.random(kl, ll, el + 2, q);
147        b = dfac.random(kl, ll, el + 2, q);
148        c = dfac.random(kl, ll, el, q);
149        //System.out.println("a  = " + a);
150        //System.out.println("b  = " + b);
151        //System.out.println("c  = " + c);
152
153        if (a.isZERO() || b.isZERO() || c.isZERO()) {
154            // skip for this turn
155            return;
156        }
157
158        // a a b b b c
159        d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c);
160        c = a.multiply(b).multiply(c);
161        //System.out.println("c  = " + c);
162        //System.out.println("d  = " + d);
163
164        c = sqf.baseSquarefreePart(c);
165        d = sqf.baseSquarefreePart(d);
166        //System.out.println("c  = " + c);
167        //System.out.println("d  = " + d);
168        assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
169        assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
170
171        e = PolyUtil.<ModInteger> baseSparsePseudoRemainder(d, c);
172        //System.out.println("e  = " + e);
173        assertTrue("squarefree(abc) | squarefree(aabbbc) " + e, e.isZERO());
174    }
175
176
177    /**
178     * Test base squarefree factors.
179     */
180    public void testBaseSquarefreeFactors() {
181        dfac = new GenPolynomialRing<ModInteger>(fac, 1, to, rvars);
182
183        a = dfac.random(kl, ll, el + 3, q);
184        b = dfac.random(kl, ll, el + 3, q);
185        c = dfac.random(kl, ll, el + 2, q);
186        //System.out.println("a  = " + a);
187        //System.out.println("b  = " + b);
188        //System.out.println("c  = " + c);
189
190        if (a.isZERO() || b.isZERO() || c.isZERO()) {
191            // skip for this turn
192            return;
193        }
194
195        // a a b b b c
196        d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c);
197        //System.out.println("d  = " + d);
198
199        SortedMap<GenPolynomial<ModInteger>, Long> sfactors;
200        sfactors = sqf.baseSquarefreeFactors(d);
201        //System.out.println("sfactors = " + sfactors);
202        assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
203    }
204
205
206    /**
207     * Test recursive squarefree.
208     */
209    public void testRecursiveSquarefree() {
210        //System.out.println("\nrecursive:");
211        cfac = new GenPolynomialRing<ModInteger>(fac, 2 - 1, to, c1vars);
212        rfac = new GenPolynomialRing<GenPolynomial<ModInteger>>(cfac, 1, to, rvars);
213
214        ar = rfac.random(kl, ll, el, q);
215        br = rfac.random(kl, ll, el, q);
216        cr = rfac.random(kl, ll, el, q);
217        //System.out.println("ar = " + ar);
218        //System.out.println("br = " + br);
219        //System.out.println("cr = " + cr);
220
221        if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
222            // skip for this turn
223            return;
224        }
225
226        dr = ar.multiply(ar).multiply(br).multiply(br);
227        cr = ar.multiply(br);
228        //System.out.println("cr  = " + cr);
229        //System.out.println("dr  = " + dr);
230
231        cr = sqf.recursiveUnivariateSquarefreePart(cr);
232        dr = sqf.recursiveUnivariateSquarefreePart(dr);
233        //System.out.println("cr  = " + cr);
234        //System.out.println("dr  = " + dr);
235        assertTrue("isSquarefree(cr) " + cr, sqf.isRecursiveSquarefree(cr));
236        assertTrue("isSquarefree(dr) " + dr, sqf.isRecursiveSquarefree(dr));
237
238        er = PolyUtil.<ModInteger> recursiveSparsePseudoRemainder(dr, cr);
239        //System.out.println("er  = " + er);
240        assertTrue("squarefree(abc) | squarefree(aabbc) " + er, er.isZERO());
241    }
242
243
244    /**
245     * Test recursive squarefree factors.
246     */
247    public void testRecursiveSquarefreeFactors() {
248        cfac = new GenPolynomialRing<ModInteger>(fac, 2 - 1, to, c1vars);
249        rfac = new GenPolynomialRing<GenPolynomial<ModInteger>>(cfac, 1, to, rvars);
250
251        ar = rfac.random(kl, 3, 2, q);
252        br = rfac.random(kl, 3, 2, q);
253        cr = rfac.random(kl, 3, 2, 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(cr).multiply(br).multiply(br);
264        //System.out.println("dr  = " + dr);
265
266        SortedMap<GenPolynomial<GenPolynomial<ModInteger>>, Long> sfactors;
267        sfactors = sqf.recursiveUnivariateSquarefreeFactors(dr);
268        //System.out.println("sfactors = " + sfactors);
269        assertTrue("isFactorization(d,sfactors) ", sqf.isRecursiveFactorization(dr, sfactors));
270    }
271
272
273    /**
274     * Test squarefree.
275     */
276    public void testSquarefree() {
277        //System.out.println("\nfull:");
278        dfac = new GenPolynomialRing<ModInteger>(fac, rl, to, vars);
279
280        a = dfac.random(kl, ll, 2, q);
281        b = dfac.random(kl, ll, 2, q);
282        c = dfac.random(kl, ll, 2, q);
283        //System.out.println("a  = " + a);
284        //System.out.println("b  = " + b);
285        //System.out.println("c  = " + c);
286
287        if (a.isZERO() || b.isZERO() || c.isZERO()) {
288            // skip for this turn
289            return;
290        }
291
292        d = a.multiply(a).multiply(b).multiply(b).multiply(c);
293        c = a.multiply(b).multiply(c);
294        //System.out.println("c  = " + c);
295        //System.out.println("d  = " + d);
296
297        c = sqf.squarefreePart(c);
298        d = sqf.squarefreePart(d);
299        //System.out.println("c  = " + c);
300        //System.out.println("d  = " + d);
301        assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
302        assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
303
304        e = PolyUtil.<ModInteger> baseSparsePseudoRemainder(d, c);
305        //System.out.println("e  = " + e);
306        assertTrue("squarefree(abc) | squarefree(aabbc) " + e, e.isZERO());
307    }
308
309
310    /**
311     * Test squarefree factors.
312     */
313    public void testSquarefreeFactors() {
314        dfac = new GenPolynomialRing<ModInteger>(fac, rl, to, vars);
315
316        a = dfac.random(kl, 3, 2, q);
317        b = dfac.random(kl, 3, 2, q);
318        c = dfac.random(kl, 3, 2, q);
319        //System.out.println("a  = " + a);
320        //System.out.println("b  = " + b);
321        //System.out.println("c  = " + c);
322
323        if (a.isZERO() || b.isZERO() || c.isZERO()) {
324            // skip for this turn
325            return;
326        }
327
328        d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c);
329        //System.out.println("d  = " + d);
330
331        SortedMap<GenPolynomial<ModInteger>, Long> sfactors;
332        sfactors = sqf.squarefreeFactors(d);
333        //System.out.println("sfactors = " + sfactors);
334        assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
335    }
336
337
338    /* ------------char-th root ------------------------- */
339
340    /**
341     * Test base squarefree with char-th root.
342     */
343    public void testBaseSquarefreeCharRoot() {
344        //System.out.println("\nbase CharRoot:");
345        long p = fac.characteristic().longValue();
346
347        dfac = new GenPolynomialRing<ModInteger>(fac, 1, to, rvars);
348
349        a = dfac.random(kl, ll + 2, el + 2, q);
350        b = dfac.random(kl, ll + 2, el + 2, q);
351        c = dfac.random(kl, ll, el, q);
352
353        if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) {
354            // skip for this turn
355            return;
356        }
357        //System.out.println("a  = " + a);
358        //System.out.println("b  = " + b);
359        //System.out.println("c  = " + c);
360
361        // a a b^p c
362        d = a.multiply(a).multiply(Power.<GenPolynomial<ModInteger>> positivePower(b, p)).multiply(c);
363        c = a.multiply(b).multiply(c);
364        //System.out.println("c  = " + c);
365        //System.out.println("d  = " + d);
366
367        c = sqf.baseSquarefreePart(c);
368        d = sqf.baseSquarefreePart(d);
369        //System.out.println("c  = " + c);
370        //System.out.println("d  = " + d);
371        assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
372        assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
373
374        e = PolyUtil.<ModInteger> baseSparsePseudoRemainder(d, c);
375        //System.out.println("e  = " + e);
376        assertTrue("squarefree(abc) | squarefree(aab^pc) " + e, e.isZERO());
377    }
378
379
380    /**
381     * Test base squarefree factors with char-th root.
382     */
383    public void testBaseSquarefreeFactorsCharRoot() {
384        long p = fac.characteristic().longValue();
385
386        dfac = new GenPolynomialRing<ModInteger>(fac, 1, to, rvars);
387
388        a = dfac.random(kl, ll + 2, el + 3, q);
389        b = dfac.random(kl, ll + 2, el + 3, q);
390        c = dfac.random(kl, ll, el + 2, q);
391
392        if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) {
393            // skip for this turn
394            return;
395        }
396        //System.out.println("a  = " + a);
397        //System.out.println("b  = " + b);
398        //System.out.println("c  = " + c);
399
400        // a a b^p c
401        d = a.multiply(a).multiply(Power.<GenPolynomial<ModInteger>> positivePower(b, p)).multiply(c);
402        //System.out.println("d  = " + d);
403
404        SortedMap<GenPolynomial<ModInteger>, Long> sfactors;
405        sfactors = sqf.baseSquarefreeFactors(d);
406        //System.out.println("sfactors = " + sfactors);
407        assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
408    }
409
410
411    /**
412     * Test recursive squarefree with char-th root.
413     * 
414     */
415    public void testRecursiveSquarefreeCharRoot() {
416        //System.out.println("\nrecursive CharRoot:");
417
418        long p = fac.characteristic().longValue();
419
420        cfac = new GenPolynomialRing<ModInteger>(fac, 2 - 1, to, c1vars);
421        rfac = new GenPolynomialRing<GenPolynomial<ModInteger>>(cfac, 1, to, rvars);
422
423        ar = rfac.random(kl, ll, el + 1, q).monic();
424        br = rfac.random(kl, ll, el + 1, q).monic();
425        cr = rfac.random(kl, ll, el, q).monic();
426
427        if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
428            // skip for this turn
429            return;
430        }
431        //System.out.println("ar = " + ar);
432        //System.out.println("br = " + br);
433        //System.out.println("cr = " + cr);
434
435        // a a b^p 
436        dr = ar.multiply(ar).multiply(Power.<GenPolynomial<GenPolynomial<ModInteger>>> positivePower(br, p));
437        cr = ar.multiply(ar).multiply(br);
438        //System.out.println("cr  = " + cr);
439        //System.out.println("dr  = " + dr);
440
441        cr = sqf.recursiveUnivariateSquarefreePart(cr);
442        dr = sqf.recursiveUnivariateSquarefreePart(dr);
443        //System.out.println("cr  = " + cr);
444        //System.out.println("dr  = " + dr);
445        assertTrue("isSquarefree(cr) " + cr, sqf.isRecursiveSquarefree(cr));
446        assertTrue("isSquarefree(dr) " + dr, sqf.isRecursiveSquarefree(dr));
447
448        er = PolyUtil.<ModInteger> recursiveSparsePseudoRemainder(dr, cr);
449        //System.out.println("er  = " + er);
450        assertTrue("squarefree(abc) | squarefree(aabbc) " + er, er.isZERO());
451    }
452
453
454    /**
455     * Test recursive squarefree factors with char-th root.
456     */
457    public void testRecursiveSquarefreeFactorsCharRoot() {
458        long p = fac.characteristic().longValue();
459
460        cfac = new GenPolynomialRing<ModInteger>(fac, 2 - 1, to, c1vars);
461        rfac = new GenPolynomialRing<GenPolynomial<ModInteger>>(cfac, 1, to, rvars);
462
463        ar = rfac.random(kl, 3, 2 + 1, q).monic();
464        br = rfac.random(kl, 3, 2 + 1, q).monic();
465        cr = rfac.random(kl, 3, 2, q).monic();
466
467        if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
468            // skip for this turn
469            return;
470        }
471        //System.out.println("ar = " + ar);
472        //System.out.println("br = " + br);
473        //System.out.println("cr = " + cr);
474
475        // a a b^p c
476        dr = ar.multiply(ar).multiply(Power.<GenPolynomial<GenPolynomial<ModInteger>>> positivePower(br, p))
477                        .multiply(cr);
478        //System.out.println("dr  = " + dr);
479
480        SortedMap<GenPolynomial<GenPolynomial<ModInteger>>, Long> sfactors;
481        sfactors = sqf.recursiveUnivariateSquarefreeFactors(dr);
482        //System.out.println("sfactors = " + sfactors);
483        assertTrue("isFactorization(d,sfactors) ", sqf.isRecursiveFactorization(dr, sfactors));
484    }
485
486
487    /**
488     * Test squarefree with char-th root.
489     */
490    public void testSquarefreeCharRoot() {
491        //System.out.println("\nfull CharRoot:");
492        long p = fac.characteristic().longValue();
493
494        dfac = new GenPolynomialRing<ModInteger>(fac, rl, to, vars);
495
496        a = dfac.random(kl, ll, 3, q).monic();
497        b = dfac.random(kl, ll, 3, q).monic();
498        c = dfac.random(kl, ll, 3, q).monic();
499
500        if (a.isZERO() || b.isZERO() || c.isZERO()) {
501            // skip for this turn
502            return;
503        }
504        //System.out.println("a  = " + a);
505        //System.out.println("b  = " + b);
506        //System.out.println("c  = " + c);
507
508        // a a b^p c
509        d = a.multiply(a).multiply(Power.<GenPolynomial<ModInteger>> positivePower(b, p)).multiply(c);
510        c = a.multiply(b).multiply(c);
511        //System.out.println("c  = " + c);
512        //System.out.println("d  = " + d);
513
514        c = sqf.squarefreePart(c);
515        d = sqf.squarefreePart(d);
516        //System.out.println("c  = " + c);
517        //System.out.println("d  = " + d);
518        assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
519        assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
520
521        e = PolyUtil.<ModInteger> baseSparsePseudoRemainder(d, c);
522        //System.out.println("e  = " + e);
523        assertTrue("squarefree(abc) | squarefree(aab^pc) " + e, e.isZERO());
524    }
525
526
527    /**
528     * Test squarefree factors with char-th root.
529     */
530    public void testSquarefreeFactorsCharRoot() {
531        long p = fac.characteristic().longValue();
532
533        dfac = new GenPolynomialRing<ModInteger>(fac, rl, to, vars);
534
535        a = dfac.random(kl, ll, 3, q).monic();
536        b = dfac.random(kl, ll, 3, q).monic();
537        c = dfac.random(kl, ll, 3, q).monic();
538
539        if (a.isZERO() || b.isZERO() || c.isZERO()) {
540            // skip for this turn
541            return;
542        }
543        //System.out.println("a  = " + a);
544        //System.out.println("b  = " + b);
545        //System.out.println("c  = " + c);
546
547        // a a b^p c
548        d = a.multiply(a).multiply(Power.<GenPolynomial<ModInteger>> positivePower(b, p)).multiply(c);
549        //System.out.println("d  = " + d);
550
551        SortedMap<GenPolynomial<ModInteger>, Long> sfactors;
552        sfactors = sqf.squarefreeFactors(d);
553        //System.out.println("sfactors = " + sfactors);
554        assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
555    }
556
557}