001/* 002 * $Id$ 003 */ 004 005package edu.jas.fd; 006 007 008import edu.jas.arith.BigQuaternion; 009import edu.jas.arith.BigQuaternionRing; 010import edu.jas.kern.ComputerThreads; 011import edu.jas.poly.GenPolynomial; 012import edu.jas.poly.GenSolvablePolynomial; 013import edu.jas.poly.GenSolvablePolynomialRing; 014import edu.jas.poly.PolyUtil; 015import edu.jas.poly.RecSolvablePolynomial; 016import edu.jas.poly.RecSolvablePolynomialRing; 017import edu.jas.poly.RelationGenerator; 018import edu.jas.poly.TermOrder; 019import edu.jas.poly.TermOrderByName; 020import edu.jas.poly.WeylRelationsIterated; 021 022import junit.framework.Test; 023import junit.framework.TestCase; 024import junit.framework.TestSuite; 025 026 027/** 028 * GCD Primitive PRS algorithm tests with JUnit. <b>Note:</b> eventually not in 029 * sync with implementation. 030 * @author Heinz Kredel 031 */ 032 033public class GCDPrimitiveQuatTest extends TestCase { 034 035 036 /** 037 * main. 038 */ 039 public static void main(String[] args) { 040 junit.textui.TestRunner.run(suite()); 041 ComputerThreads.terminate(); 042 } 043 044 045 /** 046 * Constructs a <CODE>GCDPrimitiveQuatTest</CODE> object. 047 * @param name String. 048 */ 049 public GCDPrimitiveQuatTest(String name) { 050 super(name); 051 } 052 053 054 /** 055 */ 056 public static Test suite() { 057 TestSuite suite = new TestSuite(GCDPrimitiveQuatTest.class); 058 return suite; 059 } 060 061 062 GreatestCommonDivisorAbstract<BigQuaternion> fd; 063 064 065 TermOrder to = TermOrderByName.INVLEX; 066 067 068 GenSolvablePolynomialRing<BigQuaternion> qfac; 069 070 071 //GenSolvablePolynomialRing<GenPolynomial<BigQuaternion>> rfac; 072 RecSolvablePolynomialRing<BigQuaternion> rfac; 073 074 075 GenSolvablePolynomial<BigQuaternion> a, b, a0, b0, c, d, e, f; 076 077 078 GenSolvablePolynomial<GenPolynomial<BigQuaternion>> ar, br, cr, dr, er, ar0, br0; 079 080 081 int rl = 4; 082 083 084 int kl = 2; 085 086 087 int ll = 2; 088 089 090 int el = 3; 091 092 093 float q = 0.25f; 094 095 096 @Override 097 protected void setUp() { 098 a = b = c = d = e = null; 099 ar = br = cr = dr = er = null; 100 String[] vars = new String[] { "a", "b", "c", "d" }; 101 BigQuaternionRing cf = new BigQuaternionRing(); 102 fd = new GreatestCommonDivisorPrimitive<BigQuaternion>(cf); 103 //System.out.println("fd = " + fd); 104 qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, vars); 105 RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>(); 106 //qfac.addRelations(wl); 107 rfac = (RecSolvablePolynomialRing<BigQuaternion>) qfac.recursive(1); 108 //System.out.println("qfac = " + qfac); 109 //System.out.println("rfac = " + rfac); 110 } 111 112 113 @Override 114 protected void tearDown() { 115 a = b = c = d = e = null; 116 ar = br = cr = dr = er = null; 117 fd = null; 118 qfac = null; 119 rfac = null; 120 } 121 122 123 /** 124 * Test quaternion base gcd simple. 125 */ 126 public void testQuatBaseGcdPrimitive() { 127 String[] uvars = new String[] { "x" }; 128 BigQuaternionRing cf = new BigQuaternionRing(); 129 qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, uvars); 130 //System.out.println("qfac = " + qfac.toScript()); 131 for (int i = 0; i < 3; i++) { 132 //System.out.println(); 133 a = qfac.random(kl + (i), ll + 2 * i, el + 2, q); 134 a = (GenSolvablePolynomial<BigQuaternion>) a.sum(qfac.univariate(0).power(2)); 135 b = qfac.random(kl + (i + 1), ll + i, el + 2, q); 136 b = (GenSolvablePolynomial<BigQuaternion>) b.sum(qfac.univariate(0)); 137 c = qfac.random(kl + (i + 1), ll + 1, el + 1, q); 138 c = c.multiply(qfac.univariate(0)); 139 if (a.isZERO() || b.isZERO() || c.isZERO()) { 140 // skip for this turn 141 continue; 142 } 143 a = a.monic(); 144 b = b.monic(); 145 c = c.monic(); 146 //a = fd.basePrimitivePart(a); 147 //b = fd.basePrimitivePart(b); 148 //c = (GenSolvablePolynomial<BigQuaternion>) fd.basePrimitivePart(c).abs(); 149 //System.out.println("a = " + a); 150 //System.out.println("b = " + b); 151 //System.out.println("c = " + c); 152 153 a = a.multiply(c); 154 b = b.multiply(c); 155 //a = c.multiply(a); 156 //b = c.multiply(b); 157 //System.out.println("a = " + a); 158 //System.out.println("b = " + b); 159 160 d = fd.leftBaseGcd(a, b); 161 //System.out.println("d = " + d); 162 //System.out.println("c = " + c); 163 164 e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(a, d); 165 //System.out.println("e = " + e); 166 assertTrue("gcd(ca,cb) | ca " + e, e.isZERO()); 167 168 e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(b, d); 169 //System.out.println("e = " + e); 170 assertTrue("gcd(ca,cb) | cb " + e, e.isZERO()); 171 172 // todo 173 //e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(d, c); 174 e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(c, d); 175 //System.out.println("e = " + e); 176 assertTrue("c | gcd(ca,cb) " + e, e.isZERO()); 177 } 178 } 179 180 181 /** 182 * Test quaternion univariate recursive left gcd simple. 183 */ 184 //@SuppressWarnings("cast") 185 public void testRecursiveLeftGCDPrimitive() { 186 String[] vars = new String[] { "a", "b" }; 187 BigQuaternionRing cf = new BigQuaternionRing(); 188 //GenSolvablePolynomialRing<BigQuaternion> qfac; 189 qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, vars); 190 //System.out.println("qfac = " + qfac.toScript()); 191 192 RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>(); 193 //qfac.addRelations(wl); 194 //System.out.println("qfac = " + qfac.toScript()); 195 rfac = (RecSolvablePolynomialRing<BigQuaternion>) qfac.recursive(1); 196 //System.out.println("rfac = " + rfac.toScript()); 197 198 GreatestCommonDivisorAbstract<BigQuaternion> fd = new GreatestCommonDivisorPrimitive<BigQuaternion>(cf); 199 //System.out.println("fd = " + fd); 200 201 //kl = 3; 202 int ll = 3; 203 int el = 3; 204 205 ar = rfac.random(kl, ll, el, q); 206 br = rfac.random(kl, ll, el, q); 207 cr = rfac.random(kl, ll, el, q); 208 ////cr = (RecSolvablePolynomial<BigQuaternion>) cr.abs(); 209 //cr = PolyUtil.<BigQuaternion> monic(cr); // leftMonic 210 //cr = (RecSolvablePolynomial<BigQuaternion>) fd.recursivePrimitivePart(cr).abs(); 211 //System.out.println("ar = " + ar); 212 //System.out.println("br = " + br); 213 214 if (cr.isConstant()) { 215 er = rfac.univariate(0); 216 System.out.println("univ(0) = " + er); 217 cr = (RecSolvablePolynomial<BigQuaternion>) cr.sum(er); 218 } 219 //System.out.println("cr = " + cr); 220 221 //ar0 = ar; 222 //br0 = br; 223 //ar = cr.multiply(ar); 224 //br = cr.multiply(br); 225 ar = ar.multiply(cr); 226 br = br.multiply(cr); 227 //System.out.println("ar = " + ar); 228 //System.out.println("br = " + br); 229 230 dr = fd.leftRecursiveUnivariateGcd(ar, br); 231 //System.out.println("cr_r = " + cr); 232 //System.out.println("dr_r = " + dr); 233 //dr = PolyUtil.<BigQuaternion> monic(dr); // leftMonic 234 //System.out.println("monic(dr_r) = " + dr); 235 236 er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(dr, cr); 237 //System.out.println("er = " + er); 238 assertTrue("c | gcd(ac,bc) " + er, er.isZERO()); 239 240 er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(ar, dr); 241 //System.out.println("er = " + er); 242 assertTrue("gcd(a,b) | a " + er, er.isZERO()); 243 244 er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(br, dr); 245 //System.out.println("er = " + er); 246 assertTrue("gcd(a,b) | b " + er, er.isZERO()); 247 } 248 249 250 /** 251 * Test quaternion univariate recursive left gcd simple Weyl. 252 */ 253 //@SuppressWarnings("cast") 254 public void testRecursiveLeftGCDPrimitiveWeyl() { 255 String[] vars = new String[] { "a", "b" }; 256 BigQuaternionRing cf = new BigQuaternionRing(); 257 //GenSolvablePolynomialRing<BigQuaternion> qfac; 258 qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, vars); 259 //System.out.println("qfac = " + qfac.toScript()); 260 261 RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>(); 262 qfac.addRelations(wl); 263 //System.out.println("qfac = " + qfac.toScript()); 264 rfac = (RecSolvablePolynomialRing<BigQuaternion>) qfac.recursive(1); 265 //System.out.println("rfac = " + rfac.toScript()); 266 267 GreatestCommonDivisorAbstract<BigQuaternion> fd = new GreatestCommonDivisorPrimitive<BigQuaternion>(cf); 268 //System.out.println("fd = " + fd); 269 270 //kl = 3; 271 ll = 2; 272 el = 3; 273 274 ar = rfac.random(kl, ll, el + 1, q); 275 br = rfac.random(kl, ll, el, q); 276 cr = rfac.random(kl, ll, el, q); 277 ////cr = (RecSolvablePolynomial<BigQuaternion>) cr.abs(); 278 ///cr = PolyUtil.<BigQuaternion> monic(cr); // leftMonic 279 //cr = (RecSolvablePolynomial<BigQuaternion>) fd.recursivePrimitivePart(cr).abs(); 280 //System.out.println("ar = " + ar); 281 //System.out.println("br = " + br); 282 283 if (cr.isConstant()) { 284 er = rfac.univariate(0); 285 System.out.println("univ(0) = " + er); 286 cr = (RecSolvablePolynomial<BigQuaternion>) cr.sum(er); 287 } 288 //System.out.println("cr = " + cr); 289 290 //ar0 = ar; 291 //br0 = br; 292 //ar = cr.multiply(ar); 293 //br = cr.multiply(br); 294 ar = ar.multiply(cr); 295 br = br.multiply(cr); 296 //System.out.println("ar = " + ar); 297 //System.out.println("br = " + br); 298 299 dr = fd.leftRecursiveUnivariateGcd(ar, br); 300 //System.out.println("cr_w = " + cr); 301 //System.out.println("dr_w = " + dr); 302 //dr = PolyUtil.<BigQuaternion> monic(dr); // leftMonic 303 //System.out.println("monic(dr_w) = " + dr); 304 305 er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(dr, cr); 306 //System.out.println("er = " + er); 307 assertTrue("c | gcd(ac,bc) " + er, er.isZERO()); 308 309 er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(ar, dr); 310 //System.out.println("er = " + er); 311 assertTrue("gcd(a,b) | a " + er, er.isZERO()); 312 313 er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(br, dr); 314 //System.out.println("er = " + er); 315 assertTrue("gcd(a,b) | b " + er, er.isZERO()); 316 } 317 318 319 /** 320 * Test 3 vars arbitrary recursive gcd simple. 321 */ 322 @SuppressWarnings("cast") 323 public void testArbitrary3RecursiveGCDPrimitive() { 324 String[] cvars = new String[] { "a", "b" }; 325 String[] vars = new String[] { "c" }; 326 BigQuaternionRing cf = new BigQuaternionRing(); 327 qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, cvars); 328 RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>(); 329 //dfac.addRelations(wl); 330 //System.out.println("qfac = " + qfac.toScript()); 331 rfac = new RecSolvablePolynomialRing<BigQuaternion>(qfac, to, vars); 332 //System.out.println("rfac = " + rfac.toScript()); 333 334 //kl = 3; 335 int ll = 2; 336 int el = 2; 337 338 ar0 = rfac.random(kl, ll, el, q); 339 br0 = rfac.random(kl, ll, el, q); 340 cr = rfac.random(kl, ll, el, q); 341 342 //ar0 = rfac.parse(" "); 343 //br0 = rfac.parse(" "); 344 //cr = rfac.parse(" "); 345 346 //cr = (RecSolvablePolynomial<BigQuaternion>) fd.recursivePrimitivePart(cr).abs(); 347 //cr = (RecSolvablePolynomial<BigQuaternion>) cr.monic(); 348 if (cr.isZERO()) { 349 cr = rfac.getONE(); 350 } 351 if (cr.isConstant()) { 352 er = rfac.univariate(0); 353 System.out.println("univ(0) = " + er); 354 cr = (RecSolvablePolynomial<BigQuaternion>) cr.sum(er); 355 } 356 //System.out.println("ar = " + ar); 357 //System.out.println("br = " + br); 358 //System.out.println("cr = " + cr); 359 360 // left gcd 361 ar = ar0.multiply(cr); 362 br = br0.multiply(cr); 363 //System.out.println("ar = " + ar); 364 //System.out.println("br = " + br); 365 366 dr = fd.leftRecursiveGcd(ar, br); 367 //System.out.println("cr = " + cr); 368 //System.out.println("dr = " + dr); 369 370 er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(dr, cr); 371 //System.out.println("er = " + er); 372 assertTrue("c | gcd(ac,bc): " + er, er.isZERO()); 373 374 er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(ar, dr); 375 //System.out.println("er = " + er); 376 assertTrue("gcd(ac,bc) | ac: " + er, er.isZERO()); 377 378 er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(br, dr); 379 //System.out.println("er = " + er); 380 assertTrue("gcd(ac,bc) | bc: " + er, er.isZERO()); 381 } 382 383}