Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.arith;
006
007
008import java.util.SortedMap;
009
010import junit.framework.Test;
011import junit.framework.TestCase;
012import junit.framework.TestSuite;
013
014
015/**
016 * BigQuaternion tests with JUnit.
017 * @author Heinz Kredel
018 */
019
020public class BigQuaternionTest extends TestCase {
021
022
023    /**
024     * main.
025     */
026    public static void main(String[] args) {
027        junit.textui.TestRunner.run(suite());
028    }
029
030
031    /**
032     * Constructs a <CODE>BigQuaternionTest</CODE> object.
033     * @param name String.
034     */
035    public BigQuaternionTest(String name) {
036        super(name);
037    }
038
039
040    /**
041     * @return suite.
042     */
043    public static Test suite() {
044        TestSuite suite = new TestSuite(BigQuaternionTest.class);
045        return suite;
046    }
047
048
049    BigQuaternion a, b, c, d, e, f;
050
051
052    BigQuaternionRing fac;
053
054
055    @Override
056    protected void setUp() {
057        a = b = c = d = e = null;
058        fac = new BigQuaternionRing();
059    }
060
061
062    @Override
063    protected void tearDown() {
064        a = b = c = d = e = null;
065        fac = null;
066    }
067
068
069    /**
070     * Test static initialization and constants.
071     */
072    public void testConstants() {
073        a = fac.getZERO();
074        b = fac.getONE();
075        c = b.subtract(b);
076        assertEquals("1-1 = 0", c, a);
077        assertTrue("1-1 = 0", c.isZERO());
078        assertTrue("1 = 1", b.isONE());
079
080        a = fac.getZERO();
081        b = fac.getONE();
082        c = b.subtract(b);
083        assertEquals("1-1 = 0", c, a);
084    }
085
086
087    /**
088     * Test bitLength.
089     */
090    public void testBitLength() {
091        a = fac.getZERO();
092        b = fac.getONE();
093        c = fac.random(100);
094        //System.out.println("c = " + c);
095        //System.out.println("len(c) = " + c.bitLength());
096
097        assertEquals("len(0) = 12", 12, a.bitLength());
098        assertEquals("len(1) = 13", 13, b.bitLength());
099        assertEquals("len(-1) = 13", 13, b.negate().bitLength());
100        assertTrue("len(random) >= 12", 12 <= c.bitLength());
101
102        d = fac.I;
103        assertEquals("len(i) = 13", 13, d.bitLength());
104        assertEquals("len(-i) = 13", 13, d.negate().bitLength());
105
106        d = fac.J;
107        assertEquals("len(j) = 13", 13, d.bitLength());
108        assertEquals("len(-j) = 13", 13, d.negate().bitLength());
109
110        d = fac.K;
111        assertEquals("len(k) = 13", 13, d.bitLength());
112        assertEquals("len(-k) = 13", 13, d.negate().bitLength());
113    }
114
115
116    /**
117     * Test constructor and toString.
118     */
119    public void testConstructor() {
120        a = new BigQuaternion(fac, "6/8");
121        b = new BigQuaternion(fac, "3/4");
122
123        assertEquals("6/8 = 3/4", a, b);
124
125        a = new BigQuaternion(fac, "3/4 i 4/5 j 1/5 k 2/5");
126        b = new BigQuaternion(fac, "-3/4 i -4/5 j -1/5 k -2/5");
127        assertEquals("3/4 + i 4/5 + j 1/5 + k 2/5", a, b.negate());
128
129        String s = "6/1111111111111111111111111111111111111111111";
130        a = new BigQuaternion(fac, s);
131        String t = a.toString();
132
133        assertEquals("stringConstr = toString", s, t);
134
135        a = new BigQuaternion(fac, 1);
136        b = new BigQuaternion(fac, -1);
137        c = b.sum(a);
138
139        assertTrue("1 = 1", a.isONE());
140        assertEquals("1+(-1) = 0", c, fac.getZERO());
141    }
142
143
144    /**
145     * Test random rationals.
146     */
147    public void testRandom() {
148        a = fac.random(50);
149        b = new BigQuaternion(fac, a.getRe(), a.getIm(), a.getJm(), a.getKm());
150        c = b.subtract(a);
151
152        assertEquals("a-b = 0", fac.getZERO(), c);
153
154        d = new BigQuaternion(fac, b.getRe(), b.getIm(), b.getJm(), b.getKm());
155        assertEquals("sign(a-a) = 0", 0, b.compareTo(d));
156    }
157
158
159    /**
160     * Test addition.
161     */
162    public void testAddition() {
163        a = fac.random(10);
164        b = a.sum(a);
165        c = b.subtract(a);
166        assertEquals("a+a-a = a", c, a);
167        assertEquals("a+a-a = a", 0, c.compareTo(a));
168
169        d = a.sum(fac.getZERO());
170        assertEquals("a+0 = a", d, a);
171        d = a.subtract(fac.getZERO());
172        assertEquals("a-0 = a", d, a);
173        d = a.subtract(a);
174        assertEquals("a-a = 0", d, fac.getZERO());
175    }
176
177
178    /**
179     * Test multiplication.
180     */
181    public void testMultiplication() {
182        a = fac.random(10);
183        b = a.multiply(a);
184        c = b.divide(a);
185        assertEquals("a*a/a = a", c, a);
186        assertEquals("a*a/a = a", 0, c.compareTo(a));
187
188        d = a.multiply(fac.getONE());
189        assertEquals("a*1 = a", d, a);
190        d = a.divide(fac.getONE());
191        assertEquals("a/1 = a", d, a);
192
193        a = fac.random(10);
194        b = a.inverse();
195        c = a.multiply(b);
196        assertTrue("a*1/a = 1", c.isONE());
197        c = b.multiply(a);
198        assertTrue("1/a*a = 1", c.isONE());
199
200        b = a.abs();
201        c = b.inverse();
202        d = b.multiply(c);
203        assertTrue("abs(a)*1/abs(a) = 1", d.isONE());
204
205        b = a.norm();
206        d = a.multiply(a.conjugate());
207        assertEquals("norm() = a a^", b, d);
208
209        //b = a.norm();
210        d = a.abs();
211        e = d.multiply(d);
212        BigRational dd = e.re.subtract(b.re).abs().divide(e.re.abs().sum(b.re.abs()));
213        //System.out.println("dd = " + dd + ", d = " + d + ", e = " + e);
214        BigRational eps = new BigRational(1,10).power(BigDecimal.DEFAULT_PRECISION-1);
215        assertTrue("abs()*abs() == norm(): " + dd, dd.compareTo(eps) <= 0);
216        
217        b = fac.random(10);
218        c = a.inverse();
219        d = c.multiply(b);
220        e = a.multiply(d);
221        assertEquals("a*(1/a)*b = b", b, e);
222
223        d = b.multiply(c);
224        e = d.multiply(a);
225        assertEquals("b*(1/a)*a = b", b, e);
226    }
227
228
229    /**
230     * Test multiplication axioms.
231     */
232    public void testMultiplicationAxioms() {
233        a = fac.random(10);
234        b = fac.random(10);
235
236        c = a.multiply(b);
237        d = b.multiply(a);
238        assertFalse("a*b != b*a", c.equals(d));
239
240        c = fac.random(10);
241
242        d = a.multiply(b.multiply(c));
243        e = a.multiply(b).multiply(c);
244        assertTrue("a(bc) = (ab)c", e.equals(d));
245    }
246
247
248    /**
249     * Test division.
250     */
251    public void testDivision() {
252        assertTrue("fac is field::", fac.isField());
253        a = fac.random(10);
254        b = fac.random(10);
255        if (b.isZERO()) {
256            b = fac.getONE();
257        }
258        //System.out.println("a = " + a);
259        //System.out.println("b = " + b);
260
261        c = a.remainder(b);
262        assertTrue("rem(a,b) == 0:", c.isZERO());
263        c = a.leftRemainder(b);
264        assertTrue("left rem(a,b) == 0:", c.isZERO());
265        c = a.rightRemainder(b);
266        assertTrue("right rem(a,b) == 0:", c.isZERO());
267
268        c = a.divide(b);
269        //System.out.println("c = " + c);
270        d = c.multiply(b);
271        //System.out.println("d = " + d);
272        assertEquals("div(a,b)*b == a:", d, a);
273
274        c = a.leftDivide(b);
275        //System.out.println("c = " + c);
276        d = c.multiplyLeft(b);
277        //System.out.println("d = " + d);
278        //d = b.multiply(c);
279        //System.out.println("d = " + d);
280        assertEquals("left div(a,b)*b == a:", d, a);
281
282        c = a.rightDivide(b);
283        //System.out.println("c = " + c);
284        d = c.multiply(b);
285        //System.out.println("d = " + d);
286        //d = b.multiply(c);
287        //System.out.println("d = " + d);
288        assertEquals("right div(a,b)*b == a:", d, a);
289    }
290
291
292    /**
293     * Test distributive law.
294     */
295    public void testDistributive() {
296        a = fac.random(20);
297        b = fac.random(20);
298        c = fac.random(20);
299
300        d = a.multiply(b.sum(c));
301        e = a.multiply(b).sum(a.multiply(c));
302        assertEquals("a(b+c) = ab+ac", d, e);
303    }
304
305}