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