001/*
002 * $Id: BigComplexTest.java 5688 2017-01-03 08:45:09Z 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 * BigComplex tests with JUnit.
015 * @author Heinz Kredel
016 */
017
018public class BigComplexTest 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>BigComplexTest</CODE> object.
031     * @param name String.
032     */
033    public BigComplexTest(String name) {
034        super(name);
035    }
036
037
038    /**
039     * suite.
040     */
041    public static Test suite() {
042        TestSuite suite = new TestSuite(BigComplexTest.class);
043        return suite;
044    }
045
046
047    BigComplex a, b, c, d, e;
048
049
050    BigComplex fac;
051
052
053    @Override
054    protected void setUp() {
055        a = b = c = d = e = null;
056        fac = new BigComplex();
057    }
058
059
060    @Override
061    protected void tearDown() {
062        a = b = c = d = e = null;
063        fac = null;
064    }
065
066
067    /**
068     * Test static initialization and constants.
069     * 
070     */
071    public void testConstants() {
072        a = BigComplex.ZERO;
073        b = BigComplex.ONE;
074        c = BigComplex.CDIF(b, b);
075        d = BigComplex.I;
076        e = BigComplex.CDIF(d, d);
077
078        assertEquals("1-1 = 0", c, a);
079        assertTrue("1-1 = 0", c.isZERO());
080        assertTrue("1 = 1", b.isONE());
081        assertEquals("1-1 = 0", c, a);
082        assertTrue("i = i", d.isIMAG());
083        assertTrue("i-i = 0", e.isZERO());
084    }
085
086
087    /**
088     * Test bitLength.
089     */
090    public void testBitLength() {
091        a = BigComplex.ZERO;
092        b = BigComplex.ONE;
093        c = BigComplex.CDIF(b, b);
094        d = BigComplex.I;
095        e = BigComplex.CDIF(d, d);
096
097        assertEquals("len(0) = 6", 6, a.bitLength());
098        assertEquals("len(1) = 7", 7, b.bitLength());
099        assertEquals("len(-1) = 7", 7, b.negate().bitLength());
100        assertEquals("len(i) = 7", 7, d.bitLength());
101        assertEquals("len(-i) = 7", 7, d.negate().bitLength());
102
103        e = BigComplex.CDIF(b, d);
104        assertEquals("len(1-i) = 8", 8, e.bitLength());
105    }
106
107
108    /**
109     * Test constructor and toString.
110     * 
111     */
112    public void testConstructor() {
113        a = new BigComplex("6/8");
114        b = new BigComplex("3/4");
115
116        assertEquals("6/8 = 3/4", a, b);
117
118        a = new BigComplex("3/4 i 4/5");
119        b = new BigComplex("-3/4 i -4/5");
120
121        assertEquals("3/4 + i 4/5 ", a, b.negate());
122
123        String s = "6/1111111111111111111111111111111111111111111";
124        a = new BigComplex(s);
125        String t = a.toString();
126
127        assertEquals("stringConstr = toString", s, t);
128
129        a = new BigComplex(1);
130        b = new BigComplex(-1);
131        c = BigComplex.CSUM(b, a);
132
133        assertTrue("1 = 1", a.isONE());
134        assertEquals("1+(-1) = 0", c, BigComplex.ZERO);
135    }
136
137
138    /**
139     * Test random rationals.
140     * 
141     */
142    public void testRandom() {
143        a = BigComplex.CRAND(500);
144        b = new BigComplex(a.getRe(), a.getIm());
145        c = BigComplex.CDIF(b, a);
146
147        assertEquals("a-b = 0", c, BigComplex.ZERO);
148
149        d = new BigComplex(b.getRe(), b.getIm());
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 = BigComplex.CRAND(100);
160        b = BigComplex.CSUM(a, a);
161        c = BigComplex.CDIF(b, a);
162
163        assertEquals("a+a-a = a", c, a);
164        assertEquals("a+a-a = a", 0, c.compareTo(a));
165
166        b = fac.random(5);
167        c = a.sum(b);
168        d = b.sum(a);
169        assertEquals("a+b == b+a: " + c.subtract(d), c, d);
170
171        d = BigComplex.CSUM(a, BigComplex.ZERO);
172        assertEquals("a+0 = a", d, a);
173        d = BigComplex.CDIF(a, BigComplex.ZERO);
174        assertEquals("a-0 = a", d, a);
175        d = BigComplex.CDIF(a, a);
176        assertEquals("a-a = 0", d, BigComplex.ZERO);
177    }
178
179
180    /**
181     * Test multiplication.
182     * 
183     */
184    public void testMultiplication() {
185        a = BigComplex.CRAND(100);
186        b = BigComplex.CPROD(a, a);
187        c = BigComplex.CQ(b, a);
188
189        assertEquals("a*a/a = a", c, a);
190        assertEquals("a*a/a = a", 0, c.compareTo(a));
191
192        d = BigComplex.CPROD(a, BigComplex.ONE);
193        assertEquals("a*1 = a", d, a);
194        d = BigComplex.CQ(a, BigComplex.ONE);
195        assertEquals("a/1 = a", d, a);
196
197        b = fac.random(5);
198        c = a.multiply(b);
199        d = b.multiply(a);
200        assertEquals("a*b == b*a: " + c.subtract(d), c, d);
201
202        a = BigComplex.CRAND(100);
203        b = BigComplex.CINV(a);
204        c = BigComplex.CPROD(a, b);
205
206        assertTrue("a*1/a = 1", c.isONE());
207    }
208
209
210    /**
211     * Test distributive law.
212     * 
213     */
214    public void testDistributive() {
215        BigComplex fac = new BigComplex();
216
217        a = fac.random(500);
218        b = fac.random(500);
219        c = fac.random(500);
220
221        d = a.multiply(b.sum(c));
222        e = a.multiply(b).sum(a.multiply(c));
223
224        assertEquals("a(b+c) = ab+ac", d, e);
225    }
226
227}