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