001 /*
002 * $Id: SquarefreeAlgModTest.java 2933 2009-12-29 13:13:34Z kredel $
003 */
004
005 package edu.jas.ufd;
006
007
008 import java.util.SortedMap;
009
010 import junit.framework.Test;
011 import junit.framework.TestCase;
012 import junit.framework.TestSuite;
013
014 import edu.jas.arith.ModInteger;
015 import edu.jas.arith.ModIntegerRing;
016 import edu.jas.kern.ComputerThreads;
017 import edu.jas.poly.AlgebraicNumber;
018 import edu.jas.poly.AlgebraicNumberRing;
019 import edu.jas.poly.ExpVector;
020 import edu.jas.poly.GenPolynomial;
021 import edu.jas.poly.GenPolynomialRing;
022 import edu.jas.poly.PolyUtil;
023 import edu.jas.poly.TermOrder;
024 import edu.jas.structure.Power;
025
026
027 /**
028 * Squarefree factorization tests with JUnit.
029 * @author Heinz Kredel.
030 */
031
032 public 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
506 long p = fac.characteristic().longValue();
507
508 //dfac = new GenPolynomialRing<ModInteger>(fac,1,to,rvars);
509 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars);
510
511 a = dfac.random(kl, ll + 1, el + 1, q).monic();
512 b = dfac.random(kl, ll + 1, el + 1, q).monic();
513 c = dfac.random(kl, ll, el, q).monic();
514
515 if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) {
516 // skip for this turn
517 return;
518 }
519 //System.out.println("a = " + a);
520 //System.out.println("b = " + b);
521 //System.out.println("c = " + c);
522
523 e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, qp);
524 //System.out.println("b^qp = " + e);
525 // a a b^qp c
526 d = a.multiply(a).multiply(e).multiply(c);
527 c = a.multiply(b).multiply(c);
528 //System.out.println("c = " + c);
529 //System.out.println("d = " + d);
530
531 c = sqf.baseSquarefreePart(c);
532 d = sqf.baseSquarefreePart(d);
533 //System.out.println("c = " + c);
534 //System.out.println("d = " + d);
535 assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
536 assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
537
538 e = PolyUtil.<AlgebraicNumber<ModInteger>> basePseudoRemainder(d, c);
539 //System.out.println("e = " + e);
540 assertTrue("squarefree(abc) | squarefree(aab^pc) " + e, e.isZERO());
541 }
542
543
544 /**
545 * Test base squarefree factors with char-th root, two times.
546 *
547 */
548 public void testBaseSquarefreeFactorsCharRoot2() {
549
550 long p = fac.characteristic().longValue();
551
552 //dfac = new GenPolynomialRing<ModInteger>(fac,1,to,rvars);
553 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars);
554
555 a = dfac.random(kl, ll + 1, el + 2, q).monic();
556 b = dfac.random(kl, ll + 1, el + 2, q).monic();
557 c = dfac.random(kl, ll, el + 2, q).monic();
558
559 if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) {
560 // skip for this turn
561 return;
562 }
563 //System.out.println("a = " + a);
564 //System.out.println("b = " + b);
565 //System.out.println("c = " + c);
566
567 e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, qp);
568 //System.out.println("b^qp = " + e);
569 // a a b^qp
570 d = a.multiply(a).multiply(e);
571 //d = d.monic();
572 //System.out.println("d = " + d);
573
574 SortedMap<GenPolynomial<AlgebraicNumber<ModInteger>>, Long> sfactors;
575 sfactors = sqf.baseSquarefreeFactors(d);
576 //System.out.println("sfactors = " + sfactors);
577 assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
578 }
579
580
581 /**
582 * Test recursive squarefree with char-th root.
583 *
584 */
585 public void testRecursiveSquarefreeCharRoot() {
586 //System.out.println("\nrecursive CharRoot:");
587
588 long p = fac.characteristic().longValue();
589
590 cfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 2 - 1, to, c1vars);
591 rfac = new GenPolynomialRing<GenPolynomial<AlgebraicNumber<ModInteger>>>(cfac, 1, to, rvars);
592
593 ar = rfac.random(kl, 3, el, q);
594 br = rfac.random(kl, 3, el, q);
595 cr = rfac.random(kl, 3, el, q);
596 //cr = rfac.getONE();
597
598 if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
599 // skip for this turn
600 return;
601 }
602 //ar = PolyUtil.<AlgebraicNumber<ModInteger>>monic(ar);
603 //br = PolyUtil.<AlgebraicNumber<ModInteger>>monic(br);
604 //cr = PolyUtil.<AlgebraicNumber<ModInteger>>monic(cr);
605 //System.out.println("ar = " + ar);
606 //System.out.println("br = " + br);
607 //System.out.println("cr = " + cr);
608
609 er = Power.<GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>>> positivePower(br, p);
610 //System.out.println("b^p = " + er);
611 // a a b^p c
612 dr = ar.multiply(ar).multiply(er).multiply(cr);
613 cr = ar.multiply(br).multiply(cr);
614 //System.out.println("cr = " + cr);
615 //System.out.println("dr = " + dr);
616
617 cr = sqf.recursiveUnivariateSquarefreePart(cr);
618 dr = sqf.recursiveUnivariateSquarefreePart(dr);
619 //System.out.println("cr = " + cr);
620 //System.out.println("dr = " + dr);
621 assertTrue("isSquarefree(cr) " + cr, sqf.isRecursiveSquarefree(cr));
622 assertTrue("isSquarefree(dr) " + dr, sqf.isRecursiveSquarefree(dr));
623
624 er = PolyUtil.<AlgebraicNumber<ModInteger>> recursivePseudoRemainder(dr, cr);
625 //System.out.println("er = " + er);
626 assertTrue("squarefree(abc) | squarefree(aabbc) " + er, er.isZERO());
627 }
628
629
630 /**
631 * Test recursive squarefree factors with char-th root.
632 *
633 */
634 public void testRecursiveSquarefreeFactorsCharRoot() {
635
636 long p = fac.characteristic().longValue();
637
638 cfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 2 - 1, to, c1vars);
639 rfac = new GenPolynomialRing<GenPolynomial<AlgebraicNumber<ModInteger>>>(cfac, 1, to, rvars);
640
641 ar = rfac.random(kl, 3, 2, q);
642 br = rfac.random(kl, 3, 2, q);
643 cr = rfac.random(kl, 3, 2, q);
644 //cr = rfac.getONE();
645
646 if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
647 // skip for this turn
648 return;
649 }
650 //ar = PolyUtil.<AlgebraicNumber<ModInteger>>monic(ar);
651 //br = PolyUtil.<AlgebraicNumber<ModInteger>>monic(br);
652 //cr = PolyUtil.<AlgebraicNumber<ModInteger>>monic(cr);
653 //System.out.println("ar = " + ar);
654 //System.out.println("br = " + br);
655 //System.out.println("cr = " + cr);
656
657 er = Power.<GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>>> positivePower(br, p);
658 //System.out.println("b^p = " + er);
659 // a a b^p c
660 dr = ar.multiply(ar).multiply(er).multiply(cr);
661 //System.out.println("dr = " + dr);
662
663 SortedMap<GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>>, Long> sfactors;
664 sfactors = sqf.recursiveUnivariateSquarefreeFactors(dr);
665 //System.out.println("sfactors = " + sfactors);
666
667 assertTrue("isFactorization(d,sfactors) ", sqf.isRecursiveFactorization(dr, sfactors));
668 }
669
670
671 /**
672 * Test squarefree with char-th root.
673 *
674 */
675 public void testSquarefreeCharRoot() {
676 //System.out.println("\nfull CharRoot:");
677
678 long p = fac.characteristic().longValue();
679
680 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, rl, to, vars);
681
682 a = dfac.random(kl, 3, 3, q);
683 b = dfac.random(kl, 3, 3, q);
684 c = dfac.random(kl, 3, 3, q);
685 //c = dfac.getONE();
686
687 if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) {
688 // skip for this turn
689 return;
690 }
691 //a = a.monic();
692 //b = b.monic();
693 //c = c.monic();
694 //System.out.println("a = " + a);
695 //System.out.println("b = " + b);
696 //System.out.println("c = " + c);
697
698 e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, p);
699 //System.out.println("b^p = " + e);
700 // a a b^p c
701 d = a.multiply(a).multiply(e).multiply(c);
702 c = a.multiply(b).multiply(c);
703 //System.out.println("c = " + c);
704 //System.out.println("d = " + d);
705
706 c = sqf.squarefreePart(c);
707 d = sqf.squarefreePart(d);
708 //System.out.println("c = " + c);
709 //System.out.println("d = " + d);
710 assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d));
711 assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c));
712
713 e = PolyUtil.<AlgebraicNumber<ModInteger>> basePseudoRemainder(d, c);
714 //System.out.println("e = " + e);
715 assertTrue("squarefree(abc) | squarefree(aab^pc) " + e, e.isZERO());
716 }
717
718
719 /**
720 * Test squarefree factors with char-th root.
721 *
722 */
723 public void testSquarefreeFactorsCharRoot() {
724
725 long p = fac.characteristic().longValue();
726
727 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, rl, to, vars);
728
729 a = dfac.random(kl, 3, 3, q);
730 b = dfac.random(kl, 3, 3, q);
731 c = dfac.random(kl, 3, 3, q);
732 //c = dfac.getONE();
733
734 if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) {
735 // skip for this turn
736 return;
737 }
738 //a = a.monic();
739 //b = b.monic();
740 //c = c.monic();
741 //System.out.println("a = " + a);
742 //System.out.println("b = " + b);
743 //System.out.println("c = " + c);
744
745 e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, p);
746 //System.out.println("b^p = " + e);
747 // a a b^p c
748 d = a.multiply(a).multiply(e).multiply(c);
749 //System.out.println("d = " + d);
750
751 SortedMap<GenPolynomial<AlgebraicNumber<ModInteger>>, Long> sfactors;
752 sfactors = sqf.squarefreeFactors(d);
753 //System.out.println("sfactors = " + sfactors);
754
755 assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors));
756 }
757
758 }