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