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