001/* 002 * $Id$ 003 */ 004 005package edu.jas.gbufd; 006 007 008import java.util.ArrayList; 009import java.util.List; 010 011import edu.jas.arith.BigInteger; 012import edu.jas.kern.ComputerThreads; 013import edu.jas.poly.GenSolvablePolynomial; 014import edu.jas.poly.GenSolvablePolynomialRing; 015import edu.jas.poly.PolynomialList; 016import edu.jas.poly.RelationGenerator; 017import edu.jas.poly.RelationTable; 018import edu.jas.poly.WeylRelations; 019import edu.jas.util.ListUtil; 020 021import junit.framework.Test; 022import junit.framework.TestCase; 023import junit.framework.TestSuite; 024 025 026/** 027 * Solvable Reduction tests with JUnit. 028 * @author Heinz Kredel 029 */ 030 031public class SolvablePseudoReductionTest extends TestCase { 032 033 034 /** 035 * main 036 */ 037 public static void main(String[] args) { 038 junit.textui.TestRunner.run(suite()); 039 ComputerThreads.terminate(); 040 } 041 042 043 /** 044 * Constructs a <CODE>SolvablePseudoReductionTest</CODE> object. 045 * @param name String. 046 */ 047 public SolvablePseudoReductionTest(String name) { 048 super(name); 049 } 050 051 052 /** 053 * suite. 054 */ 055 public static Test suite() { 056 TestSuite suite = new TestSuite(SolvablePseudoReductionTest.class); 057 return suite; 058 } 059 060 061 GenSolvablePolynomialRing<BigInteger> fac; 062 063 064 RelationTable table; 065 066 067 GenSolvablePolynomial<BigInteger> a, b, c, d, e, f, g, h; 068 069 070 List<GenSolvablePolynomial<BigInteger>> L; 071 072 073 PolynomialList<BigInteger> F, G; 074 075 076 SolvablePseudoReduction<BigInteger> sred; 077 078 079 //SolvablePseudoReduction<BigInteger> sredpar; 080 081 082 int rl = 4; 083 084 085 int kl = 10; 086 087 088 int ll = 5; 089 090 091 int el = 3; 092 093 094 float q = 0.4f; 095 096 097 @Override 098 protected void setUp() { 099 a = b = c = d = e = null; 100 String[] vars = new String[] { "w", "x", "y", "z" }; 101 fac = new GenSolvablePolynomialRing<BigInteger>(new BigInteger(0), vars); 102 sred = new SolvablePseudoReductionSeq<BigInteger>(); 103 //sredpar = new SolvablePseudoReductionPar<BigInteger>(); 104 } 105 106 107 @Override 108 protected void tearDown() { 109 a = b = c = d = e = null; 110 fac = null; 111 sred = null; 112 //sredpar = null; 113 } 114 115 116 /** 117 * Test constants and empty list reduction. 118 */ 119 public void testIntReduction0() { 120 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 121 122 a = fac.random(kl, ll, el, q); 123 c = fac.getONE(); 124 d = fac.getZERO(); 125 126 e = sred.leftNormalform(L, c); 127 assertTrue("isONE( e )", e.isONE()); 128 129 e = sred.leftNormalform(L, d); 130 assertTrue("isZERO( e )", e.isZERO()); 131 132 133 L.add(c); 134 e = sred.leftNormalform(L, c); 135 assertTrue("isZERO( e )", e.isZERO()); 136 137 e = sred.leftNormalform(L, a); 138 assertTrue("isZERO( e )", e.isZERO()); 139 140 e = sred.leftNormalform(L, d); 141 assertTrue("isZERO( e )", e.isZERO()); 142 143 144 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 145 L.add(d); 146 e = sred.leftNormalform(L, c); 147 assertTrue("isONE( e )", e.isONE()); 148 149 e = sred.leftNormalform(L, d); 150 assertTrue("isZERO( e )", e.isZERO()); 151 } 152 153 154 /** 155 * Test constants and empty list reduction. 156 */ 157 public void testWeylIntReduction0() { 158 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 159 RelationGenerator<BigInteger> wl = new WeylRelations<BigInteger>(); 160 wl.generate(fac); 161 162 a = fac.random(kl, ll, el, q); 163 c = fac.getONE(); 164 d = fac.getZERO(); 165 166 e = sred.leftNormalform(L, c); 167 assertTrue("isONE( e )", e.isONE()); 168 169 e = sred.leftNormalform(L, d); 170 assertTrue("isZERO( e )", e.isZERO()); 171 172 173 L.add(c); 174 e = sred.leftNormalform(L, c); 175 assertTrue("isZERO( e )", e.isZERO()); 176 177 e = sred.leftNormalform(L, a); 178 assertTrue("isZERO( e )", e.isZERO()); 179 180 e = sred.leftNormalform(L, d); 181 assertTrue("isZERO( e )", e.isZERO()); 182 183 184 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 185 L.add(d); 186 e = sred.leftNormalform(L, c); 187 assertTrue("isONE( e )", e.isONE()); 188 189 e = sred.leftNormalform(L, d); 190 assertTrue("isZERO( e )", e.isZERO()); 191 } 192 193 194 /** 195 * Test Int reduction. 196 */ 197 public void testIntReduction() { 198 a = fac.random(kl, ll, el, q); 199 b = fac.random(kl, ll, el, q); 200 201 assertTrue("not isZERO( a )", !a.isZERO()); 202 203 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 204 L.add(a); 205 206 e = sred.leftNormalform(L, a); 207 assertTrue("isZERO( e )", e.isZERO()); 208 209 assertTrue("not isZERO( b )", !b.isZERO()); 210 211 L.add(b); 212 e = sred.leftNormalform(L, a); 213 assertTrue("isZERO( e ) some times", e.isZERO()); 214 } 215 216 217 /** 218 * Test Weyl Integer reduction. 219 */ 220 public void testWeylIntReduction() { 221 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 222 223 RelationGenerator<BigInteger> wl = new WeylRelations<BigInteger>(); 224 wl.generate(fac); 225 226 a = fac.random(kl, ll, el, q); 227 b = fac.random(kl, ll, el, q); 228 229 assertTrue("not isZERO( a )", !a.isZERO()); 230 231 L.add(a); 232 233 e = sred.leftNormalform(L, a); 234 assertTrue("isZERO( e )", e.isZERO()); 235 236 assertTrue("not isZERO( b )", !b.isZERO()); 237 238 L.add(b); 239 e = sred.leftNormalform(L, a); 240 assertTrue("isZERO( e ) some times", e.isZERO()); 241 } 242 243 244 /** 245 * Test Int reduction recording. 246 */ 247 public void testIntReductionRecording() { 248 List<GenSolvablePolynomial<BigInteger>> row = null; 249 PseudoReductionEntry<BigInteger> mf; 250 251 a = fac.random(kl, ll, el, q); 252 b = fac.random(kl, ll, el, q); 253 c = fac.random(kl, ll, el, q); 254 d = fac.random(kl, ll, el, q); 255 256 assertTrue("not isZERO( a )", !a.isZERO()); 257 258 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 259 260 L.add(a); 261 mf = sred.leftNormalformFactor(L, a); 262 f = a.multiply(mf.multiplicator); 263 row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO()); 264 //d = sred.leftNormalform( row, L, a ); 265 d = sred.leftNormalform(row, L, f); 266 assertTrue("isZERO( d )", d.isZERO()); 267 assertTrue("is leftReduction ", sred.isLeftReductionNF(row, L, f, d)); 268 269 L.add(b); 270 mf = sred.leftNormalformFactor(L, b); 271 f = b.multiply(mf.multiplicator); 272 row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO()); 273 //e = sred.leftNormalform( row, L, b ); 274 d = sred.leftNormalform(row, L, f); 275 assertTrue("is leftReduction ", sred.isLeftReductionNF(row, L, f, d)); 276 277 L.add(c); 278 mf = sred.leftNormalformFactor(L, c); 279 f = c.multiply(mf.multiplicator); 280 row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO()); 281 d = sred.leftNormalform(row, L, f); 282 assertTrue("is leftReduction ", sred.isLeftReductionNF(row, L, f, d)); 283 284 L.add(d); 285 mf = sred.leftNormalformFactor(L, d); 286 f = d.multiply(mf.multiplicator); 287 row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO()); 288 e = sred.leftNormalform(row, L, f); 289 assertTrue("is leftReduction ", sred.isLeftReductionNF(row, L, f, e)); 290 } 291 292 293 /* 294 * Test Int reduction parallel. 295 public void testIntReductionPar() { 296 a = fac.random(kl, ll, el, q ); 297 b = fac.random(kl, ll, el, q ); 298 299 assertTrue("not isZERO( a )", !a.isZERO() ); 300 301 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 302 L.add(a); 303 304 e = sredpar.leftNormalform( L, a ); 305 assertTrue("isZERO( e )", e.isZERO() ); 306 307 assertTrue("not isZERO( b )", !b.isZERO() ); 308 309 L.add(b); 310 e = sredpar.leftNormalform( L, a ); 311 assertTrue("isZERO( e ) some times", e.isZERO() ); 312 } 313 */ 314 315 316 /* 317 * Test Weyl Integer reduction parallel. 318 public void testWeylIntReductionPar() { 319 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 320 321 RelationGenerator<BigInteger> wl = new WeylRelations<BigInteger>(); 322 wl.generate(fac); 323 324 a = fac.random(kl, ll, el, q ); 325 b = fac.random(kl, ll, el, q ); 326 327 assertTrue("not isZERO( a )", !a.isZERO() ); 328 329 L.add(a); 330 331 e = sredpar.leftNormalform( L, a ); 332 assertTrue("isZERO( e )", e.isZERO() ); 333 334 assertTrue("not isZERO( b )", !b.isZERO() ); 335 336 L.add(b); 337 e = sredpar.leftNormalform( L, a ); 338 assertTrue("isZERO( e ) some times", e.isZERO() ); 339 } 340 */ 341 342 343 /** 344 * Right test constants and empty list reduction. 345 */ 346 public void testIntRightReduction0() { 347 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 348 349 a = fac.random(kl, ll, el, q); 350 c = fac.getONE(); 351 d = fac.getZERO(); 352 353 e = sred.rightNormalform(L, c); 354 assertTrue("isONE( e )", e.isONE()); 355 356 e = sred.rightNormalform(L, d); 357 assertTrue("isZERO( e )", e.isZERO()); 358 359 360 L.add(c); 361 e = sred.rightNormalform(L, c); 362 assertTrue("isZERO( e )", e.isZERO()); 363 364 e = sred.rightNormalform(L, a); 365 assertTrue("isZERO( e )", e.isZERO()); 366 367 e = sred.rightNormalform(L, d); 368 assertTrue("isZERO( e )", e.isZERO()); 369 370 371 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 372 L.add(d); 373 e = sred.rightNormalform(L, c); 374 assertTrue("isONE( e )", e.isONE()); 375 376 e = sred.rightNormalform(L, d); 377 assertTrue("isZERO( e )", e.isZERO()); 378 } 379 380 381 /** 382 * Right test constants and empty list reduction. 383 */ 384 public void testWeylIntRightReduction0() { 385 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 386 RelationGenerator<BigInteger> wl = new WeylRelations<BigInteger>(); 387 wl.generate(fac); 388 389 a = fac.random(kl, ll, el, q); 390 c = fac.getONE(); 391 d = fac.getZERO(); 392 393 e = sred.rightNormalform(L, c); 394 assertTrue("isONE( e )", e.isONE()); 395 396 e = sred.rightNormalform(L, d); 397 assertTrue("isZERO( e )", e.isZERO()); 398 399 400 L.add(c); 401 e = sred.rightNormalform(L, c); 402 assertTrue("isZERO( e )", e.isZERO()); 403 404 e = sred.rightNormalform(L, a); 405 assertTrue("isZERO( e )", e.isZERO()); 406 407 e = sred.rightNormalform(L, d); 408 assertTrue("isZERO( e )", e.isZERO()); 409 410 411 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 412 L.add(d); 413 e = sred.rightNormalform(L, c); 414 assertTrue("isONE( e )", e.isONE()); 415 416 e = sred.rightNormalform(L, d); 417 assertTrue("isZERO( e )", e.isZERO()); 418 } 419 420 421 /** 422 * Right test Int reduction. 423 */ 424 public void testIntRightReduction() { 425 a = fac.random(kl, ll, el, q); 426 b = fac.random(kl, ll, el, q); 427 assertTrue("not isZERO( a )", !a.isZERO()); 428 429 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 430 L.add(a); 431 432 e = sred.rightNormalform(L, a); 433 assertTrue("isZERO( e )", e.isZERO()); 434 435 assertTrue("not isZERO( b )", !b.isZERO()); 436 437 L.add(b); 438 e = sred.rightNormalform(L, a); 439 assertTrue("isZERO( e ) some times", e.isZERO()); 440 } 441 442 443 /** 444 * Right test Weyl Integer reduction. 445 */ 446 public void testWeylIntRightReduction() { 447 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 448 449 RelationGenerator<BigInteger> wl = new WeylRelations<BigInteger>(); 450 wl.generate(fac); 451 452 a = fac.random(kl, ll, el, q); 453 b = fac.random(kl, ll, el, q); 454 455 assertTrue("not isZERO( a )", !a.isZERO()); 456 457 L.add(a); 458 459 e = sred.rightNormalform(L, a); 460 assertTrue("isZERO( e )", e.isZERO()); 461 462 assertTrue("not isZERO( b )", !b.isZERO()); 463 464 L.add(b); 465 e = sred.rightNormalform(L, a); 466 assertTrue("isZERO( e ) some times", e.isZERO()); 467 } 468 469 470 /** 471 * Right test Int reduction recording. 472 */ 473 public void testIntRightReductionRecording() { 474 List<GenSolvablePolynomial<BigInteger>> row = null; 475 PseudoReductionEntry<BigInteger> mf; 476 477 a = fac.random(kl, ll, el, q); 478 b = fac.random(kl, ll, el, q); 479 c = fac.random(kl, ll, el, q); 480 d = fac.random(kl, ll, el, q); 481 482 assertTrue("not isZERO( a )", !a.isZERO()); 483 484 L = new ArrayList<GenSolvablePolynomial<BigInteger>>(); 485 486 L.add(a); 487 mf = sred.rightNormalformFactor(L, a); 488 f = a.multiply(mf.multiplicator); 489 row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO()); 490 //d = sred.rightNormalform( row, L, a ); 491 d = sred.rightNormalform(row, L, f); 492 assertTrue("isZERO( d )", d.isZERO()); 493 assertTrue("is rightReduction ", sred.isRightReductionNF(row, L, f, d)); 494 495 L.add(b); 496 mf = sred.rightNormalformFactor(L, b); 497 f = b.multiply(mf.multiplicator); 498 row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO()); 499 //e = sred.rightNormalform( row, L, b ); 500 d = sred.rightNormalform(row, L, f); 501 assertTrue("is rightReduction ", sred.isRightReductionNF(row, L, f, d)); 502 503 L.add(c); 504 mf = sred.rightNormalformFactor(L, c); 505 f = c.multiply(mf.multiplicator); 506 row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO()); 507 d = sred.rightNormalform(row, L, f); 508 assertTrue("is rightReduction ", sred.isRightReductionNF(row, L, f, d)); 509 510 L.add(d); 511 mf = sred.rightNormalformFactor(L, d); 512 f = d.multiply(mf.multiplicator); 513 row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO()); 514 e = sred.rightNormalform(row, L, f); 515 assertTrue("is rightReduction ", sred.isRightReductionNF(row, L, f, e)); 516 } 517 518}