Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.fd;
006
007
008import edu.jas.arith.BigQuaternion;
009import edu.jas.arith.BigQuaternionRing;
010import edu.jas.kern.ComputerThreads;
011import edu.jas.poly.GenPolynomial;
012import edu.jas.poly.GenSolvablePolynomial;
013import edu.jas.poly.GenSolvablePolynomialRing;
014import edu.jas.poly.PolyUtil;
015import edu.jas.poly.RecSolvablePolynomial;
016import edu.jas.poly.RecSolvablePolynomialRing;
017import edu.jas.poly.RelationGenerator;
018import edu.jas.poly.TermOrder;
019import edu.jas.poly.TermOrderByName;
020import edu.jas.poly.WeylRelationsIterated;
021
022import junit.framework.Test;
023import junit.framework.TestCase;
024import junit.framework.TestSuite;
025
026
027/**
028 * GCD Simple PRS algorithm tests with JUnit. <b>Note:</b> eventually not in
029 * sync with implementation.
030 * @author Heinz Kredel
031 */
032
033public class GCDSimpleQuatTest extends TestCase {
034
035
036    /**
037     * main.
038     */
039    public static void main(String[] args) {
040        junit.textui.TestRunner.run(suite());
041        ComputerThreads.terminate();
042    }
043
044
045    /**
046     * Constructs a <CODE>GCDSimpleQuatTest</CODE> object.
047     * @param name String.
048     */
049    public GCDSimpleQuatTest(String name) {
050        super(name);
051    }
052
053
054    /**
055     */
056    public static Test suite() {
057        TestSuite suite = new TestSuite(GCDSimpleQuatTest.class);
058        return suite;
059    }
060
061
062    GreatestCommonDivisorAbstract<BigQuaternion> fd;
063
064
065    TermOrder to = TermOrderByName.INVLEX;
066
067
068    GenSolvablePolynomialRing<BigQuaternion> qfac;
069
070
071    //GenSolvablePolynomialRing<GenPolynomial<BigQuaternion>> rfac;
072    RecSolvablePolynomialRing<BigQuaternion> rfac;
073
074
075    GenSolvablePolynomial<BigQuaternion> a, b, a0, b0, c, d, e, f;
076
077
078    GenSolvablePolynomial<GenPolynomial<BigQuaternion>> ar, br, cr, dr, er, ar0, br0;
079
080
081    int rl = 4;
082
083
084    int kl = 2;
085
086
087    int ll = 2;
088
089
090    int el = 3;
091
092
093    float q = 0.25f;
094
095
096    @Override
097    protected void setUp() {
098        a = b = c = d = e = null;
099        ar = br = cr = dr = er = null;
100        String[] vars = new String[] { "a", "b", "c", "d" };
101        BigQuaternionRing cf = new BigQuaternionRing();
102        fd = new GreatestCommonDivisorSimple<BigQuaternion>(cf);
103        //System.out.println("fd = " + fd);
104        qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, vars);
105        RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>();
106        //qfac.addRelations(wl);
107        rfac = (RecSolvablePolynomialRing<BigQuaternion>) qfac.recursive(1);
108        //System.out.println("qfac = " + qfac);
109        //System.out.println("rfac = " + rfac);
110    }
111
112
113    @Override
114    protected void tearDown() {
115        a = b = c = d = e = null;
116        ar = br = cr = dr = er = null;
117        fd = null;
118        qfac = null;
119        rfac = null;
120    }
121
122
123    /**
124     * Test quaternion base gcd simple.
125     */
126    public void testQuatBaseGcdSimple() {
127        String[] uvars = new String[] { "x" };
128        BigQuaternionRing cf = new BigQuaternionRing();
129        qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, uvars);
130        //System.out.println("qfac = " + qfac.toScript());
131        for (int i = 0; i < 3; i++) {
132            //System.out.println();
133            a = qfac.random(kl + (i), ll + 2 * i, el + 2, q);
134            a = (GenSolvablePolynomial<BigQuaternion>) a.sum(qfac.univariate(0).power(2));
135            b = qfac.random(kl + (i + 1), ll + i, el + 2, q);
136            b = (GenSolvablePolynomial<BigQuaternion>) b.sum(qfac.univariate(0));
137            c = qfac.random(kl + (i + 1), ll + 1, el + 1, q);
138            c = c.multiply(qfac.univariate(0));
139            if (a.isZERO() || b.isZERO() || c.isZERO()) {
140                // skip for this turn
141                continue;
142            }
143            a = a.monic();
144            b = b.monic();
145            c = c.monic();
146            //System.out.println("a  = " + a);
147            //System.out.println("b  = " + b);
148            //System.out.println("c  = " + c);
149
150            a = a.multiply(c);
151            b = b.multiply(c);
152            //a = c.multiply(a);
153            //b = c.multiply(b);
154            //System.out.println("a  = " + a);
155            //System.out.println("b  = " + b);
156
157            d = fd.leftBaseGcd(a, b);
158            //System.out.println("d  = " + d);
159            //System.out.println("c  = " + c);
160
161            e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(a, d);
162            //System.out.println("e = " + e);
163            assertTrue("gcd(ca,cb) | ca " + e, e.isZERO());
164
165            e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(b, d);
166            //System.out.println("e = " + e);
167            assertTrue("gcd(ca,cb) | cb " + e, e.isZERO());
168
169            // todo
170            //e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(d, c);
171            e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(c, d);
172            //System.out.println("e = " + e);
173            assertTrue("c | gcd(ca,cb) " + e, e.isZERO());
174        }
175    }
176
177
178    /**
179     * Test quaternion univariate recursive left gcd simple.
180     */
181    //@SuppressWarnings("cast")
182    public void testRecursiveLeftGCDSimple() {
183        String[] vars = new String[] { "a", "b" };
184        BigQuaternionRing cf = new BigQuaternionRing();
185        //GenSolvablePolynomialRing<BigQuaternion> qfac;
186        qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, vars);
187        //System.out.println("qfac = " + qfac.toScript());
188
189        RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>();
190        //qfac.addRelations(wl);
191        //System.out.println("qfac = " + qfac.toScript());
192        rfac = (RecSolvablePolynomialRing<BigQuaternion>) qfac.recursive(1);
193        //System.out.println("rfac = " + rfac.toScript());
194
195        GreatestCommonDivisorAbstract<BigQuaternion> fd = new GreatestCommonDivisorSimple<BigQuaternion>(cf);
196        //System.out.println("fd = " + fd);
197
198        //kl = 3;
199        ll = 3;
200        el = 3;
201
202        ar = rfac.random(kl, ll, el + 1, q);
203        br = rfac.random(kl, ll, el, q);
204        cr = rfac.random(kl, ll, el, q);
205        ////cr = (RecSolvablePolynomial<BigQuaternion>) cr.abs();
206        ///cr = PolyUtil.<BigQuaternion> monic(cr); // leftMonic
207        //cr = (RecSolvablePolynomial<BigQuaternion>) fd.recursivePrimitivePart(cr).abs();
208        //System.out.println("ar = " + ar);
209        //System.out.println("br = " + br);
210
211        if (cr.isConstant()) {
212            er = rfac.univariate(0);
213            System.out.println("univ(0) = " + er);
214            cr = (RecSolvablePolynomial<BigQuaternion>) cr.sum(er);
215        }
216        //System.out.println("cr = " + cr);
217
218        //ar0 = ar;
219        //br0 = br;
220        //ar = cr.multiply(ar);
221        //br = cr.multiply(br);
222        ar = ar.multiply(cr);
223        br = br.multiply(cr);
224        //System.out.println("ar = " + ar);
225        //System.out.println("br = " + br);
226
227        dr = fd.leftRecursiveUnivariateGcd(ar, br);
228        //System.out.println("cr_r = " + cr);
229        //System.out.println("dr_r = " + dr);
230        //dr = PolyUtil.<BigQuaternion> monic(dr); // leftMonic
231        //System.out.println("monic(dr_r) = " + dr);
232
233        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(dr, cr);
234        //System.out.println("er = " + er);
235        assertTrue("c | gcd(ac,bc) " + er, er.isZERO());
236
237        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(ar, dr);
238        //System.out.println("er = " + er);
239        assertTrue("gcd(a,b) | a " + er, er.isZERO());
240
241        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(br, dr);
242        //System.out.println("er = " + er);
243        assertTrue("gcd(a,b) | b " + er, er.isZERO());
244    }
245
246
247    /**
248     * Test quaternion univariate recursive left gcd simple Weyl.
249     */
250    //@SuppressWarnings("cast")
251    public void testRecursiveLeftGCDSimpleWeyl() {
252        String[] vars = new String[] { "a", "b" };
253        BigQuaternionRing cf = new BigQuaternionRing();
254        //GenSolvablePolynomialRing<BigQuaternion> qfac;
255        qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, vars);
256        //System.out.println("qfac = " + qfac.toScript());
257
258        RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>();
259        qfac.addRelations(wl);
260        //System.out.println("qfac = " + qfac.toScript());
261        rfac = (RecSolvablePolynomialRing<BigQuaternion>) qfac.recursive(1);
262        //System.out.println("rfac = " + rfac.toScript());
263
264        GreatestCommonDivisorAbstract<BigQuaternion> fd = new GreatestCommonDivisorSimple<BigQuaternion>(cf);
265        System.out.println("fd = " + fd);
266
267        //kl = 3;
268        ll = 3;
269        el = 3;
270
271        ar = rfac.random(kl, ll, el + 1, q);
272        br = rfac.random(kl, ll, el, q);
273        cr = rfac.random(kl, ll, el, q);
274        ////cr = (RecSolvablePolynomial<BigQuaternion>) cr.abs();
275        ///cr = PolyUtil.<BigQuaternion> monic(cr); // leftMonic
276        //cr = (RecSolvablePolynomial<BigQuaternion>) fd.recursivePrimitivePart(cr).abs();
277        //System.out.println("ar = " + ar);
278        //System.out.println("br = " + br);
279
280        if (cr.isConstant()) {
281            er = rfac.univariate(0);
282            System.out.println("univ(0) = " + er);
283            cr = (RecSolvablePolynomial<BigQuaternion>) cr.sum(er);
284        }
285        //System.out.println("cr = " + cr);
286
287        //ar0 = ar;
288        //br0 = br;
289        //ar = cr.multiply(ar);
290        //br = cr.multiply(br);
291        ar = ar.multiply(cr);
292        br = br.multiply(cr);
293        //System.out.println("ar = " + ar);
294        //System.out.println("br = " + br);
295
296        dr = fd.leftRecursiveUnivariateGcd(ar, br);
297        //System.out.println("cr_w = " + cr);
298        //System.out.println("dr_w = " + dr);
299        //dr = PolyUtil.<BigQuaternion> monic(dr); // leftMonic
300        //System.out.println("monic(dr_w) = " + dr);
301
302        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(dr, cr);
303        //System.out.println("er = " + er);
304        assertTrue("c | gcd(ac,bc) " + er, er.isZERO());
305
306        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(ar, dr);
307        //System.out.println("er = " + er);
308        assertTrue("gcd(a,b) | a " + er, er.isZERO());
309
310        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(br, dr);
311        //System.out.println("er = " + er);
312        assertTrue("gcd(a,b) | b " + er, er.isZERO());
313    }
314
315
316    /**
317     * Test 3 vars arbitrary recursive gcd simple.
318     */
319    @SuppressWarnings("cast")
320    public void testArbitrary3RecursiveGCDSimple() {
321        String[] cvars = new String[] { "a", "b" };
322        String[] vars = new String[] { "c" };
323        BigQuaternionRing cf = new BigQuaternionRing();
324        qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, cvars);
325        RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>();
326        //dfac.addRelations(wl);
327        //System.out.println("qfac = " + qfac.toScript());
328        rfac = new RecSolvablePolynomialRing<BigQuaternion>(qfac, to, vars);
329        System.out.println("rfac = " + rfac.toScript());
330
331        //kl = 3;
332        int ll = 2;
333        int el = 2;
334
335        ar0 = rfac.random(kl, ll, el, q);
336        br0 = rfac.random(kl, ll, el, q);
337        cr = rfac.random(kl, ll, el, q);
338
339        //cr = (RecSolvablePolynomial<BigQuaternion>) fd.recursivePrimitivePart(cr).abs();
340        //cr = (RecSolvablePolynomial<BigQuaternion>) cr.monic();
341        if (cr.isZERO()) {
342            cr = rfac.getONE();
343        }
344        if (cr.isConstant()) {
345            er = rfac.univariate(0);
346            System.out.println("univ(0) = " + er);
347            cr = (RecSolvablePolynomial<BigQuaternion>) cr.sum(er);
348        }
349        //System.out.println("cr = " + cr);
350        //System.out.println("ar = " + ar);
351        //System.out.println("br = " + br);
352        //System.out.println("cr = " + cr);
353
354        // left gcd
355        ar = ar0.multiply(cr);
356        br = br0.multiply(cr);
357        //System.out.println("ar = " + ar);
358        //System.out.println("br = " + br);
359
360        dr = fd.leftRecursiveGcd(ar, br);
361        //System.out.println("cr = " + cr);
362        //System.out.println("dr = " + dr);
363
364        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(dr, cr);
365        //System.out.println("er = " + er);
366        assertTrue("c | gcd(ac,bc): " + er, er.isZERO());
367
368        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(ar, dr);
369        //System.out.println("er = " + er);
370        assertTrue("gcd(ac,bc) | ac: " + er, er.isZERO());
371
372        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(br, dr);
373        //System.out.println("er = " + er);
374        assertTrue("gcd(ac,bc) | bc: " + er, er.isZERO());
375    }
376
377}