Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.fd;
006
007
008
009import edu.jas.arith.BigComplex;
010import edu.jas.arith.BigInteger;
011import edu.jas.arith.BigRational;
012import edu.jas.arith.ModInteger;
013import edu.jas.arith.ModIntegerRing;
014import edu.jas.poly.AlgebraicNumber;
015import edu.jas.poly.AlgebraicNumberRing;
016import edu.jas.poly.GenPolynomial;
017import edu.jas.poly.GenPolynomialRing;
018import edu.jas.poly.GenSolvablePolynomial;
019import edu.jas.poly.GenSolvablePolynomialRing;
020import edu.jas.poly.TermOrder;
021import edu.jas.poly.TermOrderByName;
022
023// import java.util.Map;
024
025import junit.framework.Test;
026import junit.framework.TestCase;
027import junit.framework.TestSuite;
028
029
030/**
031 * Solvable GreatestCommonDivisor factory tests with JUnit.
032 * @author Heinz Kredel
033 */
034
035public class SGCDFactoryTest extends TestCase {
036
037
038    /**
039     * main.
040     */
041    public static void main(String[] args) {
042        junit.textui.TestRunner.run(suite());
043    }
044
045
046    /**
047     * Constructs a <CODE>SGCDFactoryTest</CODE> object.
048     * @param name String.
049     */
050    public SGCDFactoryTest(String name) {
051        super(name);
052    }
053
054
055    /**
056     */
057    public static Test suite() {
058        TestSuite suite = new TestSuite(SGCDFactoryTest.class);
059        return suite;
060    }
061
062
063    TermOrder to = TermOrderByName.INVLEX;
064
065
066    GenSolvablePolynomialRing<BigInteger> dfac;
067
068
069    GenSolvablePolynomialRing<BigInteger> cfac;
070
071
072    GenSolvablePolynomialRing<GenPolynomial<BigInteger>> rfac;
073
074
075    BigInteger ai, bi, ci, di, ei;
076
077
078    GenSolvablePolynomial<BigInteger> a, b, c, d, e;
079
080
081    GenSolvablePolynomial<GenPolynomial<BigInteger>> ar, br, cr, dr, er;
082
083
084    int rl = 5;
085
086
087    int kl = 4;
088
089
090    int ll = 5;
091
092
093    int el = 3;
094
095
096    float q = 0.3f;
097
098
099    @Override
100    protected void setUp() {
101        a = b = c = d = e = null;
102        ai = bi = ci = di = ei = null;
103        ar = br = cr = dr = er = null;
104        dfac = new GenSolvablePolynomialRing<BigInteger>(new BigInteger(1), rl, to);
105        cfac = new GenSolvablePolynomialRing<BigInteger>(new BigInteger(1), rl - 1, to);
106        rfac = new GenSolvablePolynomialRing<GenPolynomial<BigInteger>>(cfac, 1, to);
107    }
108
109
110    @Override
111    protected void tearDown() {
112        a = b = c = d = e = null;
113        ai = bi = ci = di = ei = null;
114        ar = br = cr = dr = er = null;
115        dfac = null;
116        cfac = null;
117        rfac = null;
118    }
119
120
121    /**
122     * Test get BigInteger implementation.
123     */
124    public void testBigInteger() {
125        BigInteger bi = new BigInteger();
126        GreatestCommonDivisor<BigInteger> ufd;
127
128        ufd = SGCDFactory.getImplementation(bi);
129        //System.out.println("ufd = " + ufd);
130        assertTrue("ufd = Primitive " + ufd, ufd instanceof GreatestCommonDivisorPrimitive);
131
132        ufd = SGCDFactory.getProxy(bi);
133        //System.out.println("ufd = " + ufd);
134        assertTrue("ufd = Parallel Proxy " + ufd, ufd instanceof SGCDParallelProxy);
135        assertTrue("ufd = Primitive " + ufd, ((SGCDParallelProxy)ufd).e1 instanceof GreatestCommonDivisorPrimitive);
136    }
137
138
139    /**
140     * Test get ModInteger implementation.
141     */
142    public void testModInteger() {
143        ModIntegerRing mi = new ModIntegerRing(19, true);
144        GreatestCommonDivisor<ModInteger> ufd;
145
146        ufd = SGCDFactory.getImplementation(mi);
147        //System.out.println("ufd = " + ufd);
148        assertTrue("ufd = Simple " + ufd, ufd instanceof GreatestCommonDivisorSimple);
149
150        ufd = SGCDFactory.getProxy(mi);
151        //System.out.println("ufd = " + ufd);
152        assertTrue("ufd = Parallel Proxy " + ufd, ufd instanceof SGCDParallelProxy);
153        assertTrue("ufd = Primitive " + ufd, ((SGCDParallelProxy)ufd).e2 instanceof GreatestCommonDivisorSimple);
154
155        mi = new ModIntegerRing(30);
156        ufd = SGCDFactory.getImplementation(mi);
157        //System.out.println("ufd = " + ufd);
158        assertTrue("ufd = Primitive " + ufd, ufd instanceof GreatestCommonDivisorPrimitive);
159
160        ufd = SGCDFactory.getProxy(mi);
161        //System.out.println("ufd = " + ufd);
162        assertTrue("ufd = Parallel Proxy " + ufd, ufd instanceof SGCDParallelProxy);
163        assertTrue("ufd = Simple " + ufd, ((SGCDParallelProxy)ufd).e1 instanceof GreatestCommonDivisorPrimitive);
164    }
165
166
167    /**
168     * Test get BigRational implementation.
169     */
170    public void testBigRational() {
171        BigRational b = new BigRational();
172        GreatestCommonDivisor<BigRational> ufd;
173
174        ufd = SGCDFactory.getImplementation(b);
175        //System.out.println("ufd = " + ufd);
176        assertTrue("ufd = Simple " + ufd, ufd instanceof GreatestCommonDivisorSimple);
177
178        ufd = SGCDFactory.getProxy(b);
179        //System.out.println("ufd = " + ufd);
180        assertTrue("ufd = Parallel Proxy " + ufd, ufd instanceof SGCDParallelProxy);
181        assertTrue("ufd = Simple " + ufd, ((SGCDParallelProxy)ufd).e2 instanceof GreatestCommonDivisorSimple);
182    }
183
184
185    /**
186     * Test get BigComplex implementation.
187     */
188    public void testBigComplex() {
189        BigComplex b = new BigComplex();
190        GreatestCommonDivisor<BigComplex> ufd;
191
192        ufd = SGCDFactory.<BigComplex> getImplementation(b);
193        //System.out.println("ufd = " + ufd);
194        assertTrue("ufd = Simple " + ufd, ufd instanceof GreatestCommonDivisorSimple);
195
196        ufd = SGCDFactory.<BigComplex> getProxy(b);
197        //System.out.println("ufd = " + ufd);
198        assertTrue("ufd = Parallel Proxy " + ufd, ufd instanceof SGCDParallelProxy);
199        assertTrue("ufd = Simple " + ufd, ((SGCDParallelProxy)ufd).e1 instanceof GreatestCommonDivisorSimple);
200    }
201
202
203    /**
204     * Test get AlgebraicNumber&lt;BigRational&gt; implementation.
205     * 
206     */
207    public void testAlgebraicNumberBigRational() {
208        BigRational b = new BigRational();
209        GenPolynomialRing<BigRational> fac;
210        fac = new GenPolynomialRing<BigRational>(b, 1);
211        GenPolynomial<BigRational> mo = fac.random(kl, ll, el, q);
212        while (mo.isZERO() || mo.isONE() || mo.isConstant()) {
213            mo = fac.random(kl, ll, el, q);
214        }
215
216        AlgebraicNumberRing<BigRational> afac;
217        afac = new AlgebraicNumberRing<BigRational>(mo);
218
219        GreatestCommonDivisor<AlgebraicNumber<BigRational>> ufd;
220
221        ufd = SGCDFactory.<AlgebraicNumber<BigRational>> getImplementation(afac);
222        //System.out.println("ufd1 = " + ufd);
223        assertTrue("ufd = Primitive " + ufd, ufd instanceof GreatestCommonDivisorPrimitive);
224
225        ufd = SGCDFactory.<AlgebraicNumber<BigRational>> getProxy(afac);
226        //System.out.println("ufd1 = " + ufd);
227        assertTrue("ufd = Parallel Proxy " + ufd, ufd instanceof SGCDParallelProxy);
228        assertTrue("ufd = Primitive " + ufd, ((SGCDParallelProxy)ufd).e2 instanceof GreatestCommonDivisorPrimitive);
229
230        mo = fac.univariate(0).subtract(fac.getONE());
231        afac = new AlgebraicNumberRing<BigRational>(mo, true);
232
233        ufd = SGCDFactory.<AlgebraicNumber<BigRational>> getImplementation(afac);
234        //System.out.println("ufd1 = " + ufd);
235        assertTrue("ufd = Simple " + ufd, ufd instanceof GreatestCommonDivisorSimple);
236
237        ufd = SGCDFactory.<AlgebraicNumber<BigRational>> getProxy(afac);
238        //System.out.println("ufd1 = " + ufd);
239        assertTrue("ufd = Parallel Proxy " + ufd, ufd instanceof SGCDParallelProxy);
240        assertTrue("ufd = Simple " + ufd, ((SGCDParallelProxy)ufd).e1 instanceof GreatestCommonDivisorSimple);
241    }
242
243
244    /**
245     * Test get AlgebraicNumber&lt;ModInteger&gt; implementation.
246     */
247    public void testAlgebraicNumberModInteger() {
248        ModIntegerRing b = new ModIntegerRing(19, true);
249        GenPolynomialRing<ModInteger> fac;
250        fac = new GenPolynomialRing<ModInteger>(b, 1);
251        GenPolynomial<ModInteger> mo = fac.random(kl, ll, el, q);
252        while (mo.isZERO() || mo.isONE() || mo.isConstant()) {
253            mo = fac.random(kl, ll, el, q);
254        }
255
256        AlgebraicNumberRing<ModInteger> afac;
257        afac = new AlgebraicNumberRing<ModInteger>(mo);
258
259        AlgebraicNumber<ModInteger> a = afac.getONE();
260        assertTrue("a == 1 " + a, a.isONE());
261        GreatestCommonDivisor<AlgebraicNumber<ModInteger>> ufd;
262
263        ufd = SGCDFactory.<AlgebraicNumber<ModInteger>> getImplementation(afac);
264        //System.out.println("ufd2 = " + ufd);
265        assertTrue("ufd = Primitive " + ufd, ufd instanceof GreatestCommonDivisorPrimitive);
266
267        ufd = SGCDFactory.<AlgebraicNumber<ModInteger>> getProxy(afac);
268        //System.out.println("ufd2 = " + ufd);
269        assertTrue("ufd = Parallel Proxy " + ufd, ufd instanceof SGCDParallelProxy);
270        assertTrue("ufd = Primitive " + ufd, ((SGCDParallelProxy)ufd).e2 instanceof GreatestCommonDivisorPrimitive);
271
272        mo = fac.univariate(0).subtract(fac.getONE());
273        afac = new AlgebraicNumberRing<ModInteger>(mo, true);
274        ufd = SGCDFactory.<AlgebraicNumber<ModInteger>> getImplementation(afac);
275        //System.out.println("ufd2 = " + ufd);
276        assertTrue("ufd = Simple " + ufd, ufd instanceof GreatestCommonDivisorSimple);
277
278        ufd = SGCDFactory.<AlgebraicNumber<ModInteger>> getProxy(afac);
279        //System.out.println("ufd2 = " + ufd);
280        assertTrue("ufd = Parallel Proxy " + ufd, ufd instanceof SGCDParallelProxy);
281        assertTrue("ufd = Primitive " + ufd, ((SGCDParallelProxy)ufd).e2 instanceof GreatestCommonDivisorPrimitive);
282    }
283
284}