001/* 002 * $Id: QuatGenSolvablePolynomialTest.java 5042 2014-12-29 12:32:59Z kredel $ 003 */ 004 005package edu.jas.poly; 006 007 008import java.util.List; 009 010import junit.framework.Test; 011import junit.framework.TestCase; 012import junit.framework.TestSuite; 013 014import org.apache.log4j.BasicConfigurator; 015 016import edu.jas.arith.BigQuaternion; 017 018 019/** 020 * BigQuaternion coefficients GenSolvablePolynomial tests with JUnit. 021 * @author Heinz Kredel. 022 */ 023 024public class QuatGenSolvablePolynomialTest extends TestCase { 025 026 027 /** 028 * main 029 */ 030 public static void main(String[] args) { 031 BasicConfigurator.configure(); 032 junit.textui.TestRunner.run(suite()); 033 } 034 035 036 /** 037 * Constructs a <CODE>QuatGenSolvablePolynomialTest</CODE> object. 038 * @param name String. 039 */ 040 public QuatGenSolvablePolynomialTest(String name) { 041 super(name); 042 } 043 044 045 /** 046 */ 047 public static Test suite() { 048 TestSuite suite = new TestSuite(QuatGenSolvablePolynomialTest.class); 049 return suite; 050 } 051 052 053 BigQuaternion cfac; 054 055 056 GenSolvablePolynomialRing<BigQuaternion> fac; 057 058 059 GenSolvablePolynomial<BigQuaternion> a; 060 061 062 GenSolvablePolynomial<BigQuaternion> b; 063 064 065 GenSolvablePolynomial<BigQuaternion> c; 066 067 068 GenSolvablePolynomial<BigQuaternion> d; 069 070 071 GenSolvablePolynomial<BigQuaternion> e; 072 073 074 int rl = 6; 075 076 077 int kl = 3; 078 079 080 int ll = 7; 081 082 083 int el = 5; 084 085 086 float q = 0.33f; 087 088 089 @Override 090 protected void setUp() { 091 a = b = c = d = e = null; 092 cfac = new BigQuaternion(1); 093 fac = new GenSolvablePolynomialRing<BigQuaternion>(cfac, rl); 094 RelationGenerator<BigQuaternion> rel = new WeylRelations<BigQuaternion>(); 095 rel.generate(fac); 096 } 097 098 099 @Override 100 protected void tearDown() { 101 a = b = c = d = e = null; 102 fac = null; 103 cfac = null; 104 } 105 106 107 /** 108 * Test constructor and toString. 109 */ 110 public void testConstruction() { 111 c = fac.getONE(); 112 assertTrue("length( c ) = 1", c.length() == 1); 113 assertTrue("isZERO( c )", !c.isZERO()); 114 assertTrue("isONE( c )", c.isONE()); 115 116 d = fac.getZERO(); 117 assertTrue("length( d ) = 0", d.length() == 0); 118 assertTrue("isZERO( d )", d.isZERO()); 119 assertTrue("isONE( d )", !d.isONE()); 120 } 121 122 123 /** 124 * Test factory. 125 */ 126 public void testFactory() { 127 assertFalse("!is comutative", fac.isCommutative()); 128 assertFalse("!is field", fac.isField()); 129 assertTrue("is associative", fac.isAssociative()); 130 131 List<GenPolynomial<BigQuaternion>> gens = fac.generators(); 132 //System.out.println("gens = " + gens); 133 assertTrue("#gens = 4+6 ", gens.size() == 10); 134 } 135 136 137 /** 138 * Test random polynomial. 139 */ 140 public void testRandom() { 141 for (int i = 0; i < 3; i++) { 142 //a = fac.random(ll); 143 a = fac.random(kl, ll + i, el + (5 - i), q); 144 assertTrue("length( a" + i + " ) <> 0", a.length() >= 0); 145 assertTrue(" not isZERO( a" + i + " )", !a.isZERO()); 146 assertTrue(" not isONE( a" + i + " )", !a.isONE()); 147 } 148 } 149 150 151 /** 152 * Test solvable addition. 153 */ 154 public void testAddition() { 155 a = fac.random(kl, ll, el, q); // fac.random(ll); 156 b = fac.random(kl, ll, el, q); // fac.random(ll); 157 158 c = (GenSolvablePolynomial<BigQuaternion>) a.sum(b); 159 d = (GenSolvablePolynomial<BigQuaternion>) c.subtract(b); 160 assertEquals("a+b-b = a", a, d); 161 162 c = fac.random(kl, ll, el, q); //fac.random(ll); 163 164 ExpVector u = ExpVector.EVRAND(rl, el, q); 165 BigQuaternion x = BigQuaternion.QRAND(kl); 166 167 b = new GenSolvablePolynomial<BigQuaternion>(fac, x, u); 168 c = (GenSolvablePolynomial<BigQuaternion>) a.sum(b); 169 d = (GenSolvablePolynomial<BigQuaternion>) a.sum(x, u); 170 assertEquals("a+p(x,u) = a+(x,u)", c, d); 171 172 c = (GenSolvablePolynomial<BigQuaternion>) a.subtract(b); 173 d = (GenSolvablePolynomial<BigQuaternion>) a.subtract(x, u); 174 assertEquals("a-p(x,u) = a-(x,u)", c, d); 175 176 a = new GenSolvablePolynomial<BigQuaternion>(fac); 177 assertTrue("a == 0", a.isZERO()); 178 } 179 180 181 /** 182 * Test solvable multiplication. 183 */ 184 @SuppressWarnings("cast") 185 public void testMultiplication() { 186 a = fac.random(kl, ll, el, q); //fac.random(ll); 187 assertTrue("not isZERO( a )", !a.isZERO()); 188 189 b = fac.random(kl, ll, el, q); //fac.random(ll); 190 assertTrue("not isZERO( b )", !b.isZERO()); 191 192 c = (GenSolvablePolynomial<BigQuaternion>) b.multiply(a); 193 d = (GenSolvablePolynomial<BigQuaternion>) a.multiply(b); 194 assertTrue("not isZERO( c )", !c.isZERO()); 195 assertTrue("not isZERO( d )", !d.isZERO()); 196 //System.out.println("a = " + a); 197 //System.out.println("b = " + b); 198 //System.out.println("c = " + c); 199 //System.out.println("d = " + d); 200 e = (GenSolvablePolynomial<BigQuaternion>) d.subtract(c); 201 assertTrue("!isZERO( a*b-b*a ) " + e, !e.isZERO()); 202 203 assertTrue("a*b = b*a", !c.equals(d)); 204 //assertEquals("a*b = b*a",c,d); 205 206 c = fac.random(kl, ll, el, q); //fac.random(ll); 207 //System.out.println("c = " + c); 208 d = (GenSolvablePolynomial<BigQuaternion>) a.multiply(b.multiply(c)); 209 e = (GenSolvablePolynomial<BigQuaternion>) (a.multiply(b)).multiply(c); 210 //System.out.println("d = " + d); 211 //System.out.println("e = " + e); 212 //System.out.println("d-e = " + d.subtract(c) ); 213 214 assertEquals("a(bc) = (ab)c", d, e); 215 assertTrue("a(bc) = (ab)c", d.equals(e)); 216 217 BigQuaternion x = a.leadingBaseCoefficient().inverse(); 218 c = (GenSolvablePolynomial<BigQuaternion>) a.monic(); 219 d = (GenSolvablePolynomial<BigQuaternion>) a.multiplyLeft(x); 220 assertEquals("a.monic() = a(1/ldcf(a))", c, d); 221 222 BigQuaternion y = b.leadingBaseCoefficient().inverse(); 223 c = (GenSolvablePolynomial<BigQuaternion>) b.monic(); 224 d = (GenSolvablePolynomial<BigQuaternion>) b.multiplyLeft(y); 225 assertEquals("b.monic() = b(1/ldcf(b))", c, d); 226 227 e = new GenSolvablePolynomial<BigQuaternion>(fac, y); 228 d = (GenSolvablePolynomial<BigQuaternion>) e.multiply(b); 229 assertEquals("b.monic() = b(1/ldcf(b))", c, d); 230 } 231 232 233 /** 234 * Test solvable left and right multiplication. 235 */ 236 public void testDoubleMultiplication() { 237 a = fac.random(kl, 3, el, q); //fac.random(ll); 238 b = fac.random(kl, 2, el, q); //fac.random(ll); 239 c = fac.random(kl, 3, el, q); //fac.random(ll); 240 241 d = a.multiply(b).multiply(c); 242 e = b.multiply(a, c); 243 assertEquals("a b c = b.multiply(a,c)", d, e); 244 245 BigQuaternion qa = cfac.random(kl); 246 BigQuaternion qb = cfac.random(kl); 247 BigQuaternion qc = qa.multiply(qb); 248 BigQuaternion qd = qb.multiply(qa); 249 // search non commuting qa, qb 250 while (qc.equals(qd)) { 251 qa = cfac.random(kl); 252 qb = cfac.random(kl); 253 qc = qa.multiply(qb); 254 qd = qb.multiply(qa); 255 } 256 //System.out.println("qa = " + qa); 257 //System.out.println("qb = " + qb); 258 //System.out.println("qc = " + qc); 259 //System.out.println("qd = " + qd); 260 261 a = fac.univariate(0); 262 d = a.multiply(qa, qb); 263 e = a.multiply(qb, qa); 264 //System.out.println("a = " + a); 265 //System.out.println("d = " + d); 266 //System.out.println("e = " + e); 267 assertTrue("a.multiply(qa,qb) != a.multiply(qb,qq)", 268 d.equals(e) || d.leadingExpVector().equals(e.leadingExpVector())); 269 270 // commuting variables 271 ExpVector ea = fac.univariate(1).leadingExpVector(); 272 ExpVector eb = fac.univariate(2).leadingExpVector(); 273 //System.out.println("ea = " + ea); 274 //System.out.println("eb = " + eb); 275 276 d = a.multiply(ea, eb); 277 e = a.multiply(eb, ea); 278 //System.out.println("d = " + d); 279 //System.out.println("e = " + e); 280 assertTrue("a.multiply(ea,eb) == a.multiply(eb,eq)", d.equals(e)); 281 282 d = a.multiply(qa, ea, qb, eb); 283 e = a.multiply(qb, eb, qa, ea); 284 //System.out.println("d = " + d); 285 //System.out.println("e = " + e); 286 assertTrue("a.multiply(qa,ea,qb,eb) != a.multiply(qb,eb,qa,ea)", d.equals(e) 287 || d.leadingExpVector().equals(e.leadingExpVector())); 288 } 289 290}