001/*
002 * $Id: BigQuaternionTest.java 4858 2014-06-29 14:08:48Z kredel $
003 */
004
005package edu.jas.arith;
006
007
008// import edu.jas.arith.BigRational;
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 */
042    /**
043     * @return suite.
044     */
045    public static Test suite() {
046        TestSuite suite = new TestSuite(BigQuaternionTest.class);
047        return suite;
048    }
049
050
051    BigQuaternion a;
052
053
054    BigQuaternion b;
055
056
057    BigQuaternion c;
058
059
060    BigQuaternion d;
061
062
063    BigQuaternion e;
064
065
066    BigQuaternion fac;
067
068
069    @Override
070    protected void setUp() {
071        a = b = c = d = e = null;
072        fac = new BigQuaternion();
073    }
074
075
076    @Override
077    protected void tearDown() {
078        a = b = c = d = e = null;
079        fac = null;
080    }
081
082
083    /**
084     * Test static initialization and constants.
085     * 
086     */
087    public void testConstants() {
088        a = BigQuaternion.ZERO;
089        b = BigQuaternion.ONE;
090        c = b.subtract(b);
091        assertEquals("1-1 = 0", c, a);
092        assertTrue("1-1 = 0", c.isZERO());
093        assertTrue("1 = 1", b.isONE());
094
095        a = BigQuaternion.ZERO;
096        b = BigQuaternion.ONE;
097        c = b.subtract(b);
098        assertEquals("1-1 = 0", c, a);
099    }
100
101
102    /**
103     * Test constructor and toString.
104     * 
105     */
106    public void testConstructor() {
107        a = new BigQuaternion("6/8");
108        b = new BigQuaternion("3/4");
109
110        assertEquals("6/8 = 3/4", a, b);
111
112        a = new BigQuaternion("3/4 i 4/5 j 1/5 k 2/5");
113        b = new BigQuaternion("-3/4 i -4/5 j -1/5 k -2/5");
114        assertEquals("3/4 + i 4/5 + j 1/5 + k 2/5", a, b.negate());
115
116        String s = "6/1111111111111111111111111111111111111111111";
117        a = new BigQuaternion(s);
118        String t = a.toString();
119
120        assertEquals("stringConstr = toString", s, t);
121
122        a = new BigQuaternion(1);
123        b = new BigQuaternion(-1);
124        c = b.sum(a);
125
126        assertTrue("1 = 1", a.isONE());
127        assertEquals("1+(-1) = 0", c, BigQuaternion.ZERO);
128    }
129
130
131    /**
132     * Test random rationals.
133     * 
134     */
135    public void testRandom() {
136        a = fac.random(500);
137        b = new BigQuaternion(a.getRe(), a.getIm(), a.getJm(), a.getKm());
138        c = b.subtract(a);
139
140        assertEquals("a-b = 0", BigQuaternion.ZERO, c);
141
142        d = new BigQuaternion(b.getRe(), b.getIm(), b.getJm(), b.getKm());
143        assertEquals("sign(a-a) = 0", 0, b.compareTo(d));
144    }
145
146
147    /**
148     * Test addition.
149     * 
150     */
151    public void testAddition() {
152        a = fac.random(100);
153        b = a.sum(a);
154        c = b.subtract(a);
155        assertEquals("a+a-a = a", c, a);
156        assertEquals("a+a-a = a", 0, c.compareTo(a));
157
158        d = a.sum(BigQuaternion.ZERO);
159        assertEquals("a+0 = a", d, a);
160        d = a.subtract(BigQuaternion.ZERO);
161        assertEquals("a-0 = a", d, a);
162        d = a.subtract(a);
163        assertEquals("a-a = 0", d, BigQuaternion.ZERO);
164
165    }
166
167
168    /**
169     * Test multiplication.
170     * 
171     */
172    public void testMultiplication() {
173        a = fac.random(100);
174        b = a.multiply(a);
175        c = b.divide(a);
176        assertEquals("a*a/a = a", c, a);
177        assertEquals("a*a/a = a", 0, c.compareTo(a));
178
179        d = a.multiply(BigQuaternion.ONE);
180        assertEquals("a*1 = a", d, a);
181        d = a.divide(BigQuaternion.ONE);
182        assertEquals("a/1 = a", d, a);
183
184        a = fac.random(100);
185        b = a.inverse();
186        c = a.multiply(b);
187        assertTrue("a*1/a = 1", c.isONE());
188
189        b = a.abs();
190        c = b.inverse();
191        d = b.multiply(c);
192        assertTrue("abs(a)*1/abs(a) = 1", d.isONE());
193
194        b = a.abs();
195        c = a.conjugate();
196        d = a.multiply(c);
197        assertEquals("abs(a)^2 = a a^", b, d);
198    }
199
200
201    /**
202     * Test multiplication axioms.
203     * 
204     */
205    public void testMultiplicationAxioms() {
206        a = fac.random(100);
207        b = fac.random(100);
208
209        c = a.multiply(b);
210        d = b.multiply(a);
211        assertTrue("a*b != b*a", !c.equals(d));
212
213        c = fac.random(100);
214
215        d = a.multiply(b.multiply(c));
216        e = a.multiply(b).multiply(c);
217        assertTrue("a(bc) = (ab)c", e.equals(d));
218    }
219
220
221    /**
222     * Test distributive law.
223     * 
224     */
225    public void testDistributive() {
226        a = fac.random(20);
227        b = fac.random(20);
228        c = fac.random(20);
229
230        d = a.multiply(b.sum(c));
231        e = a.multiply(b).sum(a.multiply(c));
232
233        assertEquals("a(b+c) = ab+ac", d, e);
234    }
235
236
237}