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 Primitive PRS algorithm tests with JUnit. <b>Note:</b> eventually not in
029 * sync with implementation.
030 * @author Heinz Kredel
031 */
032
033public class GCDPrimitiveQuatTest 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>GCDPrimitiveQuatTest</CODE> object.
047     * @param name String.
048     */
049    public GCDPrimitiveQuatTest(String name) {
050        super(name);
051    }
052
053
054    /**
055     */
056    public static Test suite() {
057        TestSuite suite = new TestSuite(GCDPrimitiveQuatTest.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 GreatestCommonDivisorPrimitive<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 testQuatBaseGcdPrimitive() {
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            //a = fd.basePrimitivePart(a);
147            //b = fd.basePrimitivePart(b);
148            //c = (GenSolvablePolynomial<BigQuaternion>) fd.basePrimitivePart(c).abs();
149            //System.out.println("a  = " + a);
150            //System.out.println("b  = " + b);
151            //System.out.println("c  = " + c);
152
153            a = a.multiply(c);
154            b = b.multiply(c);
155            //a = c.multiply(a);
156            //b = c.multiply(b);
157            //System.out.println("a  = " + a);
158            //System.out.println("b  = " + b);
159
160            d = fd.leftBaseGcd(a, b);
161            //System.out.println("d  = " + d);
162            //System.out.println("c  = " + c);
163
164            e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(a, d);
165            //System.out.println("e = " + e);
166            assertTrue("gcd(ca,cb) | ca " + e, e.isZERO());
167
168            e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(b, d);
169            //System.out.println("e = " + e);
170            assertTrue("gcd(ca,cb) | cb " + e, e.isZERO());
171
172            // todo
173            //e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(d, c);
174            e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(c, d);
175            //System.out.println("e = " + e);
176            assertTrue("c | gcd(ca,cb) " + e, e.isZERO());
177        }
178    }
179
180
181    /**
182     * Test quaternion univariate recursive left gcd simple.
183     */
184    //@SuppressWarnings("cast")
185    public void testRecursiveLeftGCDPrimitive() {
186        String[] vars = new String[] { "a", "b" };
187        BigQuaternionRing cf = new BigQuaternionRing();
188        //GenSolvablePolynomialRing<BigQuaternion> qfac;
189        qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, vars);
190        //System.out.println("qfac = " + qfac.toScript());
191
192        RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>();
193        //qfac.addRelations(wl);
194        //System.out.println("qfac = " + qfac.toScript());
195        rfac = (RecSolvablePolynomialRing<BigQuaternion>) qfac.recursive(1);
196        //System.out.println("rfac = " + rfac.toScript());
197
198        GreatestCommonDivisorAbstract<BigQuaternion> fd = new GreatestCommonDivisorPrimitive<BigQuaternion>(cf);
199        //System.out.println("fd = " + fd);
200
201        //kl = 3;
202        int ll = 3;
203        int el = 3;
204
205        ar = rfac.random(kl, ll, el, q);
206        br = rfac.random(kl, ll, el, q);
207        cr = rfac.random(kl, ll, el, q);
208        ////cr = (RecSolvablePolynomial<BigQuaternion>) cr.abs();
209        //cr = PolyUtil.<BigQuaternion> monic(cr); // leftMonic
210        //cr = (RecSolvablePolynomial<BigQuaternion>) fd.recursivePrimitivePart(cr).abs();
211        //System.out.println("ar = " + ar);
212        //System.out.println("br = " + br);
213
214        if (cr.isConstant()) {
215            er = rfac.univariate(0);
216            System.out.println("univ(0) = " + er);
217            cr = (RecSolvablePolynomial<BigQuaternion>) cr.sum(er);
218        }
219        //System.out.println("cr = " + cr);
220
221        //ar0 = ar;
222        //br0 = br;
223        //ar = cr.multiply(ar);
224        //br = cr.multiply(br);
225        ar = ar.multiply(cr);
226        br = br.multiply(cr);
227        //System.out.println("ar = " + ar);
228        //System.out.println("br = " + br);
229
230        dr = fd.leftRecursiveUnivariateGcd(ar, br);
231        //System.out.println("cr_r = " + cr);
232        //System.out.println("dr_r = " + dr);
233        //dr = PolyUtil.<BigQuaternion> monic(dr); // leftMonic
234        //System.out.println("monic(dr_r) = " + dr);
235
236        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(dr, cr);
237        //System.out.println("er = " + er);
238        assertTrue("c | gcd(ac,bc) " + er, er.isZERO());
239
240        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(ar, dr);
241        //System.out.println("er = " + er);
242        assertTrue("gcd(a,b) | a " + er, er.isZERO());
243
244        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(br, dr);
245        //System.out.println("er = " + er);
246        assertTrue("gcd(a,b) | b " + er, er.isZERO());
247    }
248
249
250    /**
251     * Test quaternion univariate recursive left gcd simple Weyl.
252     */
253    //@SuppressWarnings("cast")
254    public void testRecursiveLeftGCDPrimitiveWeyl() {
255        String[] vars = new String[] { "a", "b" };
256        BigQuaternionRing cf = new BigQuaternionRing();
257        //GenSolvablePolynomialRing<BigQuaternion> qfac;
258        qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, vars);
259        //System.out.println("qfac = " + qfac.toScript());
260
261        RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>();
262        qfac.addRelations(wl);
263        //System.out.println("qfac = " + qfac.toScript());
264        rfac = (RecSolvablePolynomialRing<BigQuaternion>) qfac.recursive(1);
265        //System.out.println("rfac = " + rfac.toScript());
266
267        GreatestCommonDivisorAbstract<BigQuaternion> fd = new GreatestCommonDivisorPrimitive<BigQuaternion>(cf);
268        //System.out.println("fd = " + fd);
269
270        //kl = 3;
271        ll = 2;
272        el = 3;
273
274        ar = rfac.random(kl, ll, el + 1, q);
275        br = rfac.random(kl, ll, el, q);
276        cr = rfac.random(kl, ll, el, q);
277        ////cr = (RecSolvablePolynomial<BigQuaternion>) cr.abs();
278        ///cr = PolyUtil.<BigQuaternion> monic(cr); // leftMonic
279        //cr = (RecSolvablePolynomial<BigQuaternion>) fd.recursivePrimitivePart(cr).abs();
280        //System.out.println("ar = " + ar);
281        //System.out.println("br = " + br);
282
283        if (cr.isConstant()) {
284            er = rfac.univariate(0);
285            System.out.println("univ(0) = " + er);
286            cr = (RecSolvablePolynomial<BigQuaternion>) cr.sum(er);
287        }
288        //System.out.println("cr = " + cr);
289
290        //ar0 = ar;
291        //br0 = br;
292        //ar = cr.multiply(ar);
293        //br = cr.multiply(br);
294        ar = ar.multiply(cr);
295        br = br.multiply(cr);
296        //System.out.println("ar = " + ar);
297        //System.out.println("br = " + br);
298
299        dr = fd.leftRecursiveUnivariateGcd(ar, br);
300        //System.out.println("cr_w = " + cr);
301        //System.out.println("dr_w = " + dr);
302        //dr = PolyUtil.<BigQuaternion> monic(dr); // leftMonic
303        //System.out.println("monic(dr_w) = " + dr);
304
305        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(dr, cr);
306        //System.out.println("er = " + er);
307        assertTrue("c | gcd(ac,bc) " + er, er.isZERO());
308
309        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(ar, dr);
310        //System.out.println("er = " + er);
311        assertTrue("gcd(a,b) | a " + er, er.isZERO());
312
313        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(br, dr);
314        //System.out.println("er = " + er);
315        assertTrue("gcd(a,b) | b " + er, er.isZERO());
316    }
317
318
319    /**
320     * Test 3 vars arbitrary recursive gcd simple.
321     */
322    @SuppressWarnings("cast")
323    public void testArbitrary3RecursiveGCDPrimitive() {
324        String[] cvars = new String[] { "a", "b" };
325        String[] vars = new String[] { "c" };
326        BigQuaternionRing cf = new BigQuaternionRing();
327        qfac = new GenSolvablePolynomialRing<BigQuaternion>(cf, to, cvars);
328        RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>();
329        //dfac.addRelations(wl);
330        //System.out.println("qfac = " + qfac.toScript());
331        rfac = new RecSolvablePolynomialRing<BigQuaternion>(qfac, to, vars);
332        //System.out.println("rfac = " + rfac.toScript());
333
334        //kl = 3;
335        int ll = 2;
336        int el = 2;
337
338        ar0 = rfac.random(kl, ll, el, q);
339        br0 = rfac.random(kl, ll, el, q);
340        cr = rfac.random(kl, ll, el, q);
341
342        //ar0 = rfac.parse(" ");
343        //br0 = rfac.parse(" ");
344        //cr  = rfac.parse(" ");
345
346        //cr = (RecSolvablePolynomial<BigQuaternion>) fd.recursivePrimitivePart(cr).abs();
347        //cr = (RecSolvablePolynomial<BigQuaternion>) cr.monic();
348        if (cr.isZERO()) {
349            cr = rfac.getONE();
350        }
351        if (cr.isConstant()) {
352            er = rfac.univariate(0);
353            System.out.println("univ(0) = " + er);
354            cr = (RecSolvablePolynomial<BigQuaternion>) cr.sum(er);
355        }
356        //System.out.println("ar = " + ar);
357        //System.out.println("br = " + br);
358        //System.out.println("cr = " + cr);
359
360        // left gcd
361        ar = ar0.multiply(cr);
362        br = br0.multiply(cr);
363        //System.out.println("ar = " + ar);
364        //System.out.println("br = " + br);
365
366        dr = fd.leftRecursiveGcd(ar, br);
367        //System.out.println("cr = " + cr);
368        //System.out.println("dr = " + dr);
369
370        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(dr, cr);
371        //System.out.println("er = " + er);
372        assertTrue("c | gcd(ac,bc): " + er, er.isZERO());
373
374        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(ar, dr);
375        //System.out.println("er = " + er);
376        assertTrue("gcd(ac,bc) | ac: " + er, er.isZERO());
377
378        er = FDUtil.<BigQuaternion> recursiveSparsePseudoRemainder(br, dr);
379        //System.out.println("er = " + er);
380        assertTrue("gcd(ac,bc) | bc: " + er, er.isZERO());
381    }
382
383}