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