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}