001/*
002 * $Id: BigDecimalComplexTest.java 4862 2014-07-04 20:47:09Z 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 * BigComplex tests with JUnit.
017 * @author Heinz Kredel.
018 */
019
020public class BigDecimalComplexTest 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>BigDecimalComplexTest</CODE> object.
033     * @param name String.
034     */
035    public BigDecimalComplexTest(String name) {
036        super(name);
037    }
038
039
040    /**
041     * suite.
042     */
043    public static Test suite() {
044        TestSuite suite = new TestSuite(BigDecimalComplexTest.class);
045        return suite;
046    }
047
048
049    BigDecimalComplex a, b, c, d, e;
050
051
052    BigDecimalComplex fac;
053
054
055    @Override
056    protected void setUp() {
057        a = b = c = d = e = null;
058        fac = new BigDecimalComplex();
059    }
060
061
062    @Override
063    protected void tearDown() {
064        a = b = c = d = e = null;
065    }
066
067
068    /**
069     * Test static initialization and constants.
070     */
071    public void testConstants() {
072        a = BigDecimalComplex.ZERO;
073        b = BigDecimalComplex.ONE;
074        c = b.subtract(b);
075
076        assertEquals("1-1 == 0", c, a);
077        assertTrue("1-1 == 0", c.isZERO());
078        assertTrue("1 == 1", b.isONE());
079
080        c = a.subtract(a);
081
082        assertEquals("0-0 == 0", c, a);
083    }
084
085
086    /**
087     * Test constructor and toString.
088     */
089    public void testConstructor() {
090        a = new BigDecimalComplex("6.8");
091        b = new BigDecimalComplex("3.4");
092        b = b.sum(b);
093
094        assertEquals("6.8 == 3.4+3.4", a, b);
095
096        a = new BigDecimalComplex("3.4 i 4.5");
097        b = new BigDecimalComplex("-3.4 i -4.5");
098
099        assertEquals("3.4 + i 4.5 ", a, b.negate());
100
101        String s = "6.1111111111111111111111111111111111111111111";
102        a = new BigDecimalComplex(s);
103        String t = a.toString();
104
105        assertEquals("stringConstr == toString", s, t);
106
107        a = new BigDecimalComplex(1);
108        b = new BigDecimalComplex(-1);
109        c = b.sum(a);
110
111        assertTrue("1 == 1", a.isONE());
112        assertEquals("1+(-1) == 0", c, BigDecimalComplex.ZERO);
113    }
114
115
116    /**
117     * Test random decimal.
118     */
119    public void testRandom() {
120        a = fac.random(500);
121        b = new BigDecimalComplex(a.getRe(), a.getIm());
122        c = b.subtract(a);
123
124        assertEquals("a-b == 0", c, BigDecimalComplex.ZERO);
125
126        d = new BigDecimalComplex(b.getRe(), b.getIm());
127        assertEquals("sign(a-a) == 0", 0, b.compareTo(d));
128    }
129
130
131    /**
132     * Test addition.
133     */
134    public void testAddition() {
135        a = fac.random(10);
136        b = a.sum(a);
137        c = b.subtract(a);
138
139        assertEquals("a+a-a == a", c, a);
140        assertEquals("a+a-a == a", 0, c.compareTo(a));
141
142        b = fac.random(5);
143        c = a.sum(b);
144        d = b.sum(a);
145        assertEquals("a+b == b+a: " + c.subtract(d), c, d);
146
147        d = a.sum(BigDecimalComplex.ZERO);
148        assertEquals("a+0 == a", d, a);
149        d = a.subtract(BigDecimalComplex.ZERO);
150        assertEquals("a-0 == a", d, a);
151        d = a.subtract(a);
152        assertEquals("a-a == 0", d, BigDecimalComplex.ZERO);
153    }
154
155
156    /**
157     * Test multiplication.
158     */
159    public void testMultiplication() {
160        a = fac.random(5);
161        b = a.multiply(a);
162        c = b.divide(a);
163
164        assertEquals("a*a/a == a: " + c.subtract(a), c, a);
165        assertEquals("a*a/a == a: " + c.subtract(a), 0, c.compareTo(a));
166
167        d = a.multiply(BigDecimalComplex.ONE);
168        assertEquals("a*1 == a", d, a);
169        d = a.divide(BigDecimalComplex.ONE);
170        assertEquals("a/1 == a", d, a);
171
172        b = fac.random(5);
173        c = a.multiply(b);
174        d = b.multiply(a);
175        assertEquals("a*b == b*a: " + c.subtract(d), c, d);
176
177        a = fac.random(5);
178        b = a.inverse();
179        c = a.multiply(b);
180        //assertTrue("a*1/a == 1: " + c, c.isONE());
181        assertTrue("a*1/a == 1: " + c, c.compareTo(fac.getONE()) == 0);
182    }
183
184
185    /**
186     * Test distributive law.
187     */
188    public void testDistributive() {
189        a = fac.random(50);
190        b = fac.random(50);
191        c = fac.random(50);
192
193        d = a.multiply(b.sum(c));
194        e = a.multiply(b).sum(a.multiply(c));
195
196        assertEquals("a(b+c) == ab+ac", d, e);
197    }
198
199
200    /**
201     * Test norm and abs.
202     */
203    public void testNorm() {
204        a = fac.random(5);
205
206        b = a.norm();
207        c = a.abs();
208        d = c.multiply(c);
209        e = b.subtract(d);
210        //System.out.println("e = " + e);
211
212        assertTrue("||a|| == |a|*|a|: " + e, b.compareTo(d) == 0);
213    }
214
215}