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