001/*
002 * $Id$
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 BigDecimalComplexTest 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>BigDecimalComplexTest</CODE> object.
031     * @param name String.
032     */
033    public BigDecimalComplexTest(String name) {
034        super(name);
035    }
036
037
038    /**
039     * suite.
040     */
041    public static Test suite() {
042        TestSuite suite = new TestSuite(BigDecimalComplexTest.class);
043        return suite;
044    }
045
046
047    int precision = BigDecimal.DEFAULT_PRECISION; // must match default
048
049
050    BigDecimalComplex a, b, c, d, e, eps;
051
052
053    BigDecimalComplex fac;
054
055
056    @Override
057    protected void setUp() {
058        a = b = c = d = e = null;
059        fac = new BigDecimalComplex();
060        eps = new BigDecimalComplex("0.1");
061        eps = eps.power(precision - 2);
062    }
063
064
065    @Override
066    protected void tearDown() {
067        a = b = c = d = e = null;
068        eps = null;
069    }
070
071
072    /**
073     * Test static initialization and constants.
074     */
075    public void testConstants() {
076        a = fac.getZERO();
077        b = fac.getONE();
078        c = b.subtract(b);
079        d = fac.getIMAG();
080        e = BigDecimalComplex.CDIF(d, d);
081
082        assertEquals("1-1 == 0", c, a);
083        assertTrue("1-1 == 0", c.isZERO());
084        assertTrue("1 == 1", b.isONE());
085        assertTrue("i == i", d.isIMAG());
086        assertTrue("i-i == 0", e.isZERO());
087
088        c = a.subtract(a);
089        assertEquals("0-0 == 0", c, a);
090    }
091
092
093    /**
094     * Test bitLength.
095     */
096    public void testBitLength() {
097        a = fac.getZERO();
098        b = fac.getONE();
099        c = b.random(300);
100        d = fac.getIMAG();
101        //System.out.println("c = " + c);
102        //System.out.println("len(c) = " + c.bitLength());
103
104        assertEquals("len(0) = 4", 4, a.bitLength());
105        assertEquals("len(1) = 5", 5, b.bitLength());
106        assertEquals("len(-1) = 5", 5, b.negate().bitLength());
107        assertEquals("len(i) = 5", 5, d.bitLength());
108        assertEquals("len(-i) = 5", 5, d.negate().bitLength());
109        assertTrue("len(random) >= 4", 4 <= c.bitLength());
110    }
111
112
113    /**
114     * Test constructor and toString.
115     */
116    public void testConstructor() {
117        a = new BigDecimalComplex("6.8");
118        b = new BigDecimalComplex("3.4");
119        b = b.sum(b);
120
121        assertEquals("6.8 == 3.4+3.4", a, b);
122
123        a = new BigDecimalComplex("3.4 i 4.5");
124        b = new BigDecimalComplex("-3.4 i -4.5");
125
126        assertEquals("3.4 + i 4.5 ", a, b.negate());
127
128        String s = "6.1111111111111111111111111111111111111111111";
129        a = new BigDecimalComplex(s);
130        String t = a.toString();
131
132        assertEquals("stringConstr == toString", s, t);
133
134        a = new BigDecimalComplex(1);
135        b = new BigDecimalComplex(-1);
136        c = b.sum(a);
137
138        assertTrue("1 == 1", a.isONE());
139        assertEquals("1+(-1) == 0", c, fac.getZERO());
140    }
141
142
143    /**
144     * Test random decimal.
145     */
146    public void testRandom() {
147        a = fac.random(500);
148        b = new BigDecimalComplex(a.getRe(), a.getIm());
149        c = b.subtract(a);
150
151        assertEquals("a-b == 0", c, fac.getZERO());
152
153        d = new BigDecimalComplex(b.getRe(), b.getIm());
154        assertEquals("sign(a-a) == 0", 0, b.compareTo(d));
155    }
156
157
158    /**
159     * Test addition.
160     */
161    public void testAddition() {
162        a = fac.random(10);
163        b = a.sum(a);
164        c = b.subtract(a);
165
166        assertEquals("a+a-a == a", c, a);
167        assertEquals("a+a-a == a", 0, c.compareTo(a));
168
169        b = fac.random(5);
170        c = a.sum(b);
171        d = b.sum(a);
172        assertEquals("a+b == b+a: " + c.subtract(d), c, d);
173
174        d = a.sum(fac.getZERO());
175        assertEquals("a+0 == a", d, a);
176        d = a.subtract(fac.getZERO());
177        assertEquals("a-0 == a", d, a);
178        d = a.subtract(a);
179        assertEquals("a-a == 0", d, fac.getZERO());
180    }
181
182
183    /**
184     * Test multiplication.
185     */
186    public void testMultiplication() {
187        a = fac.random(5);
188        b = a.multiply(a);
189        c = b.divide(a);
190
191        //assertEquals("a*a/a == a: " + c.subtract(a), c, a);
192        d = c.subtract(a).abs().divide(a.abs());
193        assertTrue("a*a/a == a: " + c.subtract(a), d.compareTo(eps) <= 0);
194
195        d = a.multiply(fac.getONE());
196        assertEquals("a*1 == a", d, a);
197        d = a.divide(fac.getONE());
198        assertEquals("a/1 == a", d, a);
199
200        b = fac.random(5);
201        c = a.multiply(b);
202        d = b.multiply(a);
203        assertEquals("a*b == b*a: " + c.subtract(d), c, d);
204
205        a = fac.random(5);
206        b = a.inverse();
207        c = a.multiply(b);
208        e = c.subtract(fac.getONE()).abs();
209        //assertTrue("a*1/a == 1: " + c, c.isONE());
210        assertTrue("a*1/a == 1: " + e, e.compareTo(eps) <= 0);
211    }
212
213
214    /**
215     * Test distributive law.
216     */
217    public void testDistributive() {
218        a = fac.random(50);
219        b = fac.random(50);
220        c = fac.random(50);
221
222        d = a.multiply(b.sum(c));
223        e = a.multiply(b).sum(a.multiply(c));
224
225        a = d.subtract(e).abs().divide(e.abs());
226        //assertEquals("a(b+c) == ab+ac", d, e);
227        assertTrue("a(b+c) == ab+ac", a.compareTo(eps) <= 0);
228    }
229
230
231    /**
232     * Test norm and abs.
233     */
234    public void testNorm() {
235        a = fac.random(5);
236
237        b = a.norm();
238        c = a.abs();
239        d = c.multiply(c);
240        e = b.subtract(d).abs();
241        //System.out.println("e = " + e);
242        //System.out.println("eps = " + eps);
243        assertTrue("||a|| == |a|*|a|: " + e, e.compareTo(eps) <= 0);
244
245        e = d.subtract(b).abs().divide(b.abs());
246        //System.out.println("e = " + e);
247        assertTrue("||a|| == |a|*|a|: " + e, e.compareTo(eps) <= 0);
248    }
249
250}