001/* 002 * $Id$ 003 */ 004 005package edu.jas.fd; 006 007 008import java.util.List; 009import java.util.ArrayList; 010import java.util.Collection; 011 012import edu.jas.arith.BigInteger; 013import edu.jas.arith.BigRational; 014import edu.jas.arith.BigQuaternion; 015import edu.jas.arith.BigQuaternionRing; 016import edu.jas.kern.ComputerThreads; 017import edu.jas.poly.GenPolynomial; 018import edu.jas.poly.GenSolvablePolynomial; 019import edu.jas.poly.GenSolvablePolynomialRing; 020import edu.jas.poly.PolyUtil; 021import edu.jas.poly.RecSolvablePolynomial; 022import edu.jas.poly.RecSolvablePolynomialRing; 023import edu.jas.poly.RelationGenerator; 024import edu.jas.poly.TermOrder; 025import edu.jas.poly.WeylRelationsIterated; 026 027import junit.framework.Test; 028import junit.framework.TestCase; 029import junit.framework.TestSuite; 030 031 032/** 033 * FDUtilQuat tests with JUnit. 034 * @author Heinz Kredel 035 */ 036 037public class FDUtilQuatTest extends TestCase { 038 039 040 /** 041 * main. 042 */ 043 public static void main(String[] args) { 044 junit.textui.TestRunner.run(suite()); 045 ComputerThreads.terminate(); 046 } 047 048 049 /** 050 * Constructs a <CODE>FDUtilQuatTest</CODE> object. 051 * @param name String. 052 */ 053 public FDUtilQuatTest(String name) { 054 super(name); 055 } 056 057 058 /** 059 */ 060 public static Test suite() { 061 TestSuite suite = new TestSuite(FDUtilQuatTest.class); 062 return suite; 063 } 064 065 066 TermOrder to = new TermOrder(TermOrder.INVLEX); 067 068 069 BigQuaternionRing cfi, cfr; 070 071 072 GenSolvablePolynomialRing<BigQuaternion> dfac; 073 074 075 GenSolvablePolynomialRing<BigQuaternion> rdfac; 076 077 078 GenSolvablePolynomialRing<GenPolynomial<BigQuaternion>> rfac; 079 080 081 GenSolvablePolynomialRing<GenPolynomial<BigQuaternion>> rrfac; 082 083 084 RecSolvablePolynomialRing<BigQuaternion> rsfac; 085 086 087 GenSolvablePolynomial<BigQuaternion> a, b, c, d, e, f; 088 089 090 GenSolvablePolynomial<GenPolynomial<BigQuaternion>> ar, br, cr, dr, er, fr; 091 092 093 GenSolvablePolynomial<GenPolynomial<BigQuaternion>> arr, brr, abrr, barr, crr, drr, err, frr, x1; 094 095 096 RecSolvablePolynomial<BigQuaternion> as, bs, cs, ds, es, fs; 097 098 099 int rl = 4; 100 101 102 int kl = 2; 103 104 105 int ll = 4; 106 107 108 int el = 3; 109 110 111 float q = 0.35f; 112 113 114 @Override 115 protected void setUp() { 116 a = b = c = d = e = null; 117 ar = br = cr = dr = er = null; 118 String[] vars = new String[] { "a", "b", "c", "d" }; 119 rl = vars.length; 120 cfi = new BigQuaternionRing(true); 121 cfr = new BigQuaternionRing(); 122 dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfi, to, vars); 123 RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>(); 124 dfac.addRelations(wl); 125 rfac = dfac.recursive(1); 126 rdfac = new GenSolvablePolynomialRing<BigQuaternion>(cfr, to, vars); 127 RelationGenerator<BigQuaternion> wlr = new WeylRelationsIterated<BigQuaternion>(); 128 rdfac.addRelations(wlr); 129 rrfac = rdfac.recursive(1); 130 } 131 132 133 @Override 134 protected void tearDown() { 135 a = b = c = d = e = null; 136 ar = br = cr = dr = er = null; 137 dfac = null; 138 rfac = null; 139 } 140 141 142 /** 143 * Test base pseudo division. 144 */ 145 public void testBasePseudoDivisionExact() { 146 //System.out.println("dfac = " + dfac.toScript()); 147 do { 148 a = dfac.random(kl, ll + 1, el, q).monic(); 149 } while (a.isZERO()); 150 //a = dfac.parse(" 3 x^5 + 44 "); 151 //System.out.println("a = " + a); 152 153 do { 154 b = dfac.random(kl, ll + 1, el, q).monic(); 155 } while (b.isZERO()); 156 //a = a.sum(b); 157 //b = dfac.parse(" 2 x^2 + 40 "); 158 //System.out.println("b = " + b); 159 160 // non commutative 161 c = b.multiply(a); 162 d = a.multiply(b); 163 //System.out.println("c = " + c); 164 //System.out.println("d = " + d); 165 assertTrue("c != 0: ", !c.isZERO()); 166 assertTrue("d != 0: ", !d.isZERO()); 167 168 assertTrue("a*b != b*a", !c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector())); 169 170 // divide 171 e = FDUtil.<BigQuaternion> leftBasePseudoQuotient(c, a); 172 //System.out.println("e = " + e); 173 assertEquals("b == b*a/a: ", b, e); 174 175 f = FDUtil.<BigQuaternion> rightBasePseudoQuotient(c, b); 176 //System.out.println("f = " + f); 177 assertEquals("a == b*a/b: ", a, f); 178 179 e = FDUtil.<BigQuaternion> rightBasePseudoQuotient(d, a); 180 //System.out.println("e = " + e); 181 assertEquals("b == a*b/a: ", b, e); 182 183 f = FDUtil.<BigQuaternion> leftBasePseudoQuotient(d, b); 184 //System.out.println("f = " + f); 185 assertEquals("a == a*b/b: ", a, f); 186 } 187 188 189 /** 190 * Test base pseudo quotient remainder. 191 */ 192 public void testBasePseudoQuotientRemainderExact() { 193 //System.out.println("dfac = " + dfac.toScript()); 194 do { 195 a = dfac.random(kl, ll + 1, el, q).monic(); 196 } while (a.isZERO()); 197 //a = dfac.parse(" 3 x^5 + 44 "); 198 //System.out.println("a = " + a); 199 200 do { 201 b = dfac.random(kl, ll + 1, el, q).monic(); 202 } while (b.isZERO()); 203 //a = a.sum(b); 204 //b = dfac.parse(" 2 x^2 + 40 "); 205 //System.out.println("b = " + b); 206 207 // non commutative 208 c = b.multiply(a); 209 d = a.multiply(b); 210 //System.out.println("c = " + c); 211 //System.out.println("d = " + d); 212 assertTrue("c != 0: ", !c.isZERO()); 213 assertTrue("d != 0: ", !d.isZERO()); 214 215 assertTrue("a*b != b*a", !c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector())); 216 217 // divide 218 e = FDUtil.<BigQuaternion> rightBaseSparsePseudoRemainder(d, a); 219 //System.out.println("e = " + e); 220 assertTrue("ab = a*x + 0: ", e.isZERO()); 221 222 f = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(d, b); 223 //System.out.println("f = " + f); 224 assertTrue("ab = y*b + 0: ", f.isZERO()); 225 226 e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(c, a); 227 //System.out.println("e = " + e); 228 assertTrue("ba = x*a + 0: ", e.isZERO()); 229 230 f = FDUtil.<BigQuaternion> rightBaseSparsePseudoRemainder(c, b); 231 //System.out.println("f = " + f); 232 assertTrue("ba = b*y + 0: ", f.isZERO()); 233 } 234 235 236 /** 237 * Test base pseudo division and remainder. 238 */ 239 public void testBasePseudoDivisionRemainder() { 240 String[] names = new String[] { "x" }; 241 GenSolvablePolynomialRing<BigQuaternion> dfac; 242 dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfi, to, names); 243 GenSolvablePolynomialRing<BigQuaternion> rdfac; 244 rdfac = new GenSolvablePolynomialRing<BigQuaternion>(cfr, dfac); 245 //System.out.println("dfac = " + dfac.toScript()); 246 247 do { 248 a = dfac.random(kl, ll * 1, el + 0, q); 249 } while (a.isZERO()); 250 //a = dfac.parse("3 x**5 + 44"); 251 //System.out.println("a = " + a); 252 253 do { 254 b = dfac.random(kl, ll * 2, el + 1, q); 255 } while (b.isZERO()); 256 //a = a.sum(b); 257 //b = dfac.parse("2 x**2 + 40"); 258 //System.out.println("b = " + b); 259 //System.out.println("a = " + a); 260 261 GenSolvablePolynomial<BigQuaternion>[] QR = FDUtil.<BigQuaternion> leftBasePseudoQuotientRemainder(a, b); 262 c = (GenSolvablePolynomial<BigQuaternion>) QR[0]; 263 d = (GenSolvablePolynomial<BigQuaternion>) QR[1]; 264 //System.out.println("c = " + c); 265 //System.out.println("d = " + d); 266 267 boolean t = FDUtil.<BigQuaternion> isLeftBasePseudoQuotientRemainder(a, b, c, d); 268 assertTrue("lc^n c = e b + f: " + f, t); 269 270 QR = FDUtil.<BigQuaternion> rightBasePseudoQuotientRemainder(a, b); 271 e = QR[0]; 272 f = QR[1]; 273 //System.out.println("e = " + e); 274 //System.out.println("f = " + f); 275 276 t = FDUtil.<BigQuaternion> isRightBasePseudoQuotientRemainder(a, b, e, f); 277 assertTrue("ore(lc^n) c = e b + f: " + f, t); 278 } 279 280 281 /* 282 * Test recursive pseudo division. 283 * @see edu.jas.ufd.PolyUfdUtilTest#testRecursivePseudoDivisionSparse 284 */ 285 public void todotestRecursivePseudoDivision() { 286 //String[] cnames = new String[] { "x" }; 287 //String[] mnames = new String[] { "t" }; 288 String[] names = new String[] { "t", "x", "y", "z" }; 289 rdfac = new GenSolvablePolynomialRing<BigQuaternion>(cfr, to, names); 290 RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>(); 291 rdfac.addRelations(wl); 292 rrfac = (RecSolvablePolynomialRing<BigQuaternion>) rdfac.recursive(1); 293 //System.out.println("\nrdfac = " + rdfac.toScript()); 294 //System.out.println("rrfac = " + rrfac.toScript()); 295 296 q = 0.23f; 297 kl = 1; 298 ll = 3; 299 300 arr = rrfac.random(kl, ll, el-1, q); 301 //arr = rrfac.parse(" ( t + x + y ) z^2 + ( 2 x - 8 ) y^2 - ( 13 t^4 - 13 t^3 + t^2 + 2 t - 13 ) "); 302 //arr = rrfac.parse(" ( 131/5 y - 85/84 ) "); 303 brr = rrfac.random(kl, ll, el, q); 304 //brr = rrfac.parse("( 27/28 x^2 - 31/19 t^2 + 3/5 )"); 305 if (brr.isZERO()) { 306 brr = rrfac.parse(" ( x - 2 ) z - ( t - y^2 + y ) "); 307 } 308 //System.out.println("arr = " + arr); 309 //System.out.println("brr = " + brr); 310 311 drr = FDUtil.<BigQuaternion> recursivePseudoQuotient(arr, brr); 312 crr = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(arr, brr); 313 //System.out.println("qrr = " + drr); 314 //System.out.println("crr = " + crr); 315 316 GenSolvablePolynomial<GenPolynomial<BigQuaternion>>[] QR; 317 QR = FDUtil.<BigQuaternion> recursivePseudoQuotientRemainder(arr, brr); 318 //assertEquals("drr == QR[0]: ", drr, QR[0]); 319 //assertEquals("crr == QR[1]: ", crr, QR[1]); 320 321 boolean t = FDUtil.<BigQuaternion> isRecursivePseudoQuotientRemainder(arr, brr, drr, crr); 322 //System.out.println("ore(lc^n) a == q b + r: " + t); 323 assertTrue("ore(lc^n) a = q b + r: " + crr, t); // ?? 324 } 325 326 327 /** 328 * Test recursive division coefficient polynomial. 329 */ 330 public void todoTtestLeftAndRightRecursiveDivision() { // todo 331 //String[] names = new String[] { "t", "x", "y", "z" }; 332 String[] names = new String[] { "y", "z" }; 333 rdfac = new GenSolvablePolynomialRing<BigQuaternion>(cfr, to, names); 334 RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>(); 335 rdfac.addRelations(wl); 336 rrfac = rdfac.recursive(1); 337 //System.out.println("\nrdfac = " + rdfac.toScript()); 338 //System.out.println("rrfac = " + rrfac.toScript()); 339 GenSolvablePolynomial<GenPolynomial<BigQuaternion>>[] QR; 340 boolean t; 341 342 // q = q; 343 kl = 2; 344 ll = 4; 345 el = 5; 346 347 arr = rrfac.random(kl, ll, el + 1, q); 348 //arr = rrfac.parse("z^5 - ( 1260/551 y^2 - 143/35 y - 33/100 ) z - ( 1/3 y^2 + 419/299 y - 19/56 )"); 349 // b * q + r: 350 //arr = rrfac.parse("z^5 + z^2 - 1"); 351 //System.out.println("arr = " + arr); 352 353 brr = rrfac.random(kl, ll, el, q); 354 //brr = rrfac.parse("z^3 - ( 377/140 y^2 + 211/232 y + 1213967/85560 )"); 355 //brr = rrfac.parse("( y ) z^3 - ( 1 ) z + ( 2 )"); 356 //System.out.println("brr = " + brr); 357 358 abrr = arr.multiply(brr); 359 //System.out.println("abrr = " + abrr); 360 361 // exact left division 362 drr = FDUtil.<BigQuaternion> recursivePseudoQuotient(abrr, brr); 363 crr = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(abrr, brr); 364 //System.out.println("drr = " + drr); 365 //System.out.println("crr = " + crr); 366 367 QR = FDUtil.<BigQuaternion> recursivePseudoQuotientRemainder(abrr, brr); 368 assertEquals("drr == QR[0]: ", drr, QR[0]); 369 assertEquals("crr == QR[1]: ", crr, QR[1]); 370 371 t = FDUtil.<BigQuaternion> isRecursivePseudoQuotientRemainder(abrr, brr, drr, crr); 372 //System.out.println("ore(lc^n) a == q b + r: " + t); 373 assertTrue("ore(lc^n) a = q b + r: " + crr, t); // ?? 374 375 barr = brr.multiply(arr); 376 //System.out.println("barr = " + barr); 377 378 // exact right division 379 QR = FDUtil.<BigQuaternion> recursiveRightPseudoQuotientRemainder(barr, brr); 380 drr = QR[0]; 381 crr = QR[1]; 382 //System.out.println("drr = " + drr); 383 //System.out.println("crr = " + crr); 384 //assertEquals("drr == QR[0]: ", drr, QR[0]); 385 //assertEquals("crr == QR[1]: ", crr, QR[1]); 386 387 t = FDUtil.<BigQuaternion> isRecursiveRightPseudoQuotientRemainder(barr, brr, drr, crr); 388 //System.out.println("FDQR: a ore(lc^n) == q b + r: " + t); 389 assertTrue("a ore(lc^n) = q b + r: " + crr, t); // ?? 390 391 // left division 392 QR = FDUtil.<BigQuaternion> recursivePseudoQuotientRemainder(arr, brr); 393 drr = QR[0]; 394 crr = QR[1]; 395 t = FDUtil.<BigQuaternion> isRecursivePseudoQuotientRemainder(arr, brr, drr, crr); 396 //System.out.println("drr = " + drr); 397 //System.out.println("crr = " + crr); 398 assertTrue("ore(lc^n) a = b q + r: " + crr, t); // ?? 399 400 // right division 401 QR = FDUtil.<BigQuaternion> recursiveRightPseudoQuotientRemainder(arr, brr); 402 drr = QR[0]; 403 crr = QR[1]; 404 t = FDUtil.<BigQuaternion> isRecursiveRightPseudoQuotientRemainder(arr, brr, drr, crr); 405 //System.out.println("drr = " + drr); 406 //System.out.println("crr = " + crr); 407 assertTrue("ore(lc^n) a = q p + r: " + crr, t); // ?? 408 } 409 410 411 /* 412 * Test recursive right coefficient polynomial. 413 */ 414 public void todotestRightRecursivePolynomial() { // todo 415 String[] names = new String[] { "t", "x", "y", "z" }; 416 //String[] names = new String[] { "y", "z" }; 417 rdfac = new GenSolvablePolynomialRing<BigQuaternion>(cfr, to, names); 418 RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>(); 419 rdfac.addRelations(wl); 420 rrfac = rdfac.recursive(1); 421 //System.out.println("\nrdfac = " + rdfac.toScript()); 422 //System.out.println("rrfac = " + rrfac.toScript()); 423 //GenSolvablePolynomialRing<BigQuaternion> cfac = (GenSolvablePolynomialRing) rrfac.coFac; 424 //System.out.println("cfac = " + cfac.toScript()); 425 426 // q = q; 427 kl = 3; 428 ll = 4; 429 el = 5; 430 431 arr = rrfac.random(kl, ll, el, q); 432 //arr = rrfac.parse(" z { y } "); 433 //System.out.println("arr = " + arr); 434 435 brr = arr.rightRecursivePolynomial(); 436 //System.out.println("brr = " + brr); 437 438 boolean t = arr.isRightRecursivePolynomial(brr); 439 assertTrue("arr == eval(brr): ", t); 440 441 GenSolvablePolynomial<BigQuaternion> c = (GenSolvablePolynomial<BigQuaternion>) rrfac 442 .random(kl, ll, el, q).leadingBaseCoefficient(); 443 //c = cfac.parse("y**2"); 444 //System.out.println("c = " + c); 445 446 drr = arr.multiply(c); // arr * c = drr 447 //System.out.println("drr = " + drr); 448 449 err = FDUtil.<BigQuaternion> recursiveLeftDivide(drr, c); // err * c = drr 450 //System.out.println("err = " + err); 451 assertEquals("arr == err: ", arr, err); 452 453 //System.out.println("\nFDQR: arr = " + arr); 454 drr = arr.multiplyLeft(c); // c * arr = drr 455 //System.out.println("drr = " + drr); 456 457 err = FDUtil.<BigQuaternion> recursiveRightDivide(drr, c); // c * err = drr 458 //System.out.println("err = " + err); 459 assertEquals("arr == err: ", arr, err); 460 } 461 462 463 /* 464 * Test exact division of recursive polynomials. 465 */ 466 public void todotestRecursiveDivide() { 467 rdfac = new GenSolvablePolynomialRing<BigQuaternion>(cfr, dfac); 468 RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>(); 469 rdfac.addRelations(wl); 470 //System.out.println("rdfac = " + rdfac.toScript()); 471 rsfac = (RecSolvablePolynomialRing<BigQuaternion>) rdfac.recursive(1); 472 System.out.println("rsfac = " + rsfac.toScript()); 473 474 assertFalse("isCommutative()", rsfac.isCommutative()); 475 assertTrue("isAssociative()", rsfac.isAssociative()); 476 477 do { 478 as = rsfac.random(kl, ll, el, q); 479 } while (as.isZERO()); 480 System.out.println("as = " + as); 481 482 do { 483 bs = rsfac.random(kl, ll, el, q); 484 } while (bs.isZERO()); 485 System.out.println("bs = " + bs); 486 487 // non commutative 488 cs = bs.multiply(as); 489 ds = as.multiply(bs); 490 //System.out.println("cs = " + cs); 491 //System.out.println("ds = " + ds); 492 assertTrue("cs != 0: ", !cs.isZERO()); 493 assertTrue("ds != 0: ", !ds.isZERO()); 494 495 //es = (RecSolvablePolynomial<BigQuaternion>) ds.subtract(cs); 496 assertTrue("as*bs != bs*as", !cs.equals(ds) || cs.leadingExpVector().equals(ds.leadingExpVector())); 497 498 // divide 499 es = (RecSolvablePolynomial<BigQuaternion>) FDUtil.<BigQuaternion> recursivePseudoQuotient(cs, as); 500 //System.out.println("es = " + es); 501 final int max = 4; 502 int i = 0; 503 do { 504 x1 = (RecSolvablePolynomial<BigQuaternion>) bs.multiplyLeft(as.leadingBaseCoefficient().power(i)); 505 //System.out.println("lc(a)^"+i+"*b = " + x1); 506 if (es.equals(x1)) { 507 assertEquals("b == b*a/a: ", es, x1); 508 break; 509 } 510 if (es.leadingBaseCoefficient().equals(x1.leadingBaseCoefficient())) { 511 // assertEquals("b == b*a/a: ", e, x1); 512 System.out.println("fail: b == b*a/a: lc(e)==lc(x1)"); 513 if (es.abs().equals(bs.abs())) { 514 System.out.println("success via pseudo: b == b*a/a: "); 515 } 516 break; 517 } 518 } while (i++ < max); 519 520 fs = (RecSolvablePolynomial<BigQuaternion>) FDUtil.<BigQuaternion> recursivePseudoQuotient(ds, bs); 521 System.out.println("fs = " + fs); 522 i = 0; 523 do { 524 x1 = (RecSolvablePolynomial<BigQuaternion>) as.multiplyLeft(bs.leadingBaseCoefficient().power(i)); 525 //System.out.println("lc(b)^"+i+"*a = " + x1); 526 if (fs.equals(x1)) { 527 assertEquals("a == a*b/b: ", fs, x1); 528 break; 529 } 530 if (fs.leadingBaseCoefficient().equals(x1.leadingBaseCoefficient())) { 531 //System.out.println("fail: a == a*b/b: lc(f)==lc(x1)"); 532 if (fs.abs().equals(as.abs())) { 533 //System.out.println("success via pseudo: a == a*b/b: "); 534 //assertEquals("a != a*b/b: ", fs.abs(), x1.abs()); 535 } else { 536 assertFalse("a != a*b/b: ", fs.abs().equals(x1.abs())); 537 } 538 break; 539 } 540 } while (i++ < max); 541 542 GenSolvablePolynomial<BigQuaternion> bc = (GenSolvablePolynomial<BigQuaternion>) bs.leadingBaseCoefficient(); 543 ds = (RecSolvablePolynomial<BigQuaternion>) as.multiply(bc); 544 fs = (RecSolvablePolynomial<BigQuaternion>) FDUtil.<BigQuaternion> recursiveDivide(ds, bc); 545 System.out.println("bc = " + bc); 546 System.out.println("ds = " + ds); 547 System.out.println("fs = " + fs); 548 i = 0; 549 do { 550 x1 = (RecSolvablePolynomial<BigQuaternion>) as.multiply(bc.power(i)); 551 //System.out.println("lc(b)^"+i+"*a = " + x1); 552 if (fs.equals(x1)) { 553 assertEquals("a == a*b/b: ", fs, x1); 554 break; 555 } 556 if (fs.leadingBaseCoefficient().equals(x1.leadingBaseCoefficient())) { 557 //System.out.println("fail: a == a*b/b: lc(f)==lc(x1)"); 558 if (fs.abs().equals(as.abs())) { 559 //System.out.println("success via pseudo: a == a*b/b: "); 560 } else { 561 assertFalse("a != a*b/b: ", fs.abs().equals(x1.abs())); 562 } 563 break; 564 } 565 } while (i++ < max); 566 567 bc = (GenSolvablePolynomial<BigQuaternion>) bs.leadingBaseCoefficient(); 568 ds = (RecSolvablePolynomial<BigQuaternion>) as.multiply(bc); 569 fs = (RecSolvablePolynomial<BigQuaternion>) FDUtil.<BigQuaternion> recursiveLeftDivide(ds, bc); 570 System.out.println("bc = " + bc); 571 System.out.println("ds = " + ds); 572 System.out.println("fs = " + fs); 573 i = 0; 574 do { 575 x1 = (RecSolvablePolynomial<BigQuaternion>) as.multiply(bc.power(i)); 576 //System.out.println("lc(b)^"+i+"*a = " + x1); 577 if (fs.equals(x1)) { 578 assertEquals("a == a*b/b: ", fs, x1); 579 break; 580 } 581 if (fs.leadingBaseCoefficient().equals(x1.leadingBaseCoefficient())) { 582 System.out.println("fail: a == a*b/b: lc(f)==lc(x1)"); 583 if (fs.abs().equals(as.abs())) { 584 System.out.println("success via pseudo: a == a*b/b: "); 585 } 586 break; 587 } 588 } while (i++ < max); 589 590 // todo 591 fs = (RecSolvablePolynomial<BigQuaternion>) FDUtil.<BigQuaternion> recursiveRightPseudoQuotient(cs, bs); 592 System.out.println("fs = " + fs); 593 i = 0; 594 do { 595 x1 = (RecSolvablePolynomial<BigQuaternion>) as.multiply(bs.leadingBaseCoefficient().power(i)); 596 //System.out.println("a*lc(b)^"+i+" = " + x1); 597 if (fs.equals(x1)) { 598 assertEquals("a == b*a/b: ", fs, x1); 599 break; 600 } 601 if (fs.leadingBaseCoefficient().equals(x1.leadingBaseCoefficient())) { 602 //System.out.println("fail: a == b*a/b: lc(f)==lc(x1)"); 603 if (fs.abs().equals(as.abs())) { 604 //System.out.println("success via pseudo: a == b*a/b: "); 605 } else { 606 assertFalse("a != a*b/b: ", fs.abs().equals(x1.abs())); 607 } 608 break; 609 } 610 } while (i++ < max); 611 612 es = (RecSolvablePolynomial<BigQuaternion>) FDUtil.<BigQuaternion> recursiveRightPseudoQuotient(ds, as); 613 System.out.println("es = " + es); 614 i = 0; 615 do { 616 x1 = (RecSolvablePolynomial<BigQuaternion>) bs.multiply(as.leadingBaseCoefficient().power(i)); 617 //System.out.println("b*lc(a)^"+i+" = " + x1); 618 if (es.equals(x1)) { 619 assertEquals("b == a*b/a: ", es, x1); 620 break; 621 } 622 if (es.leadingBaseCoefficient().equals(x1.leadingBaseCoefficient())) { 623 //System.out.println("fail: b == a*b/a: lc(e) == lc(x1)"); 624 if (es.abs().equals(bs.abs())) { 625 //System.out.println("success via pseudo: b == a*b/a: "); 626 } else { 627 assertFalse("a != a*b/b: ", fs.abs().equals(x1.abs())); 628 } 629 break; 630 } 631 } while (i++ < max); 632 } 633 634}