001/*
002 * $Id: BigOctonionTest.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 * BigOctonion tests with JUnit.
017 * @author Heinz Kredel.
018 */
019
020public class BigOctonionTest 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>BigOctonionTest</CODE> object.
033     * @param name String.
034     */
035    public BigOctonionTest(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(BigOctonionTest.class);
047        return suite;
048    }
049
050
051    BigOctonion a;
052
053
054    BigOctonion b;
055
056
057    BigOctonion c;
058
059
060    BigOctonion d;
061
062
063    BigOctonion e;
064
065
066    BigOctonion fac;
067
068
069    @Override
070    protected void setUp() {
071        a = b = c = d = e = null;
072        fac = new BigOctonion();
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 = BigOctonion.ZERO;
089        b = BigOctonion.ONE;
090        c = b.subtract(b);
091
092        assertEquals("1-1 = 0", c, a);
093        assertTrue("1-1 = 0", c.isZERO());
094        assertTrue("1 = 1", b.isONE());
095
096        a = BigOctonion.ZERO;
097        b = BigOctonion.ONE;
098        c = b.subtract(b);
099        assertEquals("1-1 = 0", c, a);
100    }
101
102
103    /**
104     * Test constructor and toString.
105     * 
106     */
107    public void testConstructor() {
108        a = new BigOctonion("6/8");
109        b = new BigOctonion("3/4");
110        assertEquals("6/8 = 3/4", a, b);
111
112        a = new BigOctonion("3/4 i 4/5 j 1/5 k 2/5");
113        b = new BigOctonion("-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 BigOctonion(s);
118        String t = a.toString();
119        assertEquals("stringConstr = toString", s, t);
120
121        String sr = "3/4 i 4/5 j 1/5 k 2/5";
122        String si = "-3/4 i -4/5 j -1/5 k -2/5";
123        s = sr + " o " + si;
124        a = new BigOctonion(s);
125        BigQuaternion qr = new BigQuaternion(sr);
126        BigQuaternion qi = new BigQuaternion(si);
127        b = new BigOctonion(qr, qi);
128        assertEquals("s = " + s, a, b);
129
130        a = new BigOctonion(1);
131        b = new BigOctonion(-1);
132        c = b.sum(a);
133        assertTrue("1 = 1", a.isONE());
134        assertEquals("1+(-1) = 0", c, BigOctonion.ZERO);
135    }
136
137
138    /**
139     * Test random rationals.
140     * 
141     */
142    public void testRandom() {
143        a = fac.random(100);
144
145        b = new BigOctonion(a.getR(), a.getI());
146        c = b.subtract(a);
147        assertEquals("a-b = 0", BigOctonion.ZERO, c);
148
149        d = new BigOctonion(b.getR(), b.getI());
150        assertEquals("sign(a-a) = 0", 0, b.compareTo(d));
151    }
152
153
154    /**
155     * Test addition.
156     * 
157     */
158    public void testAddition() {
159        a = fac.random(50);
160        b = a.sum(a);
161        c = b.subtract(a);
162
163        assertEquals("a+a-a = a", c, a);
164        assertEquals("a+a-a = a", 0, c.compareTo(a));
165
166        d = a.sum(BigOctonion.ZERO);
167        assertEquals("a+0 = a", d, a);
168        d = a.subtract(BigOctonion.ZERO);
169        assertEquals("a-0 = a", d, a);
170        d = a.subtract(a);
171        assertEquals("a-a = 0", d, BigOctonion.ZERO);
172    }
173
174
175    /**
176     * Test multiplication.
177     * 
178     */
179    public void testMultiplication() {
180        a = fac.random(30);
181        //System.out.println("a = " + a);
182
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(BigOctonion.ONE);
189        assertEquals("a*1 = a", d, a);
190        d = a.divide(BigOctonion.ONE);
191        assertEquals("a/1 = a", d, a);
192
193        a = fac.random(30);
194        b = a.inverse();
195        c = a.multiply(b);
196        assertTrue("a*1/a = 1", c.isONE());
197
198        b = a.abs();
199        c = b.inverse();
200        d = b.multiply(c);
201        assertTrue("abs(a)*1/abs(a) = 1", d.isONE());
202
203        a = fac.random(3);
204        b = a.abs();
205        c = a.conjugate();
206        d = a.multiply(c);
207        assertEquals("abs(a)^2 = a a^", b, d);
208    }
209
210
211    /**
212     * Test multiplication axioms.
213     * 
214     */
215    public void testMultiplicationAxioms() {
216        a = fac.random(20);
217        b = fac.random(20);
218
219        c = a.multiply(b);
220        d = b.multiply(a);
221
222        assertTrue("a*b != b*a", !c.equals(d));
223
224        c = fac.random(20);
225
226        d = a.multiply(b.multiply(c));
227        e = a.multiply(b).multiply(c);
228        assertTrue("a(bc) != (ab)c", !e.equals(d));
229    }
230
231
232    /**
233     * Test distributive law.
234     * 
235     */
236    public void testDistributive() {
237        a = fac.random(20);
238        b = fac.random(20);
239        c = fac.random(20);
240
241        d = a.multiply(b.sum(c));
242        e = a.multiply(b).sum(a.multiply(c));
243
244        assertEquals("a(b+c) = ab+ac", d, e);
245    }
246
247}