Source code

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