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