Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.arith;
006
007
008import java.util.Iterator;
009
010import junit.framework.Test;
011import junit.framework.TestCase;
012import junit.framework.TestSuite;
013
014
015/**
016 * BigRational tests with JUnit.
017 * @author Heinz Kredel
018 */
019
020public class BigRationalTest 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>BigRationalTest</CODE> object.
033     * @param name String.
034     */
035    public BigRationalTest(String name) {
036        super(name);
037    }
038
039
040    /**
041     */
042    public static Test suite() {
043        TestSuite suite = new TestSuite(BigRationalTest.class);
044        return suite;
045    }
046
047
048    BigRational a, b, c, d, e;
049
050
051    @Override
052    protected void setUp() {
053        a = b = c = d = e = null;
054    }
055
056
057    @Override
058    protected void tearDown() {
059        a = b = c = d = e = null;
060    }
061
062
063    /**
064     * Test static initialization and constants.
065     */
066    public void testConstants() {
067        a = BigRational.ZERO;
068        b = BigRational.ONE;
069        c = BigRational.RNDIF(b, b);
070
071        assertEquals("1-1 = 0", c, a);
072        assertTrue("1-1 = 0", c.isZERO());
073        assertTrue("1 = 1", b.isONE());
074        assertEquals("1-1 = 0", c, a);
075    }
076
077
078    /**
079     * Test bitLength.
080     */
081    public void testBitLength() {
082        a = BigRational.ZERO;
083        b = BigRational.ONE;
084        c = BigRational.RNDIF(b, b);
085        d = BigRational.RNRAND(500);
086
087        assertEquals("len(0) = 3", 3, a.bitLength());
088        assertEquals("len(1) = 4", 4, b.bitLength());
089        assertEquals("len(-1) = 4", 4, b.negate().bitLength());
090        assertTrue("len(rnd) >= 1", 1 <= d.bitLength());
091    }
092
093
094    /**
095     * Test constructor and toString.
096     */
097    public void testConstructor() {
098        a = new BigRational("6/8");
099        b = new BigRational("3/4");
100
101        assertEquals("6/8 = 3/4", a, b);
102
103        a = new BigRational("3/-4");
104        b = new BigRational("-3/4");
105
106        assertEquals("3/-4 = -3/4", a, b);
107
108        String s = "6/1111111111111111111111111111111111111111111";
109        a = new BigRational(s);
110        String t = a.toString();
111
112        assertEquals("stringConstr = toString", s, t);
113
114        a = new BigRational(1);
115        b = new BigRational(-1);
116        c = BigRational.RNSUM(b, a);
117
118        assertTrue("1 = 1", a.isONE());
119        assertEquals("1+(-1) = 0", c, BigRational.ZERO);
120
121        s = "1.500000000";
122        a = new BigRational(s);
123        b = new BigRational("3/2");
124        assertEquals("decimalConstr = b ", a, b);
125
126        s = "-1.500000000";
127        a = new BigRational(s);
128        b = new BigRational("-3/2");
129        assertEquals("decimalConstr = b ", a, b);
130
131        s = "0.750000000";
132        a = new BigRational(s);
133        b = new BigRational("3/4");
134        assertEquals("decimalConstr = b ", a, b);
135
136        s = "0.333333333";
137        a = new BigRational(s);
138        t = a.toString(9);
139        assertEquals("decimalConstr = b " + t, s, t);
140
141        s = "-0.000033333";
142        a = new BigRational(s);
143        t = a.toString(9);
144        assertEquals("decimalConstr = b " + t, s, t);
145        //System.out.println("a = " + a);
146    }
147
148
149    /**
150     * Test random rationals.
151     */
152    public void testRandom() {
153        a = BigRational.RNRAND(500);
154        b = new BigRational("" + a);
155        c = BigRational.RNDIF(b, a);
156
157        assertEquals("a-b = 0", c, BigRational.ZERO);
158
159        d = new BigRational(b.numerator(), b.denominator());
160        assertEquals("sign(a-a) = 0", 0, b.compareTo(d));
161    }
162
163
164    /**
165     * Test addition.
166     */
167    public void testAddition() {
168        a = BigRational.RNRAND(100);
169        b = BigRational.RNSUM(a, a);
170        c = BigRational.RNDIF(b, a);
171
172        assertEquals("a+a-a = a", c, a);
173        assertEquals("a+a-a = a", 0, BigRational.RNCOMP(c, a));
174
175        d = BigRational.RNSUM(a, BigRational.ZERO);
176        assertEquals("a+0 = a", d, a);
177        d = BigRational.RNDIF(a, BigRational.ZERO);
178        assertEquals("a-0 = a", d, a);
179        d = BigRational.RNDIF(a, a);
180        assertEquals("a-a = 0", d, BigRational.ZERO);
181
182    }
183
184
185    /**
186     * Test multiplication.
187     */
188    public void testMultiplication() {
189        a = BigRational.RNRAND(100);
190        b = BigRational.RNPROD(a, a);
191        c = BigRational.RNQ(b, a);
192
193        assertEquals("a*a/a = a", c, a);
194        assertEquals("a*a/a = a", 0, BigRational.RNCOMP(c, a));
195
196        d = BigRational.RNPROD(a, BigRational.ONE);
197        assertEquals("a*1 = a", d, a);
198        d = BigRational.RNQ(a, BigRational.ONE);
199        assertEquals("a/1 = a", d, a);
200
201        a = BigRational.RNRAND(100);
202        b = BigRational.RNINV(a);
203        c = BigRational.RNPROD(a, b);
204
205        assertTrue("a*1/a = 1", c.isONE());
206    }
207
208
209    /**
210     * Test distributive law.
211     */
212    public void testDistributive() {
213        BigRational fac = new BigRational();
214
215        a = fac.random(500);
216        b = fac.random(500);
217        c = fac.random(500);
218
219        d = a.multiply(b.sum(c));
220        e = a.multiply(b).sum(a.multiply(c));
221
222        assertEquals("a(b+c) = ab+ac", d, e);
223    }
224
225
226    /**
227     * Test iterator.
228     */
229    public void testIterator() {
230        int t = 0;
231        BigRational bi = new BigRational();
232        bi.setAllIterator();
233        BigRational j = null, elem = null;
234        for (BigRational i : bi) {
235            t++;
236            //System.out.println("i = " + i);
237            if (t >= 20) {
238                j = i;
239                break;
240            }
241        }
242        assertFalse("j == null ", j == null);
243        elem = new BigRational(-2, 3);
244        assertTrue("j == 10 ", j.equals(elem));
245    }
246
247
248    /**
249     * Test non-negative iterator.
250     */
251    public void testNNIterator() {
252        int t = 0;
253        BigRational bi = new BigRational();
254        bi.setNonNegativeIterator();
255        BigRational j = null, elem = null;
256        Iterator<BigRational> iter = bi.iterator();
257        while (iter.hasNext()) {
258            BigRational i = iter.next();
259            t++;
260            //System.out.println("i = " + i);
261            if (t >= 20) {
262                j = i;
263                break;
264            }
265        }
266        assertFalse("j == null ", j == null);
267        elem = new BigRational(4, 3);
268        assertTrue("j == 10 ", j.equals(elem));
269    }
270
271
272    /**
273     * Test non-negative unique iterator.
274     */
275    public void testUniqueNNIterator() {
276        int t = 0;
277        BigRational bi = new BigRational();
278        bi.setNonNegativeIterator();
279        //bi.setAllIterator();
280        BigRational j = null, elem = null;
281        Iterator<BigRational> iter = bi.uniqueIterator();
282        while (iter.hasNext()) {
283            BigRational i = iter.next();
284            t++;
285            //System.out.println("i = " + i);
286            if (t >= 20) {
287                j = i;
288                break;
289            }
290        }
291        assertFalse("j == null ", j == null);
292        elem = new BigRational(5, 3);
293        assertTrue("j == 10 ", j.equals(elem));
294    }
295
296
297    /**
298     * Test doubleValue.
299     */
300    public void testDoubleValue() {
301        BigRational fac = new BigRational();
302
303        //a = fac.getONE(); 
304        //a = fac.getZERO(); 
305        a = fac.random(5000);
306        //System.out.println("a = " + a.toString());
307        //System.out.println("a = " + a.toString(16+2));
308        double d = a.doubleValue();
309        //System.out.println("d = "  + d + ", a = " + a.toString(16));
310        String as = a.toString(16);
311        String ds = Double.toString(d);
312        if (ds.endsWith(".0")) {
313            ds = ds.substring(0, ds.length() - 2);
314        }
315        if (ds.indexOf(".") >= 0) {
316            while (ds.endsWith("0")) {
317                ds = ds.substring(0, ds.length() - 1);
318            }
319        }
320        if (as.indexOf(".") >= 0) {
321            while (as.endsWith("0")) {
322                as = as.substring(0, as.length() - 1);
323            }
324        }
325        int l = Math.min(as.length(), ds.length());
326        as = as.substring(0, l - 1);
327        ds = ds.substring(0, l - 1);
328        assertEquals("a = decimal(d): " + d, as, ds);
329    }
330}