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