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