001/* 002 * $Id$ 003 */ 004 005package edu.jas.poly; 006 007 008import java.util.ArrayList; 009import java.util.List; 010import java.util.Map; 011 012import edu.jas.arith.BigRational; 013 014import junit.framework.Test; 015import junit.framework.TestCase; 016import junit.framework.TestSuite; 017 018 019/** 020 * BigRational coefficients RecSolvablePolynomial tests with JUnit. 021 * @author Heinz Kredel 022 */ 023 024public class RecSolvablePolynomialTest extends TestCase { 025 026 027 /** 028 * main. 029 */ 030 public static void main(String[] args) { 031 junit.textui.TestRunner.run(suite()); 032 } 033 034 035 /** 036 * Constructs a <CODE>RecSolvablePolynomialTest</CODE> object. 037 * @param name String. 038 */ 039 public RecSolvablePolynomialTest(String name) { 040 super(name); 041 } 042 043 044 /** 045 */ 046 public static Test suite() { 047 TestSuite suite = new TestSuite(RecSolvablePolynomialTest.class); 048 return suite; 049 } 050 051 052 RecSolvablePolynomial<BigRational> a, b, c, d, e, f, x1, x2; 053 054 055 int rl = 4; 056 057 058 int kl = 3; 059 060 061 int ll = 4; 062 063 064 int el = 3; 065 066 067 float q = 0.25f; 068 069 070 String[] cvars = new String[] { "a", "b" }; 071 072 073 String[] vars = new String[] { "w", "x", "y", "z" }; 074 075 076 RelationTable<GenPolynomial<BigRational>> table; 077 078 079 RecSolvablePolynomialRing<BigRational> ring; 080 081 082 BigRational cfac; 083 084 085 GenSolvablePolynomialRing<GenPolynomial<BigRational>> sring; 086 087 088 GenSolvablePolynomialRing<BigRational> cring; 089 090 091 TermOrder tord = new TermOrder(TermOrder.INVLEX); 092 093 094 @Override 095 protected void setUp() { 096 cfac = new BigRational(1); 097 cring = new GenSolvablePolynomialRing<BigRational>(cfac, tord, cvars); 098 //sring = new GenSolvablePolynomialRing<GenPolynomial<BigRational>>(cring,rl,tord); 099 ring = new RecSolvablePolynomialRing<BigRational>(cring, tord, vars); 100 RelationGenerator<GenPolynomial<BigRational>> wl = new WeylRelations<GenPolynomial<BigRational>>(); 101 //wl.generate(ring); 102 ring.addRelations(wl); 103 table = ring.table; 104 a = b = c = d = e = null; 105 } 106 107 108 @Override 109 protected void tearDown() { 110 table = null; 111 ring = null; 112 a = b = c = d = e = null; 113 } 114 115 116 /** 117 * Test constructor, generators and properties. 118 */ 119 public void testConstructor() { 120 assertFalse("not commutative", ring.isCommutative()); 121 assertTrue("associative", ring.isAssociative()); 122 123 a = new RecSolvablePolynomial<BigRational>(ring); 124 assertTrue("length( a ) = 0", a.length() == 0); 125 assertTrue("isZERO( a )", a.isZERO()); 126 assertTrue("isONE( a )", !a.isONE()); 127 128 c = ring.getONE(); 129 assertTrue("length( c ) = 1", c.length() == 1); 130 assertTrue("isZERO( c )", !c.isZERO()); 131 assertTrue("isONE( c )", c.isONE()); 132 133 d = ring.getZERO(); 134 assertTrue("length( d ) = 0", d.length() == 0); 135 assertTrue("isZERO( d )", d.isZERO()); 136 assertTrue("isONE( d )", !d.isONE()); 137 //System.out.println("d = " + d); 138 139 //System.out.println(""); 140 for (GenPolynomial<GenPolynomial<BigRational>> g : ring.generators()) { 141 //System.out.print("g = " + g + ", "); 142 assertFalse("not isZERO( g )", g.isZERO()); 143 } 144 //System.out.println(""); 145 } 146 147 148 /** 149 * Test random polynomial. 150 */ 151 public void testRandom() { 152 for (int i = 0; i < 3; i++) { 153 // a = ring.random(ll+2*i); 154 a = ring.random(kl * (i + 1), ll + 2 * i, el + i, q); 155 //System.out.println("a = " + a); 156 assertTrue("length( a" + i + " ) <> 0", a.length() >= 0); 157 assertTrue(" not isZERO( a" + i + " )", !a.isZERO()); 158 assertTrue(" not isONE( a" + i + " )", !a.isONE()); 159 } 160 } 161 162 163 /** 164 * Test addition. 165 */ 166 public void testAddition() { 167 a = ring.random(kl, ll, el, q); 168 c = (RecSolvablePolynomial<BigRational>) a.subtract(a); 169 assertTrue("a-a = 0", c.isZERO()); 170 171 b = (RecSolvablePolynomial<BigRational>) a.sum(a); 172 c = (RecSolvablePolynomial<BigRational>) b.subtract(a); 173 assertEquals("a+a-a = a", c, a); 174 175 b = ring.random(kl, ll, el, q); 176 c = (RecSolvablePolynomial<BigRational>) b.sum(a); 177 d = (RecSolvablePolynomial<BigRational>) a.sum(b); 178 assertEquals("a+b = b+a", c, d); 179 180 c = ring.random(kl, ll, el, q); 181 d = (RecSolvablePolynomial<BigRational>) a.sum(b.sum(c)); 182 e = (RecSolvablePolynomial<BigRational>) a.sum(b).sum(c); 183 assertEquals("a+(b+c) = (a+b)+c", d, e); 184 //System.out.println("a = " + a); 185 //System.out.println("b = " + b); 186 //System.out.println("c = " + c); 187 //System.out.println("d = " + d); 188 //System.out.println("e = " + e); 189 190 ExpVector u = ExpVector.random(rl, el, q); 191 GenPolynomial<BigRational> x = cring.random(kl); 192 //System.out.println("x = " + x); 193 //System.out.println("u = " + u); 194 195 b = ring.getONE().multiply(x, u); 196 c = (RecSolvablePolynomial<BigRational>) a.sum(b); 197 d = (RecSolvablePolynomial<BigRational>) a.sum(x, u); 198 //System.out.println("a = " + a); 199 //System.out.println("b = " + b); 200 //System.out.println("c = " + c); 201 //System.out.println("d = " + d); 202 assertEquals("a+p(x,u) = a+(x,u)", c, d); 203 204 c = (RecSolvablePolynomial<BigRational>) a.subtract(b); 205 d = (RecSolvablePolynomial<BigRational>) a.subtract(x, u); 206 assertEquals("a-p(x,u) = a-(x,u)", c, d); 207 208 a = ring.getZERO(); 209 b = ring.getONE().multiply(x, u); 210 c = (RecSolvablePolynomial<BigRational>) b.sum(a); 211 d = (RecSolvablePolynomial<BigRational>) a.sum(x, u); 212 assertEquals("a+p(x,u) = a+(x,u)", c, d); 213 214 c = (RecSolvablePolynomial<BigRational>) a.subtract(b); 215 d = (RecSolvablePolynomial<BigRational>) a.subtract(x, u); 216 assertEquals("a-p(x,u) = a-(x,u)", c, d); 217 } 218 219 220 /** 221 * Test multiplication. 222 */ 223 public void testMultiplication() { 224 //System.out.println("ring = " + ring); 225 a = ring.random(kl, ll, el, q); 226 //a = ring.parse(" b y z + a w z "); 227 b = ring.random(kl, ll, el, q); 228 //b = ring.parse(" w x - b x "); 229 230 c = b.multiply(a); 231 d = a.multiply(b); 232 //System.out.println("a = " + a); 233 //System.out.println("b = " + b); 234 //System.out.println("c = " + c); 235 //System.out.println("d = " + d); 236 assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector())); 237 238 c = ring.random(kl, ll, el, q); 239 d = a.multiply(b.multiply(c)); 240 e = a.multiply(b).multiply(c); 241 assertEquals("a(bc) = (ab)c", d, e); 242 //System.out.println("a = " + a); 243 //System.out.println("b = " + b); 244 //System.out.println("c = " + c); 245 //System.out.println("d = " + d); 246 //System.out.println("e = " + e); 247 248 BigRational x = a.leadingBaseCoefficient().leadingBaseCoefficient().inverse(); 249 GenPolynomial<BigRational> xp = new GenPolynomial<BigRational>(cring, x); 250 d = (RecSolvablePolynomial<BigRational>) a.multiply(xp); 251 assertTrue("monic(a) = a*(1/ldcf(ldcf(a)))", 252 d.leadingBaseCoefficient().leadingBaseCoefficient().isONE()); 253 254 d = (RecSolvablePolynomial<BigRational>) a.monic(); 255 assertTrue("a.monic(): " + d.leadingBaseCoefficient() + ", " + a.leadingBaseCoefficient(), 256 d.leadingBaseCoefficient().isONE() || d.leadingBaseCoefficient() 257 .equals(a.leadingBaseCoefficient())); 258 } 259 260 261 /** 262 * Test commutative ring. 263 */ 264 public void testCommutative() { 265 //System.out.println("table = " + table.toString(vars)); 266 //System.out.println("table = " + table.toScript()); 267 //System.out.println("ring = " + ring); 268 //System.out.println("ring.table = " + ring.table.toScript()); 269 //assertEquals("table == ring.table: ", table, ring.table); // ? 270 assertTrue("# relations == 2", ring.table.size() == 2); 271 272 ring = new RecSolvablePolynomialRing<BigRational>(cring, ring); 273 //table = ring.table; 274 //System.out.println("table = " + table.toString(vars)); 275 //System.out.println("ring = " + ring); 276 277 assertTrue("isCommutative()", ring.isCommutative()); 278 assertTrue("isAssociative()", ring.isAssociative()); 279 280 a = ring.random(kl, ll, el, q); 281 //a = ring.parse(" b x y z + a w z "); 282 //System.out.println("a = " + a); 283 b = ring.random(kl, ll, el, q); 284 //b = ring.parse(" w y z - b x "); 285 //System.out.println("b = " + b); 286 287 // commutative 288 c = b.multiply(a); 289 //System.out.println("c = " + c); 290 d = a.multiply(b); 291 //d = ring.getONE(); 292 //System.out.println("d = " + d); 293 assertEquals("ba == ab: ", c, d); 294 } 295 296 297 /** 298 * Test distributive law. 299 */ 300 public void testDistributive() { 301 a = ring.random(kl, ll, el, q); 302 b = ring.random(kl, ll, el, q); 303 c = ring.random(kl, ll, el, q); 304 305 d = a.multiply((RecSolvablePolynomial<BigRational>) b.sum(c)); 306 e = (RecSolvablePolynomial<BigRational>) a.multiply(b).sum(a.multiply(c)); 307 assertEquals("a(b+c) = ab+ac", d, e); 308 } 309 310 311 /** 312 * Test solvable coefficient ring. 313 */ 314 public void testSolvableCoeffs() { 315 GenSolvablePolynomialRing<BigRational> csring = new GenSolvablePolynomialRing<BigRational>(cfac, tord, 316 cvars); 317 RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>(); 318 //wlc.generate(csring); 319 csring.addRelations(wlc); 320 assertTrue("# relations == 1", csring.table.size() == 1); 321 assertFalse("isCommutative()", csring.isCommutative()); 322 assertTrue("isAssociative()", csring.isAssociative()); 323 324 ring = new RecSolvablePolynomialRing<BigRational>(csring, ring); 325 RelationGenerator<GenPolynomial<BigRational>> wl = new WeylRelations<GenPolynomial<BigRational>>(); 326 //wl.generate(ring); 327 ring.addRelations(wl); 328 assertTrue("# relations == 2", ring.table.size() == 2); 329 assertFalse("isCommutative()", ring.isCommutative()); 330 assertTrue("isAssociative()", ring.isAssociative()); 331 332 RecSolvablePolynomial<BigRational> r1 = ring.parse("x"); 333 GenSolvablePolynomial<BigRational> r2 = csring.parse("b"); 334 RecSolvablePolynomial<BigRational> rp = ring.parse("b x + a"); 335 //System.out.println("r1 = " + r1); 336 //System.out.println("r2 = " + r2); 337 //System.out.println("rp = " + rp); 338 ring.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp); 339 340 table = ring.table; 341 //System.out.println("ring = " + ring); 342 343 assertFalse("isCommutative()", ring.isCommutative()); 344 assertTrue("isAssociative()", ring.isAssociative()); 345 346 List<GenPolynomial<GenPolynomial<BigRational>>> gens = ring.generators(); 347 for (GenPolynomial<GenPolynomial<BigRational>> x : gens) { 348 GenSolvablePolynomial<GenPolynomial<BigRational>> xx = (GenSolvablePolynomial<GenPolynomial<BigRational>>) x; 349 a = new RecSolvablePolynomial<BigRational>(ring, xx); 350 //System.out.println("a = " + a); 351 for (GenPolynomial<GenPolynomial<BigRational>> y : gens) { 352 GenSolvablePolynomial<GenPolynomial<BigRational>> yy = (GenSolvablePolynomial<GenPolynomial<BigRational>>) y; 353 b = new RecSolvablePolynomial<BigRational>(ring, yy); 354 //System.out.println("b = " + b); 355 c = a.multiply(b); 356 //System.out.println("gens:" + a + " * " + b + " = " + c); 357 ExpVector ev = a.leadingExpVector().sum(b.leadingExpVector()); 358 assertTrue("LT(a)*LT(b) == LT(c)", c.leadingExpVector().equals(ev)); 359 ev = a.leadingBaseCoefficient().leadingExpVector() 360 .sum(b.leadingBaseCoefficient().leadingExpVector()); 361 assertTrue("LT(a)*LT(b) == LT(c)", c.leadingBaseCoefficient().leadingExpVector().equals(ev)); 362 } 363 } 364 365 a = ring.random(kl, ll, el, q); 366 //a = ring.getONE(); 367 //System.out.println("a = " + a); 368 b = ring.random(kl, ll, el, q); 369 //b = ring.getONE(); 370 //System.out.println("b = " + b); 371 372 // non-commutative 373 c = b.multiply(a); 374 d = a.multiply(b); 375 //System.out.println("c = " + c); 376 //System.out.println("d = " + d); 377 assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector())); 378 379 // relation table list tests 380 //System.out.println("ring.table.rels = " + ring.table.relationList()); 381 //System.out.println("ring.coeffTable.rels = " + ring.coeffTable.relationList()); 382 383 RecSolvablePolynomialRing<BigRational> ring2 = new RecSolvablePolynomialRing<BigRational>(ring.coFac, 384 ring); 385 ring2.table.addSolvRelations(ring.table.relationList()); 386 ring2.coeffTable.addSolvRelations(ring.coeffTable.relationList()); 387 388 //System.out.println("ring2.table.rels = " + ring2.table.relationList()); 389 //System.out.println("ring2.coeffTable.rels = " + ring2.coeffTable.relationList()); 390 assertEquals("ring.table == ring2.table: ", ring.table, ring2.table); 391 assertEquals("ring.coeffTable == ring2.coeffTable: ", ring.coeffTable, ring2.coeffTable); 392 } 393 394 395 /** 396 * Test extension and contraction for Weyl relations. 397 */ 398 public void testExtendContractWeyl() { 399 GenSolvablePolynomialRing<BigRational> csring = new GenSolvablePolynomialRing<BigRational>(cfac, tord, 400 cvars); 401 RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>(); 402 //wlc.generate(csring); 403 csring.addRelations(wlc); 404 assertFalse("isCommutative()", csring.isCommutative()); 405 assertTrue("isAssociative()", csring.isAssociative()); 406 407 RecSolvablePolynomial<BigRational> r1 = ring.parse("x"); 408 GenSolvablePolynomial<BigRational> r2 = csring.parse("b"); 409 RecSolvablePolynomial<BigRational> rp = ring.parse("b x + a"); 410 ring.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp); 411 412 int k = rl; 413 RecSolvablePolynomialRing<BigRational> pfe = ring.extend(k); 414 //System.out.println("pfe = " + pfe); 415 RecSolvablePolynomialRing<BigRational> pfec = pfe.contract(k); 416 //System.out.println("pfec = " + pfec); 417 assertEquals("ring == pfec", ring, pfec); 418 419 RecSolvablePolynomial<BigRational> a = ring.random(kl, ll, el, q); 420 //System.out.println("a = " + a); 421 422 RecSolvablePolynomial<BigRational> ae = (RecSolvablePolynomial<BigRational>) a.extend(pfe, 0, 0); 423 //System.out.println("ae = " + ae); 424 425 Map<ExpVector, GenPolynomial<GenPolynomial<BigRational>>> m = ae.contract(pfec); 426 List<GenPolynomial<GenPolynomial<BigRational>>> ml = new ArrayList<GenPolynomial<GenPolynomial<BigRational>>>( 427 m.values()); 428 GenPolynomial<GenPolynomial<BigRational>> aec = ml.get(0); 429 //System.out.println("ae = " + ae); 430 //System.out.println("aec = " + aec); 431 assertEquals("a == aec", a, aec); 432 } 433 434 435 /** 436 * Test distribute and recursion for Weyl relations. 437 */ 438 @SuppressWarnings("unchecked") 439 public void testDistRecWeyl() { 440 GenSolvablePolynomialRing<BigRational> csring = new GenSolvablePolynomialRing<BigRational>(cfac, tord, 441 cvars); 442 RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>(); 443 csring.addRelations(wlc); 444 assertFalse("isCommutative()", csring.isCommutative()); 445 assertTrue("isAssociative()", csring.isAssociative()); 446 447 ring = new RecSolvablePolynomialRing<BigRational>(csring, tord, vars); 448 RelationGenerator<GenPolynomial<BigRational>> wl = new WeylRelations<GenPolynomial<BigRational>>(); 449 ring.addRelations(wl); 450 451 // first distribute solvable polynomial only 452 GenSolvablePolynomialRing<BigRational> fring = (GenSolvablePolynomialRing) ring; 453 GenSolvablePolynomialRing<BigRational> pfd = fring.distribute(); 454 //System.out.println("pfd = " + pfd.toScript()); 455 RecSolvablePolynomialRing<BigRational> pfdr = (RecSolvablePolynomialRing<BigRational>) pfd 456 .recursive(ring.nvar); 457 //System.out.println("pfdr = " + pfdr.toScript()); 458 //System.out.println("ring = " + ring.toScript()); 459 assertEquals("ring == pfdr", ring, pfdr); 460 461 RecSolvablePolynomial<BigRational> a = ring.random(kl, 2 * ll, el, 2.0f * q); 462 //System.out.println("a = " + a); 463 464 GenSolvablePolynomial<BigRational> ad = (GenSolvablePolynomial<BigRational>) PolyUtil 465 .<BigRational> distribute(pfd, a); 466 //System.out.println("ad = " + ad); 467 468 GenSolvablePolynomial<GenPolynomial<BigRational>> adr = (GenSolvablePolynomial<GenPolynomial<BigRational>>) PolyUtil 469 .<BigRational> recursive(pfdr, ad); 470 //System.out.println("adr = " + adr); 471 assertEquals("a == adr", a, adr); 472 473 // now recursive solvable polynials with coefficient relations: 474 RecSolvablePolynomial<BigRational> r1 = ring.parse("x"); 475 GenSolvablePolynomial<BigRational> r2 = csring.parse("b"); 476 RecSolvablePolynomial<BigRational> rp = ring.parse("b x + a"); 477 ring.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp); 478 //System.out.println("ring = " + ring.toScript()); 479 480 GenSolvablePolynomialRing<BigRational> pfrd = RecSolvablePolynomialRing 481 .<BigRational> distribute(ring); 482 //System.out.println("pfrd = " + pfrd.toScript()); 483 RecSolvablePolynomialRing<BigRational> pfrdr = (RecSolvablePolynomialRing<BigRational>) pfrd 484 .recursive(ring.nvar); 485 //System.out.println("pfrdr = " + pfrdr.toScript()); 486 //System.out.println("ring = " + ring.toScript()); 487 assertEquals("ring == pfrdr", ring, pfrdr); 488 489 //System.out.println("a = " + a); 490 ad = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> distribute(pfrd, a); 491 //System.out.println("ad = " + ad); 492 adr = (GenSolvablePolynomial<GenPolynomial<BigRational>>) PolyUtil.<BigRational> recursive(pfrdr, ad); 493 //System.out.println("adr = " + adr); 494 assertEquals("a == adr", a, adr); 495 } 496 497 498 /** 499 * Test reversion for Weyl relations. 500 */ 501 public void testReverseWeyl() { 502 GenSolvablePolynomialRing<BigRational> csring = new GenSolvablePolynomialRing<BigRational>(cfac, tord, 503 cvars); 504 RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>(); 505 //wlc.generate(csring); 506 csring.addRelations(wlc); 507 assertFalse("isCommutative()", csring.isCommutative()); 508 assertTrue("isAssociative()", csring.isAssociative()); 509 510 RecSolvablePolynomial<BigRational> r1 = ring.parse("x"); 511 GenSolvablePolynomial<BigRational> r2 = csring.parse("b"); 512 RecSolvablePolynomial<BigRational> rp = ring.parse("b x + a"); 513 ring.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp); 514 515 RecSolvablePolynomialRing<BigRational> pfr = ring.reverse(); 516 RecSolvablePolynomialRing<BigRational> pfrr = pfr.reverse(); 517 assertEquals("pf == pfrr", ring, pfrr); 518 //System.out.println("ring = " + ring); 519 //System.out.println("pfr = " + pfr); 520 521 RecSolvablePolynomial<BigRational> a = ring.random(kl, ll, el, q); 522 //System.out.println("a = " + a); 523 524 RecSolvablePolynomial<BigRational> ar = (RecSolvablePolynomial<BigRational>) a.reverse(pfr); 525 RecSolvablePolynomial<BigRational> arr = (RecSolvablePolynomial<BigRational>) ar.reverse(pfrr); 526 assertEquals("a == arr", a, arr); 527 //System.out.println("ar = " + ar); 528 //System.out.println("arr = " + arr); 529 } 530 531 532 /** 533 * Test recursive for Weyl relations. 534 */ 535 public void testRecursiveWeyl() { 536 String[] svars = new String[] { "w", "x", "y", "z" }; 537 GenSolvablePolynomialRing<BigRational> sring = new GenSolvablePolynomialRing<BigRational>(cfac, tord, 538 svars); 539 RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>(sring); 540 //wlc.generate(sring); 541 sring.addRelations(wlc); 542 assertFalse("isCommutative()", sring.isCommutative()); 543 assertTrue("isAssociative()", sring.isAssociative()); 544 //System.out.println("sring = " + sring.toScript()); 545 546 GenSolvablePolynomialRing<GenPolynomial<BigRational>> rsring = sring.recursive(2); // 1,2,3 547 //System.out.println("rsring = " + rsring.toScript()); 548 549 GenSolvablePolynomial<BigRational> ad, bd, cd, dd; 550 RecSolvablePolynomial<BigRational> ar, br, cr, dr; 551 ad = sring.random(kl, ll, el, q); 552 bd = sring.random(kl, ll, el, q); 553 //ad = sring.parse("7/2 y^2 * z"); // - 15/2 w^2 + 262/225"); 554 //bd = sring.parse("-10/13 x "); //+ 413/150"); 555 //ad = (GenSolvablePolynomial<BigRational>) ad.monic(); 556 //bd = (GenSolvablePolynomial<BigRational>) bd.monic(); 557 558 //System.out.println("ad = " + ad); 559 //System.out.println("bd = " + bd); 560 561 cd = ad.multiply(bd); 562 //System.out.println("cd = " + cd); 563 564 ar = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, ad); 565 br = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, bd); 566 //System.out.println("ar = " + ar); 567 //System.out.println("br = " + br); 568 569 cr = ar.multiply(br); 570 //System.out.println("cr = " + cr); 571 //System.out.println("cr.ring = " + cr.ring.toScript()); 572 573 dr = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, cd); 574 //System.out.println("dr = " + dr); 575 576 assertEquals("dr.ring == cr.ring", dr.ring, cr.ring); 577 assertEquals("dr == cr", dr, cr); 578 579 dd = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> distribute(sring, cr); 580 //System.out.println("dd = " + dd); 581 assertEquals("dd == cd", dd, cd); 582 } 583 584 585 /** 586 * Test recursive for iterated Weyl relations. 587 */ 588 public void testRecursiveIteratedWeyl() { 589 String[] svars = new String[] { "w", "x", "y", "z" }; 590 GenSolvablePolynomialRing<BigRational> sring = new GenSolvablePolynomialRing<BigRational>(cfac, tord, 591 svars); 592 RelationGenerator<BigRational> wlc = new WeylRelationsIterated<BigRational>(); 593 //wlc.generate(sring); 594 sring.addRelations(wlc); 595 assertFalse("isCommutative()", sring.isCommutative()); 596 assertTrue("isAssociative()", sring.isAssociative()); 597 //System.out.println("sring = " + sring.toScript()); 598 599 GenSolvablePolynomialRing<GenPolynomial<BigRational>> rsring = sring.recursive(2); // 1,2,3 600 //System.out.println("rsring = " + rsring); //.toScript()); 601 //System.out.println("rsring = " + rsring.toScript()); 602 603 GenSolvablePolynomial<BigRational> ad, bd, cd, dd; 604 RecSolvablePolynomial<BigRational> ar, br, cr, dr; 605 ad = sring.random(kl, ll, el, q); 606 bd = sring.random(kl, ll, el, q); 607 //ad = (GenSolvablePolynomial<BigRational>) ad.monic(); 608 //bd = (GenSolvablePolynomial<BigRational>) bd.monic(); 609 610 //System.out.println("ad = " + ad); 611 //System.out.println("bd = " + bd); 612 613 cd = ad.multiply(bd); 614 //System.out.println("cd = " + cd); 615 616 ar = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, ad); 617 br = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, bd); 618 //System.out.println("ar = " + ar); 619 //System.out.println("br = " + br); 620 621 cr = ar.multiply(br); 622 //System.out.println("cr = " + cr); 623 624 dr = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, cd); 625 //System.out.println("dr = " + dr); 626 627 assertEquals("dr.ring == cr.ring", dr.ring, cr.ring); 628 assertEquals("dr == cr", dr, cr); 629 630 dd = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> distribute(sring, cr); 631 //System.out.println("dd = " + dd); 632 assertEquals("dd == cd", dd, cd); 633 } 634 635 636 /** 637 * Test right recursive representation. 638 */ 639 public void testRightRecursive() { 640 String[] svars = new String[] { "w", "x", "y", "z" }; 641 GenSolvablePolynomialRing<BigRational> sring = new GenSolvablePolynomialRing<BigRational>(cfac, tord, 642 svars); 643 RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>(); 644 //wlc.generate(sring); 645 sring.addRelations(wlc); 646 assertFalse("isCommutative()", sring.isCommutative()); 647 assertTrue("isAssociative()", sring.isAssociative()); 648 //System.out.println("sring = " + sring.toScript()); 649 650 GenSolvablePolynomialRing<GenPolynomial<BigRational>> rsring = sring.recursive(2); // 1,2,3 651 //System.out.println("rsring = " + rsring.toScript()); 652 653 a = (RecSolvablePolynomial<BigRational>) rsring.random(kl, ll, el, q); 654 //System.out.println("a = " + a); 655 d = (RecSolvablePolynomial<BigRational>) a.rightRecursivePolynomial(); 656 //System.out.println("d = " + d); 657 e = (RecSolvablePolynomial<BigRational>) d.evalAsRightRecursivePolynomial(); 658 //System.out.println("e = " + e); 659 660 assertEquals("eval(right(a)) == a", a, e); 661 assertTrue("d == isRight(right(a))", a.isRightRecursivePolynomial(d)); 662 663 GenSolvablePolynomial<GenPolynomial<BigRational>> ar, dr, er; 664 ar = rsring.random(kl, ll, el, q); 665 //System.out.println("ar = " + ar); 666 dr = ar.rightRecursivePolynomial(); 667 //System.out.println("dr = " + dr); 668 er = dr.evalAsRightRecursivePolynomial(); 669 //System.out.println("er = " + er); 670 671 assertEquals("eval(right(ar)) == ar", ar, er); 672 assertTrue("dr == isRight(right(ar))", ar.isRightRecursivePolynomial(dr)); 673 } 674 675}