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:ModInteger coefficients tests with 029 * JUnit. 030 * @author Heinz Kredel 031 */ 032 033public class SquarefreeAlgModTest 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>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, b, c, d, e; 124 125 126 GenPolynomialRing<AlgebraicNumber<ModInteger>> cfac; 127 128 129 GenPolynomialRing<GenPolynomial<AlgebraicNumber<ModInteger>>> rfac; 130 131 132 GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>> ar, br, cr, dr, er; 133 134 135 @Override 136 protected void setUp() { 137 vars = ExpVector.STDVARS(rl); 138 cvars = ExpVector.STDVARS(rl - 1); 139 c1vars = new String[] { cvars[0] }; 140 rvars = new String[] { vars[rl - 1] }; 141 142 mfac = new ModIntegerRing(p); 143 alpha = new String[] { "alpha" }; 144 mpfac = new GenPolynomialRing<ModInteger>(mfac, 1, to, alpha); 145 agen = mpfac.univariate(0, 2); 146 agen = agen.sum(mpfac.getONE()); // x^2 + 1, is irred mod 7, 11, 19 147 fac = new AlgebraicNumberRing<ModInteger>(agen, true); 148 qp = 1L; 149 for (int i = 0; i < agen.degree(0); i++) { 150 qp = qp * p; 151 } 152 //System.out.println("p = " + p + ", qp = " + qp); 153 154 //ufd = new GreatestCommonDivisorSubres<AlgebraicNumber<ModInteger>>(); 155 //ufd = GCDFactory.<AlgebraicNumber<ModInteger>> getImplementation(fac); 156 ufd = GCDFactory.<AlgebraicNumber<ModInteger>> getProxy(fac); 157 158 sqf = new SquarefreeFiniteFieldCharP<AlgebraicNumber<ModInteger>>(fac); 159 160 SquarefreeAbstract<AlgebraicNumber<ModInteger>> sqff = SquarefreeFactory.getImplementation(fac); 161 //System.out.println("sqf = " + sqf); 162 //System.out.println("sqff = " + sqff); 163 assertEquals("sqf == sqff ", sqf.getClass(), sqff.getClass()); 164 165 a = b = c = d = e = null; 166 ar = br = cr = dr = er = null; 167 } 168 169 170 @Override 171 protected void tearDown() { 172 a = b = c = d = e = null; 173 ar = br = cr = dr = er = null; 174 //ComputerThreads.terminate(); 175 } 176 177 178 /** 179 * Test base squarefree. 180 */ 181 public void testBaseSquarefree() { 182 //System.out.println("\nbase:"); 183 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars); 184 185 a = dfac.random(kl, ll, el + 2, q); 186 b = dfac.random(kl, ll, el + 2, q); 187 c = dfac.random(kl, ll, el, q); 188 //System.out.println("a = " + a); 189 //System.out.println("b = " + b); 190 //System.out.println("c = " + c); 191 192 if (a.isZERO() || b.isZERO() || c.isZERO()) { 193 // skip for this turn 194 return; 195 } 196 197 // a a b b b c 198 d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c); 199 c = a.multiply(b).multiply(c); 200 //System.out.println("c = " + c); 201 //System.out.println("d = " + d); 202 203 c = sqf.baseSquarefreePart(c); 204 d = sqf.baseSquarefreePart(d); 205 //System.out.println("c = " + c); 206 //System.out.println("d = " + d); 207 assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c)); 208 assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d)); 209 210 e = PolyUtil.<AlgebraicNumber<ModInteger>> baseSparsePseudoRemainder(d, c); 211 //System.out.println("e = " + e); 212 assertTrue("squarefree(abc) | squarefree(aabbbc) " + e, e.isZERO()); 213 } 214 215 216 /** 217 * Test base squarefree factors. 218 */ 219 public void testBaseSquarefreeFactors() { 220 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars); 221 222 a = dfac.random(kl, ll, el + 3, q); 223 b = dfac.random(kl, ll, el + 3, q); 224 c = dfac.random(kl, ll, el + 2, q); 225 //System.out.println("a = " + a); 226 //System.out.println("b = " + b); 227 //System.out.println("c = " + c); 228 229 if (a.isZERO() || b.isZERO() || c.isZERO()) { 230 // skip for this turn 231 return; 232 } 233 234 // a a b b b c 235 d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c); 236 //System.out.println("d = " + d); 237 238 SortedMap<GenPolynomial<AlgebraicNumber<ModInteger>>, Long> sfactors; 239 sfactors = sqf.baseSquarefreeFactors(d); 240 //System.out.println("sfactors = " + sfactors); 241 assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors)); 242 } 243 244 245 /** 246 * Test recursive squarefree. 247 */ 248 public void testRecursiveSquarefree() { 249 //System.out.println("\nrecursive:"); 250 cfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 2 - 1, to, c1vars); 251 rfac = new GenPolynomialRing<GenPolynomial<AlgebraicNumber<ModInteger>>>(cfac, 1, to, rvars); 252 253 ar = rfac.random(kl, ll, el, q); 254 br = rfac.random(kl, ll, el, q); 255 cr = rfac.random(kl, ll, el, q); 256 //System.out.println("ar = " + ar); 257 //System.out.println("br = " + br); 258 //System.out.println("cr = " + cr); 259 260 if (ar.isZERO() || br.isZERO() || cr.isZERO()) { 261 // skip for this turn 262 return; 263 } 264 265 dr = ar.multiply(ar).multiply(br).multiply(br); 266 cr = ar.multiply(br); 267 //System.out.println("cr = " + cr); 268 //System.out.println("dr = " + dr); 269 270 cr = sqf.recursiveUnivariateSquarefreePart(cr); 271 dr = sqf.recursiveUnivariateSquarefreePart(dr); 272 //System.out.println("cr = " + cr); 273 //System.out.println("dr = " + dr); 274 assertTrue("isSquarefree(cr) " + cr, sqf.isRecursiveSquarefree(cr)); 275 assertTrue("isSquarefree(dr) " + dr, sqf.isRecursiveSquarefree(dr)); 276 277 er = PolyUtil.<AlgebraicNumber<ModInteger>> recursiveSparsePseudoRemainder(dr, cr); 278 //System.out.println("er = " + er); 279 assertTrue("squarefree(abc) | squarefree(aabbc) " + er, er.isZERO()); 280 } 281 282 283 /** 284 * Test recursive squarefree factors. 285 */ 286 public void testRecursiveSquarefreeFactors() { 287 cfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 2 - 1, to, c1vars); 288 rfac = new GenPolynomialRing<GenPolynomial<AlgebraicNumber<ModInteger>>>(cfac, 1, to, rvars); 289 290 ar = rfac.random(kl, 3, 2, q); 291 br = rfac.random(kl, 3, 2, q); 292 cr = rfac.random(kl, 3, 2, q); 293 //System.out.println("ar = " + ar); 294 //System.out.println("br = " + br); 295 //System.out.println("cr = " + cr); 296 297 if (ar.isZERO() || br.isZERO() || cr.isZERO()) { 298 // skip for this turn 299 return; 300 } 301 302 dr = ar.multiply(cr).multiply(br).multiply(br); 303 //System.out.println("dr = " + dr); 304 305 SortedMap<GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>>, Long> sfactors; 306 sfactors = sqf.recursiveUnivariateSquarefreeFactors(dr); 307 //System.out.println("sfactors = " + sfactors); 308 309 assertTrue("isFactorization(d,sfactors) ", sqf.isRecursiveFactorization(dr, sfactors)); 310 } 311 312 313 /** 314 * Test squarefree. 315 */ 316 public void testSquarefree() { 317 //System.out.println("\nfull:"); 318 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, rl, to, vars); 319 320 a = dfac.random(kl, 3, 2, q); 321 b = dfac.random(kl, 3, 2, q); 322 c = dfac.random(kl, 3, 2, q); 323 //System.out.println("a = " + a); 324 //System.out.println("b = " + b); 325 //System.out.println("c = " + c); 326 327 if (a.isZERO() || b.isZERO() || c.isZERO()) { 328 // skip for this turn 329 return; 330 } 331 332 d = a.multiply(a).multiply(b).multiply(b).multiply(c); 333 c = a.multiply(b).multiply(c); 334 //System.out.println("c = " + c); 335 //System.out.println("d = " + d); 336 337 c = sqf.squarefreePart(c); 338 d = sqf.squarefreePart(d); 339 //System.out.println("c = " + c); 340 //System.out.println("d = " + d); 341 assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d)); 342 assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c)); 343 344 e = PolyUtil.<AlgebraicNumber<ModInteger>> baseSparsePseudoRemainder(d, c); 345 //System.out.println("e = " + e); 346 assertTrue("squarefree(abc) | squarefree(aabbc) " + e, e.isZERO()); 347 } 348 349 350 /** 351 * Test squarefree factors. 352 */ 353 public void testSquarefreeFactors() { 354 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, rl, to, vars); 355 356 a = dfac.random(kl, 3, 2, q); 357 b = dfac.random(kl, 3, 2, q); 358 c = dfac.random(kl, 3, 2, q); 359 //System.out.println("a = " + a); 360 //System.out.println("b = " + b); 361 //System.out.println("c = " + c); 362 363 if (a.isZERO() || b.isZERO() || c.isZERO()) { 364 // skip for this turn 365 return; 366 } 367 368 d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c); 369 //System.out.println("d = " + d); 370 371 SortedMap<GenPolynomial<AlgebraicNumber<ModInteger>>, Long> sfactors; 372 sfactors = sqf.squarefreeFactors(d); 373 //System.out.println("sfactors = " + sfactors); 374 assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors)); 375 } 376 377 378 /* ------------char-th root ------------------------- */ 379 380 381 /** 382 * Test base squarefree with char-th root. 383 */ 384 public void testBaseSquarefreeCharRoot() { 385 //System.out.println("\nbase CharRoot:"); 386 long p = fac.characteristic().longValue(); 387 388 //dfac = new GenPolynomialRing<ModInteger>(fac,1,to,rvars); 389 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars); 390 391 a = dfac.random(kl, ll + 1, el + 1, q).monic(); 392 b = dfac.random(kl, ll + 1, el + 1, q).monic(); 393 c = dfac.random(kl, ll, el, q).monic(); 394 395 if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) { 396 // skip for this turn 397 return; 398 } 399 //System.out.println("a = " + a); 400 //System.out.println("b = " + b); 401 //System.out.println("c = " + c); 402 403 e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, p); 404 //System.out.println("b^p = " + e); 405 // a a b^p c 406 d = a.multiply(a).multiply(e).multiply(c); 407 c = a.multiply(b).multiply(c); 408 //System.out.println("c = " + c); 409 //System.out.println("d = " + d); 410 411 c = sqf.baseSquarefreePart(c); 412 d = sqf.baseSquarefreePart(d); 413 //System.out.println("c = " + c); 414 //System.out.println("d = " + d); 415 assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c)); 416 assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d)); 417 418 e = PolyUtil.<AlgebraicNumber<ModInteger>> baseSparsePseudoRemainder(d, c); 419 //System.out.println("e = " + e); 420 assertTrue("squarefree(abc) | squarefree(aab^pc) " + e, e.isZERO()); 421 } 422 423 424 /** 425 * Test base squarefree factors with char-th root. 426 */ 427 public void testBaseSquarefreeFactorsCharRoot() { 428 long p = fac.characteristic().longValue(); 429 430 //dfac = new GenPolynomialRing<ModInteger>(fac,1,to,rvars); 431 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars); 432 433 a = dfac.random(kl, ll + 1, el + 2, q).monic(); 434 b = dfac.random(kl, ll + 1, el + 2, q).monic(); 435 c = dfac.random(kl, ll, el + 1, q).monic(); 436 437 if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) { 438 // skip for this turn 439 return; 440 } 441 //System.out.println("a = " + a); 442 //System.out.println("b = " + b); 443 //System.out.println("c = " + c); 444 445 e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, p); 446 //System.out.println("b^p = " + e); 447 // a a b^p 448 d = a.multiply(a).multiply(e); 449 //d = d.monic(); 450 //System.out.println("d = " + d); 451 452 SortedMap<GenPolynomial<AlgebraicNumber<ModInteger>>, Long> sfactors; 453 sfactors = sqf.baseSquarefreeFactors(d); 454 //System.out.println("sfactors = " + sfactors); 455 assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors)); 456 } 457 458 459 /** 460 * Test base squarefree with char-th root, two times. 461 */ 462 public void testBaseSquarefreeCharRoot2() { 463 //System.out.println("\nbase CharRoot 2:"); 464 //long p = fac.characteristic().longValue(); 465 466 //dfac = new GenPolynomialRing<ModInteger>(fac,1,to,rvars); 467 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 1, to, rvars); 468 469 a = dfac.random(kl, ll + 1, el + 1, q).monic(); 470 b = dfac.random(kl, ll + 1, el + 1, q).monic(); 471 c = dfac.random(kl, ll, el, q).monic(); 472 473 if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) { 474 // skip for this turn 475 return; 476 } 477 //System.out.println("a = " + a); 478 //System.out.println("b = " + b); 479 //System.out.println("c = " + c); 480 481 e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, qp); 482 //System.out.println("b^qp = " + e); 483 // a a b^qp c 484 d = a.multiply(a).multiply(e).multiply(c); 485 c = a.multiply(b).multiply(c); 486 //System.out.println("c = " + c); 487 //System.out.println("d = " + d); 488 489 c = sqf.baseSquarefreePart(c); 490 d = sqf.baseSquarefreePart(d); 491 //System.out.println("c = " + c); 492 //System.out.println("d = " + d); 493 assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c)); 494 assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d)); 495 496 e = PolyUtil.<AlgebraicNumber<ModInteger>> baseSparsePseudoRemainder(d, c); 497 //System.out.println("e = " + e); 498 assertTrue("squarefree(abc) | squarefree(aab^pc) " + e, e.isZERO()); 499 } 500 501 502 /** 503 * Test base squarefree factors with char-th root, two times. 504 */ 505 public void testBaseSquarefreeFactorsCharRoot2() { 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 + 2, q).monic(); 512 b = dfac.random(kl, ll + 1, el + 2, q).monic(); 513 c = dfac.random(kl, ll, el + 2, 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 526 d = a.multiply(a).multiply(e); 527 //d = d.monic(); 528 //System.out.println("d = " + d); 529 530 SortedMap<GenPolynomial<AlgebraicNumber<ModInteger>>, Long> sfactors; 531 sfactors = sqf.baseSquarefreeFactors(d); 532 //System.out.println("sfactors = " + sfactors); 533 assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors)); 534 } 535 536 537 /** 538 * Test recursive squarefree with char-th root. 539 */ 540 public void testRecursiveSquarefreeCharRoot() { 541 //System.out.println("\nrecursive CharRoot:"); 542 long p = fac.characteristic().longValue(); 543 544 cfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, 2 - 1, to, c1vars); 545 rfac = new GenPolynomialRing<GenPolynomial<AlgebraicNumber<ModInteger>>>(cfac, 1, to, rvars); 546 547 ar = rfac.random(kl, 3, el, q); 548 br = rfac.random(kl, 3, el, q); 549 cr = rfac.random(kl, 3, el, q); 550 //cr = rfac.getONE(); 551 552 if (ar.isZERO() || br.isZERO() || cr.isZERO()) { 553 // skip for this turn 554 return; 555 } 556 //ar = PolyUtil.<AlgebraicNumber<ModInteger>>monic(ar); 557 //br = PolyUtil.<AlgebraicNumber<ModInteger>>monic(br); 558 //cr = PolyUtil.<AlgebraicNumber<ModInteger>>monic(cr); 559 //System.out.println("ar = " + ar); 560 //System.out.println("br = " + br); 561 //System.out.println("cr = " + cr); 562 563 er = Power.<GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>>> positivePower(br, p); 564 //System.out.println("b^p = " + er); 565 // a a b^p c 566 dr = ar.multiply(ar).multiply(er).multiply(cr); 567 cr = ar.multiply(br).multiply(cr); 568 //System.out.println("cr = " + cr); 569 //System.out.println("dr = " + dr); 570 571 cr = sqf.recursiveUnivariateSquarefreePart(cr); 572 dr = sqf.recursiveUnivariateSquarefreePart(dr); 573 //System.out.println("cr = " + cr); 574 //System.out.println("dr = " + dr); 575 assertTrue("isSquarefree(cr) " + cr, sqf.isRecursiveSquarefree(cr)); 576 assertTrue("isSquarefree(dr) " + dr, sqf.isRecursiveSquarefree(dr)); 577 578 er = PolyUtil.<AlgebraicNumber<ModInteger>> recursiveSparsePseudoRemainder(dr, cr); 579 //System.out.println("er = " + er); 580 assertTrue("squarefree(abc) | squarefree(aabbc) " + er, er.isZERO()); 581 } 582 583 584 /** 585 * Test recursive squarefree factors with char-th root. 586 */ 587 public void testRecursiveSquarefreeFactorsCharRoot() { 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, 2, q); 594 br = rfac.random(kl, 3, 2, q); 595 cr = rfac.random(kl, 3, 2, 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 //System.out.println("dr = " + dr); 614 615 SortedMap<GenPolynomial<GenPolynomial<AlgebraicNumber<ModInteger>>>, Long> sfactors; 616 sfactors = sqf.recursiveUnivariateSquarefreeFactors(dr); 617 //System.out.println("sfactors = " + sfactors); 618 619 assertTrue("isFactorization(d,sfactors) ", sqf.isRecursiveFactorization(dr, sfactors)); 620 } 621 622 623 /** 624 * Test squarefree with char-th root. 625 */ 626 public void testSquarefreeCharRoot() { 627 //System.out.println("\nfull CharRoot:"); 628 long p = fac.characteristic().longValue(); 629 630 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, rl, to, vars); 631 632 a = dfac.random(kl, 3, 3, q); 633 b = dfac.random(kl, 3, 3, q); 634 c = dfac.random(kl, 3, 3, q); 635 //c = dfac.getONE(); 636 637 if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) { 638 // skip for this turn 639 return; 640 } 641 //a = a.monic(); 642 //b = b.monic(); 643 //c = c.monic(); 644 //System.out.println("a = " + a); 645 //System.out.println("b = " + b); 646 //System.out.println("c = " + c); 647 648 e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, p); 649 //System.out.println("b^p = " + e); 650 // a a b^p c 651 d = a.multiply(a).multiply(e).multiply(c); 652 c = a.multiply(b).multiply(c); 653 //System.out.println("c = " + c); 654 //System.out.println("d = " + d); 655 656 c = sqf.squarefreePart(c); 657 d = sqf.squarefreePart(d); 658 //System.out.println("c = " + c); 659 //System.out.println("d = " + d); 660 assertTrue("isSquarefree(d) " + d, sqf.isSquarefree(d)); 661 assertTrue("isSquarefree(c) " + c, sqf.isSquarefree(c)); 662 663 e = PolyUtil.<AlgebraicNumber<ModInteger>> baseSparsePseudoRemainder(d, c); 664 //System.out.println("e = " + e); 665 assertTrue("squarefree(abc) | squarefree(aab^pc) " + e, e.isZERO()); 666 } 667 668 669 /** 670 * Test squarefree factors with char-th root. 671 */ 672 public void testSquarefreeFactorsCharRoot() { 673 long p = fac.characteristic().longValue(); 674 675 dfac = new GenPolynomialRing<AlgebraicNumber<ModInteger>>(fac, rl, to, vars); 676 677 a = dfac.random(kl, 3, 3, q); 678 b = dfac.random(kl, 3, 3, q); 679 c = dfac.random(kl, 3, 3, q); 680 //c = dfac.getONE(); 681 682 if (a.isZERO() || b.isZERO() || c.isZERO() || a.isConstant() || b.isConstant()) { 683 // skip for this turn 684 return; 685 } 686 //a = a.monic(); 687 //b = b.monic(); 688 //c = c.monic(); 689 //System.out.println("a = " + a); 690 //System.out.println("b = " + b); 691 //System.out.println("c = " + c); 692 693 e = Power.<GenPolynomial<AlgebraicNumber<ModInteger>>> positivePower(b, p); 694 //System.out.println("b^p = " + e); 695 // a a b^p c 696 d = a.multiply(a).multiply(e).multiply(c); 697 //System.out.println("d = " + d); 698 699 SortedMap<GenPolynomial<AlgebraicNumber<ModInteger>>, Long> sfactors; 700 sfactors = sqf.squarefreeFactors(d); 701 //System.out.println("sfactors = " + sfactors); 702 703 assertTrue("isFactorization(d,sfactors) ", sqf.isFactorization(d, sfactors)); 704 } 705 706}