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