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}