001/*
002 * $Id: SquarefreeAlgModTest.java 4019 2012-07-22 18:31:13Z 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.ModInteger;
015import edu.jas.arith.ModIntegerRing;
016import edu.jas.kern.ComputerThreads;
017import edu.jas.poly.AlgebraicNumber;
018import edu.jas.poly.AlgebraicNumberRing;
019import edu.jas.poly.ExpVector;
020import edu.jas.poly.GenPolynomial;
021import edu.jas.poly.GenPolynomialRing;
022import edu.jas.poly.PolyUtil;
023import edu.jas.poly.TermOrder;
024import edu.jas.structure.Power;
025
026
027/**
028 * Squarefree factorization tests with JUnit.
029 * @author Heinz Kredel.
030 */
031
032public class SquarefreeAlgModTest extends TestCase {
033
034
035    /**
036     * main.
037     */
038    public static void main(String[] args) {
039        //BasicConfigurator.configure();
040        junit.textui.TestRunner.run(suite());
041        ComputerThreads.terminate();
042    }
043
044
045    /**
046     * Constructs a <CODE>SquarefreeAlgModTest</CODE> object.
047     * @param name String.
048     */
049    public SquarefreeAlgModTest(String name) {
050        super(name);
051    }
052
053
054    /**
055     */
056    public static Test suite() {
057        TestSuite suite = new TestSuite(SquarefreeAlgModTest.class);
058        return suite;
059    }
060
061
062    TermOrder to = new TermOrder(TermOrder.INVLEX);
063
064
065    //long p = 11L;
066    long p = 7L;
067
068
069    long qp;
070
071
072    int rl = 3;
073
074
075    int kl = 3;
076
077
078    int ll = 4;
079
080
081    int el = 3;
082
083
084    float q = 0.25f;
085
086
087    String[] vars;
088
089
090    String[] cvars;
091
092
093    String[] c1vars;
094
095
096    String[] rvars;
097
098
099    ModIntegerRing mfac;
100
101
102    String[] alpha;
103
104
105    GenPolynomialRing<ModInteger> mpfac;
106
107
108    GenPolynomial<ModInteger> agen;
109
110
111    AlgebraicNumberRing<ModInteger> fac;
112
113
114    GreatestCommonDivisorAbstract<AlgebraicNumber<ModInteger>> ufd;
115
116
117    SquarefreeFiniteFieldCharP<AlgebraicNumber<ModInteger>> sqf;
118
119
120    GenPolynomialRing<AlgebraicNumber<ModInteger>> dfac;
121
122
123    GenPolynomial<AlgebraicNumber<ModInteger>> a;
124
125
126    GenPolynomial<AlgebraicNumber<ModInteger>> b;
127
128
129    GenPolynomial<AlgebraicNumber<ModInteger>> c;
130
131
132    GenPolynomial<AlgebraicNumber<ModInteger>> d;
133
134
135    GenPolynomial<AlgebraicNumber<ModInteger>> e;
136
137
138    GenPolynomialRing<AlgebraicNumber<ModInteger>> cfac;
139
140
141    GenPolynomialRing<GenPolynomial<AlgebraicNumber<ModInteger>>> rfac;
142
143
144    GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>> ar;
145
146
147    GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>> br;
148
149
150    GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>> cr;
151
152
153    GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>> dr;
154
155
156    GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>> er;
157
158
159    @Override
160    protected void setUp() {
161        vars = ExpVector.STDVARS(rl);
162        cvars = ExpVector.STDVARS(rl - 1);
163        c1vars = new String[] { cvars[0] };
164        rvars = new String[] { vars[rl - 1] };
165
166        mfac = new ModIntegerRing(p);
167        alpha = new String[] { "alpha" };
168        mpfac = new GenPolynomialRing<ModInteger>(mfac, 1, to, alpha);
169        agen = mpfac.univariate(0, 2);
170        agen = agen.sum(mpfac.getONE()); // x^2 + 1, is irred mod 7, 11, 19
171        fac = new AlgebraicNumberRing<ModInteger>(agen, true);
172        qp = 1L;
173        for (int i = 0; i < agen.degree(0); i++) {
174            qp = qp * p;
175        }
176        //System.out.println("p = " + p + ", qp = " + qp);
177
178        //ufd = new GreatestCommonDivisorSubres<AlgebraicNumber<ModInteger>>();
179        //ufd = GCDFactory.<AlgebraicNumber<ModInteger>> getImplementation(fac);
180        ufd = GCDFactory.<AlgebraicNumber<ModInteger>> getProxy(fac);
181
182        sqf = new SquarefreeFiniteFieldCharP<AlgebraicNumber<ModInteger>>(fac);
183
184        SquarefreeAbstract<AlgebraicNumber<ModInteger>> sqff = SquarefreeFactory.getImplementation(fac);
185        //System.out.println("sqf  = " + sqf);
186        //System.out.println("sqff = " + sqff);
187        assertEquals("sqf == sqff ", sqf.getClass(), sqff.getClass());
188
189        a = b = c = d = e = null;
190        ar = br = cr = dr = er = null;
191    }
192
193
194    @Override
195    protected void tearDown() {
196        a = b = c = d = e = null;
197        ar = br = cr = dr = er = null;
198        //ComputerThreads.terminate();
199    }
200
201
202    /**
203     * Test base squarefree.
204     * 
205     */
206    public void testBaseSquarefree() {
207        //System.out.println("\nbase:");
208
209        dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars);
210
211        a = dfac.random(kl, ll, el + 2, q);
212        b = dfac.random(kl, ll, el + 2, q);
213        c = dfac.random(kl, ll, el, q);
214        //System.out.println("a  = " + a);
215        //System.out.println("b  = " + b);
216        //System.out.println("c  = " + c);
217
218        if (a.isZERO() || b.isZERO() || c.isZERO()) {
219            // skip for this turn
220            return;
221        }
222
223        // a a b b b c
224        d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c);
225        c = a.multiply(b).multiply(c);
226        //System.out.println("c  = " + c);
227        //System.out.println("d  = " + d);
228
229        c = sqf.baseSquarefreePart(c);
230        d = sqf.baseSquarefreePart(d);
231        //System.out.println("c  = " + c);
232        //System.out.println("d  = " + d);
233        assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
234        assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
235
236        e = PolyUtil.<AlgebraicNumber<ModInteger>> basePseudoRemainder(d, c);
237        //System.out.println("e  = " + e);
238        assertTrue("squarefree(abc) | squarefree(aabbbc) " + e, e.isZERO());
239    }
240
241
242    /**
243     * Test base squarefree factors.
244     * 
245     */
246    public void testBaseSquarefreeFactors() {
247
248        dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars);
249
250        a = dfac.random(kl, ll, el + 3, q);
251        b = dfac.random(kl, ll, el + 3, q);
252        c = dfac.random(kl, ll, el + 2, q);
253        //System.out.println("a  = " + a);
254        //System.out.println("b  = " + b);
255        //System.out.println("c  = " + c);
256
257        if (a.isZERO() || b.isZERO() || c.isZERO()) {
258            // skip for this turn
259            return;
260        }
261
262        // a a b b b c
263        d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c);
264        //System.out.println("d  = " + d);
265
266        SortedMap<GenPolynomial<AlgebraicNumber<ModInteger>>, Long> sfactors;
267        sfactors = sqf.baseSquarefreeFactors(d);
268        //System.out.println("sfactors = " + sfactors);
269        assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
270    }
271
272
273    /**
274     * Test recursive squarefree.
275     * 
276     */
277    public void testRecursiveSquarefree() {
278        //System.out.println("\nrecursive:");
279
280        cfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 2 - 1, to, c1vars);
281        rfac = new GenPolynomialRing<GenPolynomial<AlgebraicNumber<ModInteger>>>(cfac, 1, to, rvars);
282
283        ar = rfac.random(kl, ll, el, q);
284        br = rfac.random(kl, ll, el, q);
285        cr = rfac.random(kl, ll, el, q);
286        //System.out.println("ar = " + ar);
287        //System.out.println("br = " + br);
288        //System.out.println("cr = " + cr);
289
290        if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
291            // skip for this turn
292            return;
293        }
294
295        dr = ar.multiply(ar).multiply(br).multiply(br);
296        cr = ar.multiply(br);
297        //System.out.println("cr  = " + cr);
298        //System.out.println("dr  = " + dr);
299
300        cr = sqf.recursiveUnivariateSquarefreePart(cr);
301        dr = sqf.recursiveUnivariateSquarefreePart(dr);
302        //System.out.println("cr  = " + cr);
303        //System.out.println("dr  = " + dr);
304        assertTrue("isSquarefree(cr) " + cr, sqf.isRecursiveSquarefree(cr));
305        assertTrue("isSquarefree(dr) " + dr, sqf.isRecursiveSquarefree(dr));
306
307        er = PolyUtil.<AlgebraicNumber<ModInteger>> recursivePseudoRemainder(dr, cr);
308        //System.out.println("er  = " + er);
309        assertTrue("squarefree(abc) | squarefree(aabbc) " + er, er.isZERO());
310    }
311
312
313    /**
314     * Test recursive squarefree factors.
315     * 
316     */
317    public void testRecursiveSquarefreeFactors() {
318
319        cfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 2 - 1, to, c1vars);
320        rfac = new GenPolynomialRing<GenPolynomial<AlgebraicNumber<ModInteger>>>(cfac, 1, to, rvars);
321
322        ar = rfac.random(kl, 3, 2, q);
323        br = rfac.random(kl, 3, 2, q);
324        cr = rfac.random(kl, 3, 2, q);
325        //System.out.println("ar = " + ar);
326        //System.out.println("br = " + br);
327        //System.out.println("cr = " + cr);
328
329        if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
330            // skip for this turn
331            return;
332        }
333
334        dr = ar.multiply(cr).multiply(br).multiply(br);
335        //System.out.println("dr  = " + dr);
336
337        SortedMap<GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>>, Long> sfactors;
338        sfactors = sqf.recursiveUnivariateSquarefreeFactors(dr);
339        //System.out.println("sfactors = " + sfactors);
340
341        assertTrue("isFactorization(d,sfactors) ", sqf.isRecursiveFactorization(dr, sfactors));
342    }
343
344
345    /**
346     * Test squarefree.
347     * 
348     */
349    public void testSquarefree() {
350        //System.out.println("\nfull:");
351
352        dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, rl, to, vars);
353
354        a = dfac.random(kl, 3, 2, q);
355        b = dfac.random(kl, 3, 2, q);
356        c = dfac.random(kl, 3, 2, q);
357        //System.out.println("a  = " + a);
358        //System.out.println("b  = " + b);
359        //System.out.println("c  = " + c);
360
361        if (a.isZERO() || b.isZERO() || c.isZERO()) {
362            // skip for this turn
363            return;
364        }
365
366        d = a.multiply(a).multiply(b).multiply(b).multiply(c);
367        c = a.multiply(b).multiply(c);
368        //System.out.println("c  = " + c);
369        //System.out.println("d  = " + d);
370
371        c = sqf.squarefreePart(c);
372        d = sqf.squarefreePart(d);
373        //System.out.println("c  = " + c);
374        //System.out.println("d  = " + d);
375        assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
376        assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
377
378        e = PolyUtil.<AlgebraicNumber<ModInteger>> basePseudoRemainder(d, c);
379        //System.out.println("e  = " + e);
380        assertTrue("squarefree(abc) | squarefree(aabbc) " + e, e.isZERO());
381    }
382
383
384    /**
385     * Test squarefree factors.
386     * 
387     */
388    public void testSquarefreeFactors() {
389
390        dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, rl, to, vars);
391
392        a = dfac.random(kl, 3, 2, q);
393        b = dfac.random(kl, 3, 2, q);
394        c = dfac.random(kl, 3, 2, q);
395        //System.out.println("a  = " + a);
396        //System.out.println("b  = " + b);
397        //System.out.println("c  = " + c);
398
399        if (a.isZERO() || b.isZERO() || c.isZERO()) {
400            // skip for this turn
401            return;
402        }
403
404        d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c);
405        //System.out.println("d  = " + d);
406
407        SortedMap<GenPolynomial<AlgebraicNumber<ModInteger>>, Long> sfactors;
408        sfactors = sqf.squarefreeFactors(d);
409        //System.out.println("sfactors = " + sfactors);
410        assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
411    }
412
413
414    /* ------------char-th root ------------------------- */
415
416
417    /**
418     * Test base squarefree with char-th root.
419     * 
420     */
421    public void testBaseSquarefreeCharRoot() {
422        //System.out.println("\nbase CharRoot:");
423
424        long p = fac.characteristic().longValue();
425
426        //dfac = new GenPolynomialRing<ModInteger>(fac,1,to,rvars);
427        dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars);
428
429        a = dfac.random(kl, ll + 1, el + 1, q).monic();
430        b = dfac.random(kl, ll + 1, el + 1, q).monic();
431        c = dfac.random(kl, ll, el, q).monic();
432
433        if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) {
434            // skip for this turn
435            return;
436        }
437        //System.out.println("a  = " + a);
438        //System.out.println("b  = " + b);
439        //System.out.println("c  = " + c);
440
441        e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, p);
442        //System.out.println("b^p  = " + e);
443        // a a b^p c
444        d = a.multiply(a).multiply(e).multiply(c);
445        c = a.multiply(b).multiply(c);
446        //System.out.println("c  = " + c);
447        //System.out.println("d  = " + d);
448
449        c = sqf.baseSquarefreePart(c);
450        d = sqf.baseSquarefreePart(d);
451        //System.out.println("c  = " + c);
452        //System.out.println("d  = " + d);
453        assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
454        assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
455
456        e = PolyUtil.<AlgebraicNumber<ModInteger>> basePseudoRemainder(d, c);
457        //System.out.println("e  = " + e);
458        assertTrue("squarefree(abc) | squarefree(aab^pc) " + e, e.isZERO());
459    }
460
461
462    /**
463     * Test base squarefree factors with char-th root.
464     * 
465     */
466    public void testBaseSquarefreeFactorsCharRoot() {
467
468        long p = fac.characteristic().longValue();
469
470        //dfac = new GenPolynomialRing<ModInteger>(fac,1,to,rvars);
471        dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars);
472
473        a = dfac.random(kl, ll + 1, el + 2, q).monic();
474        b = dfac.random(kl, ll + 1, el + 2, q).monic();
475        c = dfac.random(kl, ll, el + 1, q).monic();
476
477        if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) {
478            // skip for this turn
479            return;
480        }
481        //System.out.println("a  = " + a);
482        //System.out.println("b  = " + b);
483        //System.out.println("c  = " + c);
484
485        e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, p);
486        //System.out.println("b^p  = " + e);
487        // a a b^p 
488        d = a.multiply(a).multiply(e);
489        //d = d.monic();
490        //System.out.println("d  = " + d);
491
492        SortedMap<GenPolynomial<AlgebraicNumber<ModInteger>>, Long> sfactors;
493        sfactors = sqf.baseSquarefreeFactors(d);
494        //System.out.println("sfactors = " + sfactors);
495        assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
496    }
497
498
499    /**
500     * Test base squarefree with char-th root, two times.
501     * 
502     */
503    public void testBaseSquarefreeCharRoot2() {
504        //System.out.println("\nbase CharRoot 2:");
505        //long p = fac.characteristic().longValue();
506
507        //dfac = new GenPolynomialRing<ModInteger>(fac,1,to,rvars);
508        dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars);
509
510        a = dfac.random(kl, ll + 1, el + 1, q).monic();
511        b = dfac.random(kl, ll + 1, el + 1, q).monic();
512        c = dfac.random(kl, ll, el, q).monic();
513
514        if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) {
515            // skip for this turn
516            return;
517        }
518        //System.out.println("a  = " + a);
519        //System.out.println("b  = " + b);
520        //System.out.println("c  = " + c);
521
522        e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, qp);
523        //System.out.println("b^qp  = " + e);
524        // a a b^qp c
525        d = a.multiply(a).multiply(e).multiply(c);
526        c = a.multiply(b).multiply(c);
527        //System.out.println("c  = " + c);
528        //System.out.println("d  = " + d);
529
530        c = sqf.baseSquarefreePart(c);
531        d = sqf.baseSquarefreePart(d);
532        //System.out.println("c  = " + c);
533        //System.out.println("d  = " + d);
534        assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
535        assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
536
537        e = PolyUtil.<AlgebraicNumber<ModInteger>> basePseudoRemainder(d, c);
538        //System.out.println("e  = " + e);
539        assertTrue("squarefree(abc) | squarefree(aab^pc) " + e, e.isZERO());
540    }
541
542
543    /**
544     * Test base squarefree factors with char-th root, two times.
545     * 
546     */
547    public void testBaseSquarefreeFactorsCharRoot2() {
548        //long p = fac.characteristic().longValue();
549
550        //dfac = new GenPolynomialRing<ModInteger>(fac,1,to,rvars);
551        dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars);
552
553        a = dfac.random(kl, ll + 1, el + 2, q).monic();
554        b = dfac.random(kl, ll + 1, el + 2, q).monic();
555        c = dfac.random(kl, ll, el + 2, q).monic();
556
557        if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) {
558            // skip for this turn
559            return;
560        }
561        //System.out.println("a  = " + a);
562        //System.out.println("b  = " + b);
563        //System.out.println("c  = " + c);
564
565        e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, qp);
566        //System.out.println("b^qp  = " + e);
567        // a a b^qp 
568        d = a.multiply(a).multiply(e);
569        //d = d.monic();
570        //System.out.println("d  = " + d);
571
572        SortedMap<GenPolynomial<AlgebraicNumber<ModInteger>>, Long> sfactors;
573        sfactors = sqf.baseSquarefreeFactors(d);
574        //System.out.println("sfactors = " + sfactors);
575        assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
576    }
577
578
579    /**
580     * Test recursive squarefree with char-th root.
581     * 
582     */
583    public void testRecursiveSquarefreeCharRoot() {
584        //System.out.println("\nrecursive CharRoot:");
585
586        long p = fac.characteristic().longValue();
587
588        cfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 2 - 1, to, c1vars);
589        rfac = new GenPolynomialRing<GenPolynomial<AlgebraicNumber<ModInteger>>>(cfac, 1, to, rvars);
590
591        ar = rfac.random(kl, 3, el, q);
592        br = rfac.random(kl, 3, el, q);
593        cr = rfac.random(kl, 3, el, q);
594        //cr = rfac.getONE();
595
596        if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
597            // skip for this turn
598            return;
599        }
600        //ar = PolyUtil.<AlgebraicNumber<ModInteger>>monic(ar);
601        //br = PolyUtil.<AlgebraicNumber<ModInteger>>monic(br);
602        //cr = PolyUtil.<AlgebraicNumber<ModInteger>>monic(cr);
603        //System.out.println("ar = " + ar);
604        //System.out.println("br = " + br);
605        //System.out.println("cr = " + cr);
606
607        er = Power.<GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>>> positivePower(br, p);
608        //System.out.println("b^p  = " + er);
609        // a a b^p c
610        dr = ar.multiply(ar).multiply(er).multiply(cr);
611        cr = ar.multiply(br).multiply(cr);
612        //System.out.println("cr  = " + cr);
613        //System.out.println("dr  = " + dr);
614
615        cr = sqf.recursiveUnivariateSquarefreePart(cr);
616        dr = sqf.recursiveUnivariateSquarefreePart(dr);
617        //System.out.println("cr  = " + cr);
618        //System.out.println("dr  = " + dr);
619        assertTrue("isSquarefree(cr) " + cr, sqf.isRecursiveSquarefree(cr));
620        assertTrue("isSquarefree(dr) " + dr, sqf.isRecursiveSquarefree(dr));
621
622        er = PolyUtil.<AlgebraicNumber<ModInteger>> recursivePseudoRemainder(dr, cr);
623        //System.out.println("er  = " + er);
624        assertTrue("squarefree(abc) | squarefree(aabbc) " + er, er.isZERO());
625    }
626
627
628    /**
629     * Test recursive squarefree factors with char-th root.
630     * 
631     */
632    public void testRecursiveSquarefreeFactorsCharRoot() {
633
634        long p = fac.characteristic().longValue();
635
636        cfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 2 - 1, to, c1vars);
637        rfac = new GenPolynomialRing<GenPolynomial<AlgebraicNumber<ModInteger>>>(cfac, 1, to, rvars);
638
639        ar = rfac.random(kl, 3, 2, q);
640        br = rfac.random(kl, 3, 2, q);
641        cr = rfac.random(kl, 3, 2, q);
642        //cr = rfac.getONE();
643
644        if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
645            // skip for this turn
646            return;
647        }
648        //ar = PolyUtil.<AlgebraicNumber<ModInteger>>monic(ar);
649        //br = PolyUtil.<AlgebraicNumber<ModInteger>>monic(br);
650        //cr = PolyUtil.<AlgebraicNumber<ModInteger>>monic(cr);
651        //System.out.println("ar = " + ar);
652        //System.out.println("br = " + br);
653        //System.out.println("cr = " + cr);
654
655        er = Power.<GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>>> positivePower(br, p);
656        //System.out.println("b^p  = " + er);
657        // a a b^p c
658        dr = ar.multiply(ar).multiply(er).multiply(cr);
659        //System.out.println("dr  = " + dr);
660
661        SortedMap<GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>>, Long> sfactors;
662        sfactors = sqf.recursiveUnivariateSquarefreeFactors(dr);
663        //System.out.println("sfactors = " + sfactors);
664
665        assertTrue("isFactorization(d,sfactors) ", sqf.isRecursiveFactorization(dr, sfactors));
666    }
667
668
669    /**
670     * Test squarefree with char-th root.
671     * 
672     */
673    public void testSquarefreeCharRoot() {
674        //System.out.println("\nfull CharRoot:");
675
676        long p = fac.characteristic().longValue();
677
678        dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, rl, to, vars);
679
680        a = dfac.random(kl, 3, 3, q);
681        b = dfac.random(kl, 3, 3, q);
682        c = dfac.random(kl, 3, 3, q);
683        //c = dfac.getONE();
684
685        if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) {
686            // skip for this turn
687            return;
688        }
689        //a = a.monic();
690        //b = b.monic();
691        //c = c.monic();
692        //System.out.println("a  = " + a);
693        //System.out.println("b  = " + b);
694        //System.out.println("c  = " + c);
695
696        e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, p);
697        //System.out.println("b^p  = " + e);
698        // a a b^p c
699        d = a.multiply(a).multiply(e).multiply(c);
700        c = a.multiply(b).multiply(c);
701        //System.out.println("c  = " + c);
702        //System.out.println("d  = " + d);
703
704        c = sqf.squarefreePart(c);
705        d = sqf.squarefreePart(d);
706        //System.out.println("c  = " + c);
707        //System.out.println("d  = " + d);
708        assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
709        assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
710
711        e = PolyUtil.<AlgebraicNumber<ModInteger>> basePseudoRemainder(d, c);
712        //System.out.println("e  = " + e);
713        assertTrue("squarefree(abc) | squarefree(aab^pc) " + e, e.isZERO());
714    }
715
716
717    /**
718     * Test squarefree factors with char-th root.
719     * 
720     */
721    public void testSquarefreeFactorsCharRoot() {
722
723        long p = fac.characteristic().longValue();
724
725        dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, rl, to, vars);
726
727        a = dfac.random(kl, 3, 3, q);
728        b = dfac.random(kl, 3, 3, q);
729        c = dfac.random(kl, 3, 3, q);
730        //c = dfac.getONE();
731
732        if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) {
733            // skip for this turn
734            return;
735        }
736        //a = a.monic();
737        //b = b.monic();
738        //c = c.monic();
739        //System.out.println("a  = " + a);
740        //System.out.println("b  = " + b);
741        //System.out.println("c  = " + c);
742
743        e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, p);
744        //System.out.println("b^p  = " + e);
745        // a a b^p c
746        d = a.multiply(a).multiply(e).multiply(c);
747        //System.out.println("d  = " + d);
748
749        SortedMap<GenPolynomial<AlgebraicNumber<ModInteger>>, Long> sfactors;
750        sfactors = sqf.squarefreeFactors(d);
751        //System.out.println("sfactors = " + sfactors);
752
753        assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
754    }
755
756}