001/* 002 * $Id$ 003 */ 004 005package edu.jas.fd; 006 007 008import java.util.List; 009import java.util.ArrayList; 010 011import edu.jas.arith.BigRational; 012import edu.jas.kern.ComputerThreads; 013import edu.jas.poly.GenPolynomial; 014import edu.jas.poly.GenSolvablePolynomial; 015import edu.jas.poly.GenSolvablePolynomialRing; 016import edu.jas.poly.PolyUtil; 017import edu.jas.poly.PolynomialList; 018import edu.jas.poly.RecSolvablePolynomial; 019import edu.jas.poly.RecSolvablePolynomialRing; 020import edu.jas.poly.RelationGenerator; 021import edu.jas.poly.TermOrder; 022import edu.jas.poly.TermOrderByName; 023import edu.jas.poly.WeylRelationsIterated; 024 025import junit.framework.Test; 026import junit.framework.TestCase; 027import junit.framework.TestSuite; 028 029 030/** 031 * GCD Primitive PRS algorithm tests with JUnit. <b>Note:</b> not in sync with 032 * implementation. 033 * @author Heinz Kredel 034 */ 035 036public class GCDPrimitiveTest extends TestCase { 037 038 039 /** 040 * main. 041 */ 042 public static void main(String[] args) { 043 junit.textui.TestRunner.run(suite()); 044 ComputerThreads.terminate(); 045 } 046 047 048 /** 049 * Constructs a <CODE>GCDPrimitiveTest</CODE> object. 050 * @param name String. 051 */ 052 public GCDPrimitiveTest(String name) { 053 super(name); 054 } 055 056 057 /** 058 */ 059 public static Test suite() { 060 TestSuite suite = new TestSuite(GCDPrimitiveTest.class); 061 return suite; 062 } 063 064 065 GreatestCommonDivisorAbstract<BigRational> fd, fds; 066 067 068 TermOrder to = TermOrderByName.INVLEX; 069 070 071 GenSolvablePolynomialRing<BigRational> dfac; 072 073 074 //GenSolvablePolynomialRing<GenPolynomial<BigRational>> rfac; 075 RecSolvablePolynomialRing<BigRational> rfac; 076 077 078 GenSolvablePolynomial<BigRational> a, b, a0, b0, c, d, e, a1, b1; 079 080 081 GenSolvablePolynomial<GenPolynomial<BigRational>> ar, br, ar0, br0, cr, dr, er, sr; 082 083 084 int rl = 4; 085 086 087 int kl = 2; 088 089 090 int ll = 2; 091 092 093 int el = 3; 094 095 096 float q = 0.25f; 097 098 099 @Override 100 protected void setUp() { 101 a = b = c = d = e = null; 102 ar = br = cr = dr = er = null; 103 String[] vars = new String[] { "a", "b", "c", "d" }; 104 BigRational cf = new BigRational(1); 105 fd = new GreatestCommonDivisorPrimitive<BigRational>(cf); 106 fds = new GreatestCommonDivisorSimple<BigRational>(cf); 107 dfac = new GenSolvablePolynomialRing<BigRational>(cf, to, vars); 108 RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>(); 109 dfac.addRelations(wl); 110 rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(1); 111 } 112 113 114 @Override 115 protected void tearDown() { 116 a = b = c = d = e = null; 117 ar = br = cr = dr = er = null; 118 fd = null; 119 dfac = null; 120 rfac = null; 121 } 122 123 124 /** 125 * Test base gcd primitive. 126 */ 127 public void testBaseGcdPrimitive() { 128 String[] uvars = new String[] { "x" }; 129 dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, uvars); 130 131 for (int i = 0; i < 5; i++) { 132 a = dfac.random(kl * (i + 2), ll + 2 * i, el + 2, q); 133 b = dfac.random(kl * (i + 2), ll + 2 * i, el + 2, q); 134 c = dfac.random(kl * (i + 2), ll + 2, el + 2, q); 135 c = c.multiply(dfac.univariate(0)); 136 if (c.isZERO()) { 137 // skip for this turn 138 continue; 139 } 140 //a = fd.basePrimitivePart(a); 141 //b = fd.basePrimitivePart(b); 142 c = (GenSolvablePolynomial<BigRational>) fd.leftBasePrimitivePart(c).abs(); 143 144 //System.out.println("a = " + a); 145 //System.out.println("b = " + b); 146 //System.out.println("c = " + c); 147 //assertTrue("length( c" + i + " ) <> 0", c.length() > 0); 148 149 a = a.multiply(c); 150 b = b.multiply(c); 151 152 d = fd.leftBaseGcd(a, b); 153 e = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> baseSparsePseudoRemainder(d, c); 154 //System.out.println("d = " + d); 155 //System.out.println("c = " + c); 156 assertTrue("c | gcd(ac,bc): " + e, e.isZERO()); 157 158 e = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> baseSparsePseudoRemainder(a, d); 159 //System.out.println("e = " + e); 160 assertTrue("gcd(a,b) | a: " + e, e.isZERO()); 161 162 e = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> baseSparsePseudoRemainder(b, d); 163 //System.out.println("e = " + e); 164 assertTrue("gcd(a,b) | b " + e, e.isZERO()); 165 } 166 } 167 168 169 /** 170 * Test univariate recursive left gcd primitive. 171 */ 172 @SuppressWarnings("cast") 173 public void testRecursiveLeftGCDPrimitive() { 174 //String[] vars = new String[] { "a", "b", "c", "d" }; 175 String[] vars = new String[] { "a", "b" }; 176 dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, vars); 177 RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>(); 178 dfac.addRelations(wl); 179 //System.out.println("dfac = " + dfac.toScript()); 180 rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(1); 181 //System.out.println("rfac = " + rfac.toScript()); 182 183 RecSolvablePolynomialRing<BigRational> rrfacTemp = rfac; 184 GenSolvablePolynomialRing<GenPolynomial<BigRational>> rrfac = rfac; 185 186 GenSolvablePolynomialRing<BigRational> rcfac = (GenSolvablePolynomialRing<BigRational>) rfac.coFac; 187 SolvableQuotientRing<BigRational> qfac = new SolvableQuotientRing<BigRational>(rcfac); 188 QuotSolvablePolynomialRing<BigRational> rqfac = new QuotSolvablePolynomialRing<BigRational>(qfac, 189 rrfac); 190 List<GenSolvablePolynomial<GenPolynomial<BigRational>>> rl = rrfacTemp.coeffTable.relationList(); 191 List<GenPolynomial<GenPolynomial<BigRational>>> rlc = PolynomialList 192 .<GenPolynomial<BigRational>> castToList(rl); 193 rqfac.polCoeff.coeffTable.addRelations(rlc); 194 //System.out.println("rrfac = " + rrfac.toScript()); 195 //System.out.println("rcfac = " + rcfac.toScript()); 196 //System.out.println("qfac = " + qfac.toScript()); 197 //System.out.println("rqfac = " + rqfac.toScript()); 198 199 //kl = 3; ll = 4; // 200 el = 2; 201 202 ar = rfac.random(kl, ll, el + 1, q); 203 br = rfac.random(kl, ll, el, q); 204 cr = rfac.random(kl, ll, el, q); 205 //cr = (RecSolvablePolynomial<BigRational>) cr.abs(); 206 cr = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> monic(cr); 207 //cr = (RecSolvablePolynomial<BigRational>) fd.recursivePrimitivePart(cr).abs(); 208 //cr = rfac.getONE(); 209 //cr = rfac.parse("a+b+c+d"); 210 211 //ar = rfac.parse("1/3 b^3 - 1/6"); 212 //ar = rfac.parse("1/3 b^2 - 1/6"); 213 //br = rfac.parse("( -1/2 ) b + 3 a"); 214 //nok: cr = rfac.parse("b * a - 5 b"); 215 //cr = rfac.parse("a - 5"); 216 217 //System.out.println("ar = " + ar); 218 //System.out.println("br = " + br); 219 //System.out.println("cr = " + cr); 220 221 if (br.isZERO() || cr.isZERO()) { 222 br = rfac.parse("( -1/2 ) b + 3 a"); 223 cr = rfac.parse("a * b - 5 b"); 224 } 225 226 //ar = cr.multiply(ar); 227 //br = cr.multiply(br); 228 ar = ar.multiply(cr); 229 br = br.multiply(cr); 230 //System.out.println("ar = " + ar); 231 //System.out.println("br = " + br); 232 //if (true) return; 233 234 long ts = System.currentTimeMillis(); 235 //sr = rfac.getONE(); 236 sr = fds.leftRecursiveUnivariateGcd(ar, br); 237 ts = System.currentTimeMillis() - ts; 238 //System.out.println("cr = " + cr); 239 240 long tp = System.currentTimeMillis(); 241 dr = fd.leftRecursiveUnivariateGcd(ar, br); 242 tp = System.currentTimeMillis() - tp; 243 //System.out.println("cr = " + cr); 244 //System.out.println("dr = " + dr); 245 //System.out.println("sr = " + sr); 246 //System.out.println("time: ts = " + ts + ", tp = " + tp); 247 assertTrue("time: ts = " + ts + ", tp = " + tp, ts + tp >= 0); 248 249 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(dr, cr); 250 //System.out.println("er = " + er); 251 assertTrue("c | gcd(ac,bc): " + er, er.isZERO()); 252 253 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(ar, dr); 254 //System.out.println("er = " + er); 255 assertTrue("gcd(ac,bc) | ac: " + er, er.isZERO()); 256 257 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(br, dr); 258 //System.out.println("er = " + er); 259 assertTrue("gcd(ac,bc) | bc: " + er, er.isZERO()); 260 261 GenSolvablePolynomial<SolvableQuotient<BigRational>> ap, bp, dp, gp, ep; // cp, apm, bpm, cpm, dpm, gpm; 262 ap = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, ar); 263 bp = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, br); 264 //cp = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, cr); 265 dp = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, dr); 266 //apm = ap.monic(); 267 //bpm = bp.monic(); 268 //cpm = cp.monic(); 269 //dpm = dp.monic(); 270 //System.out.println("ap = " + ap); 271 //System.out.println("apm = " + apm); 272 //System.out.println("bp = " + bp); 273 //System.out.println("bpm = " + bpm); 274 //System.out.println("cp = " + cp); 275 //System.out.println("cpm = " + cpm); 276 //System.out.println("dp = " + dp); 277 //System.out.println("dpm = " + dpm); 278 279 GreatestCommonDivisorAbstract<SolvableQuotient<BigRational>> fdq = new GreatestCommonDivisorPrimitive<SolvableQuotient<BigRational>>( 280 qfac); 281 gp = fdq.leftBaseGcd(ap, bp); 282 //gpm = gp.monic(); 283 //System.out.println("gp = " + gp); 284 //System.out.println("gpm = " + gpm); 285 286 ep = FDUtil.<SolvableQuotient<BigRational>> leftBaseSparsePseudoRemainder(gp, dp); 287 //System.out.println("ep = " + ep); 288 assertTrue("c | gcd(ac,bc): " + ep, ep.isZERO()); 289 290 ep = FDUtil.<SolvableQuotient<BigRational>> leftBaseSparsePseudoRemainder(ap, gp); 291 //System.out.println("ep = " + ep); 292 assertTrue("gcd(ac,bc)| ac): " + ep, ep.isZERO()); 293 294 ep = FDUtil.<SolvableQuotient<BigRational>> leftBaseSparsePseudoRemainder(bp, gp); 295 //System.out.println("ep = " + ep); 296 assertTrue("gcd(ac,bc)| bc): " + ep, ep.isZERO()); 297 } 298 299 300 /** 301 * Test univariate recursive right gcd primitive. 302 */ 303 @SuppressWarnings("cast") 304 public void testRecursiveRightGCDPrimitive() { 305 //String[] vars = new String[] { "a", "b", "c", "d" }; 306 String[] vars = new String[] { "a", "b" }; 307 dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, vars); 308 RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>(); 309 dfac.addRelations(wl); 310 //System.out.println("dfac = " + dfac.toScript()); 311 rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(1); 312 //System.out.println("rfac = " + rfac.toScript()); 313 314 RecSolvablePolynomialRing<BigRational> rrfacTemp = rfac; 315 GenSolvablePolynomialRing<GenPolynomial<BigRational>> rrfac = rfac; 316 317 GenSolvablePolynomialRing<BigRational> rcfac = (GenSolvablePolynomialRing<BigRational>) rfac.coFac; 318 SolvableQuotientRing<BigRational> qfac = new SolvableQuotientRing<BigRational>(rcfac); 319 QuotSolvablePolynomialRing<BigRational> rqfac = new QuotSolvablePolynomialRing<BigRational>(qfac, 320 rrfac); 321 List<GenSolvablePolynomial<GenPolynomial<BigRational>>> rl = rrfacTemp.coeffTable.relationList(); 322 List<GenPolynomial<GenPolynomial<BigRational>>> rlc = PolynomialList 323 .<GenPolynomial<BigRational>> castToList(rl); 324 rqfac.polCoeff.coeffTable.addRelations(rlc); 325 //System.out.println("rrfac = " + rrfac.toScript()); 326 //System.out.println("rcfac = " + rcfac.toScript()); 327 //System.out.println("qfac = " + qfac.toScript()); 328 //System.out.println("rqfac = " + rqfac.toScript()); 329 330 //kl = 3; ll = 4; // 331 el = 3; 332 333 ar = rfac.random(kl, ll, el + 1, q); 334 br = rfac.random(kl, ll, el, q); 335 cr = rfac.random(kl, ll, el, q); 336 //cr = (RecSolvablePolynomial<BigRational>) cr.abs(); 337 cr = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> monic(cr); 338 //cr = (RecSolvablePolynomial<BigRational>) fd.recursivePrimitivePart(cr).abs(); 339 //cr = rfac.getONE(); 340 //cr = rfac.parse("a+b+c+d"); 341 342 //ar = rfac.parse("1/3 b^3 - 1/6"); 343 //ar = rfac.parse("1/3 b^2 - 1/6"); 344 //br = rfac.parse("( -1/2 ) b + 3 a"); 345 //nok: cr = rfac.parse("b * a - 5 b"); 346 //cr = rfac.parse("a - 5"); 347 348 //ar = rfac.parse("359/95 a b^2 + 275/124 a"); 349 //br = rfac.parse("814/189 b + 135/44 a"); 350 //cr = rfac.parse("b - 612/25"); 351 352 //System.out.println("ar = " + ar); 353 //System.out.println("br = " + br); 354 //System.out.println("cr = " + cr); 355 356 if (br.isZERO() || cr.isZERO()) { 357 br = rfac.parse("( -1/2 ) b + 3 a"); 358 cr = rfac.parse("a * b - 5 b"); 359 } 360 361 ar = cr.multiply(ar); 362 br = cr.multiply(br); 363 //System.out.println("ar = " + ar); 364 //System.out.println("br = " + br); 365 366 long ts = System.currentTimeMillis(); 367 //sr = rfac.getONE(); 368 sr = fds.rightRecursiveUnivariateGcd(ar, br); 369 ts = System.currentTimeMillis() - ts; 370 //System.out.println("cr = " + cr); 371 372 long tp = System.currentTimeMillis(); 373 dr = fd.rightRecursiveUnivariateGcd(ar, br); 374 tp = System.currentTimeMillis() - tp; 375 //System.out.println("cr = " + cr); 376 //System.out.println("dr = " + dr); 377 //System.out.println("sr = " + sr); 378 //System.out.println("time: ts = " + ts + ", tp = " + tp); 379 assertTrue("time: ts = " + ts + ", tp = " + tp, ts + tp >= 0); 380 381 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(dr, 382 cr); 383 //System.out.println("er = " + er); 384 assertTrue("c | gcd(ca,cb): " + er, er.isZERO()); 385 386 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(ar, 387 dr); 388 //System.out.println("er = " + er); 389 assertTrue("gcd(ca,cb) | ca: " + er, er.isZERO()); 390 391 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(br, 392 dr); 393 //System.out.println("er = " + er); 394 assertTrue("gcd(ca,cb) | cb: " + er, er.isZERO()); 395 } 396 397 398 /** 399 * Test arbitrary recursive gcd primitive. 400 */ 401 @SuppressWarnings("cast") 402 public void testArbitraryRecursiveGCDPrimitive() { 403 String[] cvars = new String[] { "a", "b" }; 404 String[] vars = new String[] { "c" }; 405 dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, cvars); 406 RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>(); 407 dfac.addRelations(wl); 408 //System.out.println("dfac = " + dfac.toScript()); 409 rfac = new RecSolvablePolynomialRing<BigRational>(dfac, to, vars); 410 //rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(1); 411 //System.out.println("rfac = " + rfac.toScript()); 412 413 //kl = 3; ll = 2; 414 el = 2; 415 416 ar0 = rfac.random(kl, ll, el + 1, q); 417 br0 = rfac.random(kl, ll, el, q); 418 cr = rfac.random(kl, ll, el, q); 419 420 //ar0 = rfac.parse("a + b c^2 "); 421 //br0 = rfac.parse("( a^2 - 1/3 ) c - 1/4"); 422 //cr = rfac.parse("(b - 1/2 a^2) c"); 423 424 //cr = (RecSolvablePolynomial<BigRational>) fd.recursivePrimitivePart(cr).abs(); 425 cr = (RecSolvablePolynomial<BigRational>) cr.monic(); 426 if (cr.isZERO()) { 427 cr = rfac.getONE(); 428 } 429 430 //System.out.println("ar = " + ar); 431 //System.out.println("br = " + br); 432 //System.out.println("cr = " + cr); 433 434 // left gcd 435 ar = ar0.multiply(cr); 436 br = br0.multiply(cr); 437 //System.out.println("ar = " + ar); 438 //System.out.println("br = " + br); 439 440 dr = fd.leftRecursiveGcd(ar, br); 441 //System.out.println("cr = " + cr); 442 //System.out.println("dr = " + dr); 443 444 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(dr, cr); 445 //System.out.println("er = " + er); 446 assertTrue("c | gcd(ac,bc): " + er, er.isZERO()); 447 448 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(ar, dr); 449 //System.out.println("er = " + er); 450 assertTrue("gcd(a,b) | a: " + er, er.isZERO()); 451 452 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(br, dr); 453 //System.out.println("er = " + er); 454 assertTrue("gcd(a,b) | b: " + er, er.isZERO()); 455 456 // right gcd 457 ar = cr.multiply(ar0); 458 br = cr.multiply(br0); 459 //System.out.println("ar = " + ar); 460 //System.out.println("br = " + br); 461 462 dr = fd.rightRecursiveGcd(ar, br); 463 //System.out.println("cr = " + cr); 464 //System.out.println("dr = " + dr); 465 466 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(dr, 467 cr); 468 //System.out.println("er = " + er); 469 assertTrue("c | gcd(ca,cb) " + er, er.isZERO()); 470 471 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(ar, 472 dr); 473 //System.out.println("er = " + er); 474 assertTrue("gcd(ca,cb) | ca " + er, er.isZERO()); 475 476 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(br, 477 dr); 478 //System.out.println("er = " + er); 479 assertTrue("gcd(ca,cb) | cb " + er, er.isZERO()); 480 } 481 482 483 /** 484 * Test full gcd primitive. 485 */ 486 public void testGCDPrimitive() { 487 String[] vars = new String[] { "a", "b", "c", "d" }; 488 //String[] vars = new String[] { "a", "b" }; 489 dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, vars); 490 RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>(); 491 dfac.addRelations(wl); 492 //System.out.println("dfac = " + dfac.toScript()); 493 494 //kl = 3; 495 ll = 4; 496 el = 4; 497 498 //a = dfac.random(kl, ll, el, q); 499 //b = dfac.random(kl, ll, el, q); 500 //c = dfac.random(kl, ll, el, q); 501 //c = c.multiply(dfac.univariate(0)); 502 503 a = dfac.parse("1/3 b^3 - 1/6 + d"); 504 b = dfac.parse("( -1/2 ) b + 3 a^2 + d"); 505 ////b = dfac.parse("( -1/2 ) b + 3 a^2 + c"); 506 ////c = dfac.parse("(a - 5 b) + c + d"); 507 ////ok: c = dfac.parse("(a - b) c"); 508 ////c = dfac.parse("c (a - b)"); 509 //c = dfac.parse("(a - b) + c + d "); 510 c = dfac.parse("(a - b) + c"); 511 //c = dfac.parse("(a - b) + b^3"); 512 //c = dfac.parse("(a - b) + d"); 513 514 //a = dfac.parse("2 b^3 * d^2 + 2/3 a + 3/2"); 515 //b = dfac.parse("2/3 d + 1/2 a^3 + 3/4"); 516 //c = dfac.parse("c^2 * d - 1/2 a^3 * d + 5/4 d"); 517 518 //c = (GenSolvablePolynomial<BigRational>) fd.primitivePart(c).abs(); 519 c = c.monic(); 520 if (c.isZERO()) { 521 c = dfac.getONE(); 522 } 523 //System.out.println("a = " + a); 524 //System.out.println("b = " + b); 525 //System.out.println("c = " + c); 526 527 // left 528 a0 = a; 529 b0 = b; 530 a = a0.multiply(c); 531 b = b0.multiply(c); 532 //System.out.println("a = " + a); 533 //System.out.println("b = " + b); 534 //System.out.println("c = " + c); 535 536 d = fd.leftGcd(a, b); 537 //System.out.println("c = " + c); 538 //System.out.println("d = " + d); 539 540 e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(d, c); 541 //System.out.println("e = " + e); 542 assertTrue("c | gcd(ac,bc) " + e, e.isZERO()); 543 544 e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(a, c); 545 //System.out.println("e = " + e); 546 assertTrue("c | ac " + e, e.isZERO()); 547 e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(a, d); 548 //System.out.println("e = " + e); 549 assertTrue("gcd(a,b) | a " + e, e.isZERO()); 550 551 e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(b, c); 552 //System.out.println("e = " + e); 553 assertTrue("c | bc " + e, e.isZERO()); 554 e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(b, d); 555 //System.out.println("e = " + e); 556 assertTrue("gcd(a,b) | b " + e, e.isZERO()); 557 558 559 // right 560 a = c.multiply(a0); 561 b = c.multiply(b0); 562 //System.out.println("a = " + a); 563 //System.out.println("b = " + b); 564 //System.out.println("c = " + c); 565 566 d = fd.rightGcd(a, b); 567 //System.out.println("c = " + c); 568 //System.out.println("d = " + d); 569 570 e = FDUtil.<BigRational> rightBaseSparsePseudoRemainder(d, c); 571 //System.out.println("e = " + e); 572 assertTrue("c | gcd(ac,bc): " + e, e.isZERO()); 573 574 e = FDUtil.<BigRational> rightBaseSparsePseudoRemainder(a, c); 575 //System.out.println("e = " + e); 576 assertTrue("c | ac: " + e, e.isZERO()); 577 e = FDUtil.<BigRational> rightBaseSparsePseudoRemainder(b, c); 578 //System.out.println("e = " + e); 579 assertTrue("c | bc: " + e, e.isZERO()); 580 581 e = FDUtil.<BigRational> rightBaseSparsePseudoRemainder(a, d); 582 //System.out.println("e = " + e); 583 //e = FDUtil.<BigRational> divideRightPolynomial(a,d); 584 //System.out.println("e = " + e); 585 assertTrue("gcd(a,b) | a: " + e, e.isZERO()); 586 587 e = FDUtil.<BigRational> rightBaseSparsePseudoRemainder(b, d); 588 //System.out.println("e = " + e); 589 //e = FDUtil.<BigRational> divideRightPolynomial(b,d); 590 //System.out.println("e = " + e); 591 assertTrue("gcd(a,b) | b: " + e, e.isZERO()); 592 } 593 594 595 /** 596 * Test rational coefficients gcd polynomial cofactor tests. 597 */ 598 public void testRatCofactors() { 599 //System.out.println("dfac = " + dfac.toScript()); 600 do { 601 a = dfac.random(kl, ll, el, q); 602 } while (a.isZERO()||a.isConstant()); 603 do { 604 b = dfac.random(kl, ll, el, q/2f); 605 } while (b.isZERO()||b.isConstant()); 606 do { 607 c = dfac.random(kl, ll, el, q/2f); 608 } while (c.isZERO()||c.isConstant()); 609 c = c.monic(); 610 //System.out.println("a = " + a); 611 //System.out.println("b = " + b); 612 //System.out.println("c = " + c); 613 614 // non commutative left 615 //System.out.println("right: "); 616 d = c.multiply(a); 617 e = c.multiply(b); 618 //System.out.println("d = " + d); 619 //System.out.println("e = " + e); 620 621 GenSolvablePolynomial<BigRational>[] gco = fd.leftGcdCofactors(dfac, d, e); 622 //System.out.println("left gco[0] = " + gco[0]); 623 //System.out.println("gco[1] = " + gco[1]); 624 //System.out.println("gco[2] = " + gco[2]); 625 626 GenSolvablePolynomial<BigRational> ca, cb; 627 ca = gco[0].multiply(gco[1]); 628 cb = gco[0].multiply(gco[2]); 629 //System.out.println("ca = " + ca); 630 //System.out.println("d = " + d); 631 //System.out.println("cb = " + cb); 632 //System.out.println("e = " + e); 633 assertEquals("ca = c*a: ", ca, d); 634 assertEquals("cb = c*b: ", cb, e); 635 636 // non commutative right 637 //System.out.println("left: "); 638 d = a.multiply(c); 639 e = b.multiply(c); 640 //System.out.println("d = " + d); 641 //System.out.println("e = " + e); 642 643 gco = fd.rightGcdCofactors(dfac, d, e); 644 //System.out.println("right gco[0] = " + gco[0]); 645 //System.out.println("gco[1] = " + gco[1]); 646 //System.out.println("gco[2] = " + gco[2]); 647 648 GenSolvablePolynomial<BigRational> ac, bc; 649 ac = gco[1].multiply(gco[0]); 650 bc = gco[2].multiply(gco[0]); 651 //System.out.println("ac = " + ac); 652 //System.out.println("d = " + d); 653 //System.out.println("bc = " + bc); 654 //System.out.println("e = " + e); 655 assertEquals("ac = a*c: ", ac, d); 656 assertEquals("bc = b*c: ", bc, e); 657 } 658 659 660 /** 661 * Test co-prime factors. 662 */ 663 public void testCoPrime() { 664 String[] vs = new String[] { "a", "b" }; 665 dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, vs); 666 RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>(); 667 dfac.addRelations(wl); 668 //System.out.println("dfac = " + dfac.toScript()); 669 670 a = dfac.random(kl, 3, 2, q); 671 b = dfac.random(kl, 3, 2, q); 672 c = dfac.random(kl, 3, 2, q); 673 //System.out.println("a = " + a); 674 //System.out.println("b = " + b); 675 //System.out.println("c = " + c); 676 677 if (a.isZERO() || b.isZERO() || c.isZERO()) { 678 // skip for this turn 679 return; 680 } 681 assertTrue("length( a ) <> 0", a.length() > 0); 682 683 d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c); 684 e = a.multiply(b).multiply(c); 685 //System.out.println("d = " + d); 686 //System.out.println("e = " + e); 687 688 List<GenSolvablePolynomial<BigRational>> F = new ArrayList<GenSolvablePolynomial<BigRational>>(5); 689 F.add(d); 690 F.add(a); 691 F.add(b); 692 F.add(c); 693 F.add(e); 694 695 List<GenSolvablePolynomial<BigRational>> P = fd.leftCoPrime(F); 696 //System.out.println("F = " + F); 697 //System.out.println("P = " + P); 698 699 assertTrue("is co-prime ", fd.isLeftCoPrime(P)); 700 assertTrue("is co-prime of ", fd.isLeftCoPrime(P, F)); 701 702 P = fd.leftCoPrimeRec(F); 703 //System.out.println("F = " + F); 704 //System.out.println("P = " + P); 705 assertTrue("is co-prime ", fd.isLeftCoPrime(P)); 706 assertTrue("is co-prime of ", fd.isLeftCoPrime(P, F)); 707 } 708 709}