001/* 002 * $Id: GCDSimpleTest.java 5267 2015-07-27 17:57:50Z kredel $ 003 */ 004 005package edu.jas.fd; 006 007 008import java.util.ArrayList; 009import java.util.List; 010 011import junit.framework.Test; 012import junit.framework.TestCase; 013import junit.framework.TestSuite; 014 015import org.apache.log4j.BasicConfigurator; 016 017import edu.jas.arith.BigRational; 018import edu.jas.gb.SolvableGroebnerBaseAbstract; 019import edu.jas.gb.SolvableGroebnerBaseSeq; 020import edu.jas.gbufd.QuotSolvablePolynomialRing; 021import edu.jas.gbufd.SolvableQuotient; 022import edu.jas.gbufd.SolvableQuotientRing; 023import edu.jas.poly.GenPolynomial; 024import edu.jas.poly.GenSolvablePolynomial; 025import edu.jas.poly.GenSolvablePolynomialRing; 026import edu.jas.poly.PolyUtil; 027import edu.jas.poly.PolynomialList; 028import edu.jas.poly.RecSolvablePolynomial; 029import edu.jas.poly.RecSolvablePolynomialRing; 030import edu.jas.poly.RelationGenerator; 031import edu.jas.poly.TermOrder; 032import edu.jas.poly.WeylRelationsIterated; 033 034 035/** 036 * GCD Simple PRS algorithm tests with JUnit. <b>Note:</b> not in sync with 037 * implementation. 038 * @author Heinz Kredel. 039 */ 040 041public class GCDSimpleTest extends TestCase { 042 043 044 /** 045 * main. 046 */ 047 public static void main(String[] args) { 048 BasicConfigurator.configure(); 049 junit.textui.TestRunner.run(suite()); 050 } 051 052 053 /** 054 * Constructs a <CODE>GCDSimpleTest</CODE> object. 055 * @param name String. 056 */ 057 public GCDSimpleTest(String name) { 058 super(name); 059 } 060 061 062 /** 063 */ 064 public static Test suite() { 065 TestSuite suite = new TestSuite(GCDSimpleTest.class); 066 return suite; 067 } 068 069 070 GreatestCommonDivisorAbstract<BigRational> fd; 071 072 073 TermOrder to = new TermOrder(TermOrder.INVLEX); 074 075 076 //TermOrder to = new TermOrder(TermOrder.IGRLEX); 077 078 079 GenSolvablePolynomialRing<BigRational> dfac; 080 081 082 //GenSolvablePolynomialRing<GenPolynomial<BigRational>> rfac; 083 RecSolvablePolynomialRing<BigRational> rfac; 084 085 086 GenSolvablePolynomial<BigRational> a, b, c, d, e; 087 088 089 GenSolvablePolynomial<GenPolynomial<BigRational>> ar, br, cr, dr, er; 090 091 092 int rl = 4; 093 094 095 int kl = 2; 096 097 098 int ll = 2; 099 100 101 int el = 3; 102 103 104 float q = 0.25f; 105 106 107 @Override 108 protected void setUp() { 109 a = b = c = d = e = null; 110 ar = br = cr = dr = er = null; 111 String[] vars = new String[] { "a", "b", "c", "d" }; 112 BigRational cf = new BigRational(1); 113 fd = new GreatestCommonDivisorSimple<BigRational>(cf); 114 dfac = new GenSolvablePolynomialRing<BigRational>(cf, rl, to, vars); 115 RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>(); 116 dfac.addRelations(wl); 117 rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(1); 118 //System.out.println("dfac = " + dfac); 119 } 120 121 122 @Override 123 protected void tearDown() { 124 a = b = c = d = e = null; 125 ar = br = cr = dr = er = null; 126 fd = null; 127 dfac = null; 128 rfac = null; 129 } 130 131 132 /** 133 * Test base gcd simple. 134 */ 135 public void xtestBaseGcdSimple() { 136 String[] uvars = new String[] { "x" }; 137 dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), 1, to, uvars); 138 for (int i = 0; i < 3; i++) { 139 a = dfac.random(kl * (i + 2), ll + 2 * i, el + 2, q); 140 b = dfac.random(kl * (i + 1), ll + i, el + 2, q); 141 c = dfac.random(kl * (i + 1), ll + 1, el + 1, q); 142 c = c.multiply(dfac.univariate(0)); 143 if (c.isZERO()) { 144 // skip for this turn 145 continue; 146 } 147 //a = fd.basePrimitivePart(a); 148 //b = fd.basePrimitivePart(b); 149 //c = (GenSolvablePolynomial<BigRational>) fd.basePrimitivePart(c).abs(); 150 //System.out.println("a = " + a); 151 //System.out.println("b = " + b); 152 //System.out.println("c = " + c); 153 154 a = a.multiply(c); 155 b = b.multiply(c); 156 157 d = fd.leftBaseGcd(a, b); 158 e = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> basePseudoRemainder(d, c); 159 //System.out.println("d = " + d); 160 //System.out.println("c = " + c); 161 assertTrue("c | gcd(ac,bc) " + e, e.isZERO()); 162 163 e = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> basePseudoRemainder(a, d); 164 //System.out.println("e = " + e); 165 assertTrue("gcd(a,b) | a " + e, e.isZERO()); 166 167 e = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> basePseudoRemainder(b, d); 168 //System.out.println("e = " + e); 169 assertTrue("gcd(a,b) | b " + e, e.isZERO()); 170 } 171 } 172 173 174 /** 175 * Test univariate recursive left gcd simple. 176 */ 177 @SuppressWarnings("cast") 178 public void xtestRecursiveLeftGCDSimple() { 179 String[] vars = new String[] { "a", "b" }; 180 dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, vars); 181 RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>(); 182 dfac.addRelations(wl); 183 System.out.println("dfac = " + dfac.toScript()); 184 rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(1); 185 System.out.println("rfac = " + rfac.toScript()); 186 187 RecSolvablePolynomialRing<BigRational> rrfacTemp = rfac; 188 GenSolvablePolynomialRing<GenPolynomial<BigRational>> rrfac = rfac; 189 190 GenSolvablePolynomialRing<BigRational> rcfac = (GenSolvablePolynomialRing<BigRational>) rfac.coFac; 191 SolvableQuotientRing<BigRational> qfac = new SolvableQuotientRing<BigRational>(rcfac); 192 QuotSolvablePolynomialRing<BigRational> rqfac = new QuotSolvablePolynomialRing<BigRational>(qfac, 193 rrfac); 194 List<GenSolvablePolynomial<GenPolynomial<BigRational>>> rl = rrfacTemp.coeffTable.relationList(); 195 List<GenPolynomial<GenPolynomial<BigRational>>> rlc = PolynomialList 196 .<GenPolynomial<BigRational>> castToList(rl); 197 rqfac.polCoeff.coeffTable.addRelations(rlc); 198 //System.out.println("rrfac = " + rrfac.toScript()); 199 //System.out.println("rcfac = " + rcfac.toScript()); 200 //System.out.println("qfac = " + qfac.toScript()); 201 //System.out.println("rqfac = " + rqfac.toScript()); 202 203 //kl = 3; 204 ll = 3; 205 el = 3; 206 207 ar = rfac.random(kl, ll, el + 1, q); 208 br = rfac.random(kl, ll, el, q); 209 cr = rfac.random(kl, ll, el, q); 210 ////cr = (RecSolvablePolynomial<BigRational>) cr.abs(); 211 cr = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> monic(cr); 212 //cr = (RecSolvablePolynomial<BigRational>) fd.recursivePrimitivePart(cr).abs(); 213 //cr = rfac.getONE(); 214 //cr = rfac.parse("a+b+c+d"); 215 216 //ar = rfac.parse("( ( -31/19 ) ) b^3 - ( 781/260 a - 641/372 )"); 217 //br = rfac.parse("( ( -1/5 ) a - 1/4 ) b^2 - 11/12 b - ( 47/17 a + 29/30 )"); 218 //cr = rfac.parse(" ( a + 9/8 ) b + ( 285/208 a + 191/280 )"); 219 220 //ar = rfac.parse("b^3 - ( a )"); 221 //br = rfac.parse("( a ) b^2 - 1/2 b"); 222 //cr = rfac.parse("b + ( a )"); 223 224 //ar = rfac.parse("( 2/23 a - 1/2 ) b^3 + 617/672 b^2 - ( 5 a + 307/154 )"); 225 //br = rfac.parse("( ( -673/330 ) ) b - ( 2/5 a - 566969/1651860 )"); 226 //cr = rfac.parse("( a - 2287945/213324 )"); 227 228 //ar = rfac.parse("( b^2 + 1/2 )"); 229 //br = rfac.parse("( a^2 b - ( a - 1/3 ) )"); 230 //cr = rfac.parse("( b + a - 1/5 )"); 231 232 //System.out.println("ar = " + ar); 233 //System.out.println("br = " + br); 234 //System.out.println("cr = " + cr); 235 236 if (cr.isZERO()) { 237 cr = rfac.getONE(); 238 } 239 //ar = cr.multiply(ar); 240 //br = cr.multiply(br); 241 ar = ar.multiply(cr); 242 br = br.multiply(cr); 243 //System.out.println("ar = " + ar); 244 //System.out.println("br = " + br); 245 246 dr = fd.leftRecursiveUnivariateGcd(ar, br); 247 //System.out.println("cr = " + cr); 248 //System.out.println("dr = " + dr); 249 250 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(dr, cr); 251 //System.out.println("er = " + er); 252 assertTrue("c | gcd(ac,bc) " + er, er.isZERO()); 253 254 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(ar, dr); 255 //System.out.println("er = " + er); 256 assertTrue("gcd(a,b) | a " + er, er.isZERO()); 257 258 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(br, dr); 259 //System.out.println("er = " + er); 260 assertTrue("gcd(a,b) | b " + er, er.isZERO()); 261 262 //if (true) return; 263 GenSolvablePolynomial<SolvableQuotient<BigRational>> ap, bp, cp, dp, gp, ep, apm, bpm, cpm, dpm, gpm; 264 ap = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, ar); 265 bp = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, br); 266 cp = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, cr); 267 dp = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, dr); 268 apm = ap.monic(); 269 bpm = bp.monic(); 270 cpm = cp.monic(); 271 dpm = dp.monic(); 272 System.out.println("ap = " + ap); 273 System.out.println("apm = " + apm); 274 System.out.println("bp = " + bp); 275 System.out.println("bpm = " + bpm); 276 System.out.println("cp = " + cp); 277 System.out.println("cpm = " + cpm); 278 System.out.println("dp = " + dp); 279 System.out.println("dpm = " + dpm); 280 281 GreatestCommonDivisorAbstract<SolvableQuotient<BigRational>> fdq = new GreatestCommonDivisorSimple<SolvableQuotient<BigRational>>( 282 qfac); 283 gp = fdq.leftBaseGcd(ap, bp); 284 gpm = gp.monic(); 285 System.out.println("gp = " + gp); 286 System.out.println("gpm = " + gpm); 287 288 ep = FDUtil.<SolvableQuotient<BigRational>> leftBaseSparsePseudoRemainder(gp, dp); 289 //System.out.println("ep = " + ep); 290 assertTrue("c | gcd(ac,bc): " + ep, ep.isZERO()); 291 292 ep = FDUtil.<SolvableQuotient<BigRational>> leftBaseSparsePseudoRemainder(ap, gp); 293 //System.out.println("ep = " + ep); 294 assertTrue("gcd(ac,bc)| ac): " + ep, ep.isZERO()); 295 296 ep = FDUtil.<SolvableQuotient<BigRational>> leftBaseSparsePseudoRemainder(bp, gp); 297 //System.out.println("ep = " + ep); 298 assertTrue("gcd(ac,bc)| bc): " + ep, ep.isZERO()); 299 } 300 301 302 /** 303 * Test univariate recursive right gcd simple. 304 */ 305 @SuppressWarnings("cast") 306 public void xtestRecursiveRightGCDSimple() { 307 String[] vars = new String[] { "a", "b" }; 308 dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, vars); 309 RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>(); 310 dfac.addRelations(wl); 311 System.out.println("dfac = " + dfac.toScript()); 312 rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(1); 313 System.out.println("rfac = " + rfac.toScript()); 314 315 RecSolvablePolynomialRing<BigRational> rrfacTemp = rfac; 316 GenSolvablePolynomialRing<GenPolynomial<BigRational>> rrfac = rfac; 317 318 GenSolvablePolynomialRing<BigRational> rcfac = (GenSolvablePolynomialRing<BigRational>) rfac.coFac; 319 SolvableQuotientRing<BigRational> qfac = new SolvableQuotientRing<BigRational>(rcfac); 320 QuotSolvablePolynomialRing<BigRational> rqfac = new QuotSolvablePolynomialRing<BigRational>(qfac, 321 rrfac); 322 List<GenSolvablePolynomial<GenPolynomial<BigRational>>> rl = rrfacTemp.coeffTable.relationList(); 323 List<GenPolynomial<GenPolynomial<BigRational>>> rlc = PolynomialList 324 .<GenPolynomial<BigRational>> castToList(rl); 325 rqfac.polCoeff.coeffTable.addRelations(rlc); 326 //System.out.println("rrfac = " + rrfac.toScript()); 327 //System.out.println("rcfac = " + rcfac.toScript()); 328 //System.out.println("qfac = " + qfac.toScript()); 329 //System.out.println("rqfac = " + rqfac.toScript()); 330 331 //kl = 3; 332 ll = 3; 333 el = 3; 334 335 ar = rfac.random(kl, ll, el + 1, q); 336 br = rfac.random(kl, ll, el, q); 337 cr = rfac.random(kl, ll, el, q); 338 ////cr = (RecSolvablePolynomial<BigRational>) cr.abs(); 339 cr = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> monic(cr); 340 //cr = (RecSolvablePolynomial<BigRational>) fd.recursivePrimitivePart(cr).abs(); 341 //cr = rfac.getONE(); 342 343 System.out.println("ar = " + ar); 344 System.out.println("br = " + br); 345 System.out.println("cr = " + cr); 346 347 if (cr.isZERO()) { 348 cr = rfac.getONE(); 349 } 350 ar = cr.multiply(ar); 351 br = cr.multiply(br); 352 //ar = ar.multiply(cr); 353 //br = br.multiply(cr); 354 System.out.println("ar = " + ar); 355 System.out.println("br = " + br); 356 357 dr = fd.rightRecursiveUnivariateGcd(ar, br); 358 System.out.println("cr = " + cr); 359 System.out.println("dr = " + dr); 360 361 //er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightPseudoQuotient(dr, cr); 362 //System.out.println("dr/cr = " + er); 363 364 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder( 365 dr, cr); 366 //System.out.println("er = " + er); 367 assertTrue("c | gcd(ac,bc) " + er, er.isZERO()); 368 369 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder( 370 ar, dr); 371 //System.out.println("er = " + er); 372 assertTrue("gcd(a,b) | a " + er, er.isZERO()); 373 374 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder( 375 br, dr); 376 //System.out.println("er = " + er); 377 assertTrue("gcd(a,b) | b " + er, er.isZERO()); 378 } 379 380 381 /** 382 * Test arbitrary recursive gcd simple. 383 */ 384 @SuppressWarnings("cast") 385 public void testArbitraryRecursiveGCDSimple() { 386 String[] cvars = new String[] { "a", "b" }; 387 String[] vars = new String[] { "c" }; 388 dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, cvars); 389 RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>(); 390 dfac.addRelations(wl); 391 //System.out.println("dfac = " + dfac.toScript()); 392 rfac = new RecSolvablePolynomialRing<BigRational>(dfac, to, vars); 393 //System.out.println("rfac = " + rfac.toScript()); 394 395 //kl = 3; ll = 2; 396 el = 2; 397 398 //ar = rfac.random(kl, ll, el + 1, q); 399 //br = rfac.random(kl, ll, el, q); 400 //cr = rfac.random(kl, ll, el, q); 401 402 //ar = rfac.parse("a + b c^2 "); 403 //br = rfac.parse("( a^2 - 1/3 ) c - 1/4"); 404 //cr = rfac.parse("(b - 1/2 a^2) c"); 405 //ar = rfac.parse("( 2/11 a * b^2 + 11/24 b - 11/6 a^2 )"); 406 //br = rfac.parse("( 14/13 b^2 - 1/69 )"); 407 //cr = rfac.parse("c + 33/133 a"); 408 ar = rfac.parse("( a * b^2 + 1/2 b - 1/6 a^2 )"); 409 br = rfac.parse("( b^2 - 1/5 )"); 410 cr = rfac.parse("c + 3/13 a"); 411 412 //cr = (RecSolvablePolynomial<BigRational>) fd.recursivePrimitivePart(cr).abs(); 413 cr = (RecSolvablePolynomial<BigRational>) cr.monic(); 414 if (cr.isZERO()) { 415 cr = rfac.getONE(); 416 } 417 //System.out.println("ar = " + ar); 418 //System.out.println("br = " + br); 419 //System.out.println("cr = " + cr); 420 421 ar = ar.multiply(cr); 422 br = br.multiply(cr); 423 //System.out.println("ar = " + ar); 424 //System.out.println("br = " + br); 425 426 dr = fd.leftRecursiveGcd(ar, br); 427 //System.out.println("cr = " + cr); 428 //System.out.println("dr = " + dr); 429 430 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(dr, cr); 431 //System.out.println("er = " + er); 432 assertTrue("c | gcd(ac,bc) " + er, er.isZERO()); 433 434 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(ar, dr); 435 //System.out.println("er = " + er); 436 assertTrue("gcd(a,b) | a " + er, er.isZERO()); 437 438 er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(br, dr); 439 //System.out.println("er = " + er); 440 assertTrue("gcd(a,b) | b " + er, er.isZERO()); 441 442 //if (true) return; 443 // compare with field coefficients: 444 RecSolvablePolynomialRing<BigRational> rrfacTemp = rfac; 445 GenSolvablePolynomialRing<GenPolynomial<BigRational>> rrfac = rfac; 446 447 GenSolvablePolynomialRing<BigRational> rcfac = (GenSolvablePolynomialRing<BigRational>) rfac.coFac; 448 SolvableQuotientRing<BigRational> qfac = new SolvableQuotientRing<BigRational>(rcfac); 449 QuotSolvablePolynomialRing<BigRational> rqfac = new QuotSolvablePolynomialRing<BigRational>(qfac, 450 rrfac); 451 List<GenSolvablePolynomial<GenPolynomial<BigRational>>> rl = rrfacTemp.coeffTable.relationList(); 452 List<GenPolynomial<GenPolynomial<BigRational>>> rlc = PolynomialList 453 .<GenPolynomial<BigRational>> castToList(rl); 454 rqfac.polCoeff.coeffTable.addRelations(rlc); 455 //System.out.println("rrfac = " + rrfac.toScript()); 456 //System.out.println("rcfac = " + rcfac.toScript()); 457 //System.out.println("qfac = " + qfac.toScript()); 458 //System.out.println("rqfac = " + rqfac.toScript()); 459 460 GenSolvablePolynomial<SolvableQuotient<BigRational>> ap, bp, cp, dp, gp, ep, apm, bpm, cpm, dpm, gpm; 461 ap = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, ar); 462 bp = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, br); 463 cp = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, cr); 464 dp = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, dr); 465 apm = ap.monic(); 466 bpm = bp.monic(); 467 cpm = cp.monic(); 468 dpm = dp.monic(); 469 //System.out.println("ap = " + ap); 470 //System.out.println("apm = " + apm); 471 //System.out.println("bp = " + bp); 472 //System.out.println("bpm = " + bpm); 473 //System.out.println("cp = " + cp); 474 //System.out.println("cpm = " + cpm); 475 //System.out.println("dp = " + dp); 476 //System.out.println("dpm = " + dpm); 477 478 GreatestCommonDivisorAbstract<SolvableQuotient<BigRational>> fdq = new GreatestCommonDivisorSimple<SolvableQuotient<BigRational>>( 479 qfac); 480 gp = fdq.leftBaseGcd(ap, bp); 481 gpm = gp.monic(); 482 //System.out.println("gp = " + gp); 483 //System.out.println("gpm = " + gpm); 484 485 ep = FDUtil.<SolvableQuotient<BigRational>> leftBaseSparsePseudoRemainder(gp, dp); 486 //System.out.println("ep = " + ep); 487 assertTrue("c | gcd(ac,bc): " + ep, ep.isZERO()); 488 489 ep = FDUtil.<SolvableQuotient<BigRational>> leftBaseSparsePseudoRemainder(ap, gp); 490 //System.out.println("ep = " + ep); 491 assertTrue("gcd(ac,bc)| ac): " + ep, ep.isZERO()); 492 493 ep = FDUtil.<SolvableQuotient<BigRational>> leftBaseSparsePseudoRemainder(bp, gp); 494 //System.out.println("ep = " + ep); 495 assertTrue("gcd(ac,bc)| bc): " + ep, ep.isZERO()); 496 497 assertEquals("nonsense", apm, ap.monic()); 498 assertEquals("nonsense", bpm, bp.monic()); 499 assertEquals("nonsense", cpm, cp.monic()); 500 assertEquals("nonsense", dpm, dp.monic()); 501 assertEquals("nonsense", gpm, gp.monic()); 502 } 503 504 505 /** 506 * Test full gcd simple. 507 */ 508 public void xtestGCDSimple() { 509 String[] vars = new String[] { "a", "b", "c", "d" }; 510 //String[] vars = new String[] { "a", "b" }; 511 dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, vars); 512 RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>(); 513 //RelationGenerator<BigRational> wl = new WeylRelations<BigRational>(); 514 dfac.addRelations(wl); 515 System.out.println("dfac = " + dfac.toScript()); 516 517 //kl = 3; 518 ll = 4; 519 el = 4; 520 521 //a = dfac.random(kl, ll, el, q); 522 //b = dfac.random(kl, ll, el, q); 523 //c = dfac.random(kl, ll, el, q); 524 //c = c.multiply(dfac.univariate(0)); 525 526 a = dfac.parse("b^3 - 1/6 + d"); 527 b = dfac.parse("b + 3 a^2 + d"); 528 //b = dfac.parse("( -1/2 ) b + 3 a^2 + d"); 529 //c = dfac.parse("(a - 5 b) + c + d"); 530 //ok: c = dfac.parse("(a - b) c"); 531 //c = dfac.parse("(a - b) + c + d "); 532 //c = dfac.parse("(a - b) + c"); 533 //c = dfac.parse("(a - b) + b^2"); 534 c = dfac.parse("c - a - b"); 535 //c = dfac.parse("d - c - b - a"); 536 //c = dfac.parse("(a - b) + d"); 537 //c = dfac.parse("b + d"); 538 //c = dfac.parse("a + d"); 539 540 //a = dfac.parse("2 b^3 * d^2 + 2/3 a + 3/2"); 541 //b = dfac.parse("2/3 d + 1/2 a^3 + 3/4"); 542 //c = dfac.parse("c^2 * d - 1/2 a^3 * d + 5/4 d"); 543 544 //c = (GenSolvablePolynomial<BigRational>) fd.primitivePart(c).abs(); 545 c = c.monic(); 546 if (c.isZERO()) { 547 c = dfac.getONE(); 548 } 549 System.out.println("a = " + a); 550 System.out.println("b = " + b); 551 System.out.println("c = " + c); 552 553 a = a.multiply(c); 554 b = b.multiply(c); 555 System.out.println("a = " + a); 556 System.out.println("b = " + b); 557 //System.out.println("c = " + c); 558 559 560 List<GenSolvablePolynomial<BigRational>> L = new ArrayList<GenSolvablePolynomial<BigRational>>(); 561 L.add(a); 562 L.add(b); 563 SolvableGroebnerBaseAbstract<BigRational> sbb = new SolvableGroebnerBaseSeq<BigRational>(); 564 565 List<GenSolvablePolynomial<BigRational>> Llgb = sbb.leftGB(L); 566 System.out.println("leftGB = " + Llgb); 567 //List<GenSolvablePolynomial<BigRational>> Lrgb = sbb.rightGB(L); 568 //System.out.println("rightGB = " + Lrgb); 569 //List<GenSolvablePolynomial<BigRational>> Ltgb = sbb.twosidedGB(L); 570 //System.out.println("twosidedGB = " + Ltgb); 571 572 d = fd.leftGcd(a, b); 573 System.out.println("gb = " + Llgb); 574 System.out.println("c = " + c); 575 System.out.println("d = " + d); 576 577 e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(d, c); 578 System.out.println("e = " + e); 579 assertTrue("c | gcd(ac,bc): " + e, e.isZERO()); 580 581 e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(a, c); 582 System.out.println("e = " + e); 583 assertTrue("c | ac: " + e, e.isZERO()); 584 e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(b, c); 585 System.out.println("e = " + e); 586 assertTrue("c | bc: " + e, e.isZERO()); 587 588 e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(a, d); 589 System.out.println("e = " + e); 590 //e = FDUtil.<BigRational> divideRightPolynomial(a,d); 591 //System.out.println("e = " + e); 592 assertTrue("gcd(a,b) | a: " + e, e.isZERO()); 593 594 e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(b, d); 595 System.out.println("e = " + e); 596 //e = FDUtil.<BigRational> divideRightPolynomial(b,d); 597 //System.out.println("e = " + e); 598 assertTrue("gcd(a,b) | b: " + e, e.isZERO()); 599 } 600 601}