Source code

001/*
002 * $Id: GCDPrimitiveTest.java 5688 2017-01-03 08:45:09Z kredel $
003 */
004
005package edu.jas.fd;
006
007
008import java.util.List;
009
010import org.apache.log4j.BasicConfigurator;
011
012import edu.jas.arith.BigRational;
013import edu.jas.kern.ComputerThreads;
014import edu.jas.poly.GenPolynomial;
015import edu.jas.poly.GenSolvablePolynomial;
016import edu.jas.poly.GenSolvablePolynomialRing;
017import edu.jas.poly.PolyUtil;
018import edu.jas.poly.PolynomialList;
019import edu.jas.poly.RecSolvablePolynomial;
020import edu.jas.poly.RecSolvablePolynomialRing;
021import edu.jas.poly.RelationGenerator;
022import edu.jas.poly.TermOrder;
023import edu.jas.poly.WeylRelationsIterated;
024
025import junit.framework.Test;
026import junit.framework.TestCase;
027import junit.framework.TestSuite;
028
029
030/**
031 * GCD Primitive PRS algorithm tests with JUnit. <b>Note:</b> not in sync with
032 * implementation.
033 * @author Heinz Kredel
034 */
035
036public class GCDPrimitiveTest extends TestCase {
037
038
039    /**
040     * main.
041     */
042    public static void main(String[] args) {
043        BasicConfigurator.configure();
044        junit.textui.TestRunner.run(suite());
045        ComputerThreads.terminate();
046    }
047
048
049    /**
050     * Constructs a <CODE>GCDPrimitiveTest</CODE> object.
051     * @param name String.
052     */
053    public GCDPrimitiveTest(String name) {
054        super(name);
055    }
056
057
058    /**
059     */
060    public static Test suite() {
061        TestSuite suite = new TestSuite(GCDPrimitiveTest.class);
062        return suite;
063    }
064
065
066    GreatestCommonDivisorAbstract<BigRational> fd, fds;
067
068
069    TermOrder to = new TermOrder(TermOrder.INVLEX);
070
071
072    GenSolvablePolynomialRing<BigRational> dfac;
073
074
075    //GenSolvablePolynomialRing<GenPolynomial<BigRational>> rfac;
076    RecSolvablePolynomialRing<BigRational> rfac;
077
078
079    GenSolvablePolynomial<BigRational> a, b, a0, b0, c, d, e, a1, b1;
080
081
082    GenSolvablePolynomial<GenPolynomial<BigRational>> ar, br, ar0, br0, cr, dr, er, sr;
083
084
085    int rl = 4;
086
087
088    int kl = 2;
089
090
091    int ll = 2;
092
093
094    int el = 3;
095
096
097    float q = 0.25f;
098
099
100    @Override
101    protected void setUp() {
102        a = b = c = d = e = null;
103        ar = br = cr = dr = er = null;
104        String[] vars = new String[] { "a", "b", "c", "d" };
105        BigRational cf = new BigRational(1);
106        fd = new GreatestCommonDivisorPrimitive<BigRational>(cf);
107        fds = new GreatestCommonDivisorSimple<BigRational>(cf);
108        dfac = new GenSolvablePolynomialRing<BigRational>(cf, rl, to, vars);
109        RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>();
110        dfac.addRelations(wl);
111        rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(1);
112    }
113
114
115    @Override
116    protected void tearDown() {
117        a = b = c = d = e = null;
118        ar = br = cr = dr = er = null;
119        fd = null;
120        dfac = null;
121        rfac = null;
122    }
123
124
125    /**
126     * Test base gcd primitive.
127     */
128    public void testBaseGcdPrimitive() {
129        String[] uvars = new String[] { "x" };
130        dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), 1, to, uvars);
131
132        for (int i = 0; i < 5; i++) {
133            a = dfac.random(kl * (i + 2), ll + 2 * i, el + 2, q);
134            b = dfac.random(kl * (i + 2), ll + 2 * i, el + 2, q);
135            c = dfac.random(kl * (i + 2), ll + 2, el + 2, q);
136            c = c.multiply(dfac.univariate(0));
137            if (c.isZERO()) {
138                // skip for this turn
139                continue;
140            }
141            //a = fd.basePrimitivePart(a);
142            //b = fd.basePrimitivePart(b);
143            c = (GenSolvablePolynomial<BigRational>) fd.leftBasePrimitivePart(c).abs();
144
145            //System.out.println("a  = " + a);
146            //System.out.println("b  = " + b);
147            //System.out.println("c  = " + c);
148            //assertTrue("length( c" + i + " ) <> 0", c.length() > 0);
149
150            a = a.multiply(c);
151            b = b.multiply(c);
152
153            d = fd.leftBaseGcd(a, b);
154            e = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> basePseudoRemainder(d, c);
155            //System.out.println("d  = " + d);
156            //System.out.println("c  = " + c);
157            assertTrue("c | gcd(ac,bc): " + e, e.isZERO());
158
159            e = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> basePseudoRemainder(a, d);
160            //System.out.println("e = " + e);
161            assertTrue("gcd(a,b) | a: " + e, e.isZERO());
162
163            e = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> basePseudoRemainder(b, d);
164            //System.out.println("e = " + e);
165            assertTrue("gcd(a,b) | b " + e, e.isZERO());
166        }
167    }
168
169
170    /**
171     * Test univariate recursive left gcd primitive.
172     */
173    @SuppressWarnings("cast")
174    public void testRecursiveLeftGCDPrimitive() {
175        //String[] vars = new String[] { "a", "b", "c", "d" };
176        String[] vars = new String[] { "a", "b" };
177        dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, vars);
178        RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>();
179        dfac.addRelations(wl);
180        //System.out.println("dfac = " + dfac.toScript());
181        rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(1);
182        //System.out.println("rfac = " + rfac.toScript());
183
184        RecSolvablePolynomialRing<BigRational> rrfacTemp = rfac;
185        GenSolvablePolynomialRing<GenPolynomial<BigRational>> rrfac = rfac;
186
187        GenSolvablePolynomialRing<BigRational> rcfac = (GenSolvablePolynomialRing<BigRational>) rfac.coFac;
188        SolvableQuotientRing<BigRational> qfac = new SolvableQuotientRing<BigRational>(rcfac);
189        QuotSolvablePolynomialRing<BigRational> rqfac = new QuotSolvablePolynomialRing<BigRational>(qfac,
190                        rrfac);
191        List<GenSolvablePolynomial<GenPolynomial<BigRational>>> rl = rrfacTemp.coeffTable.relationList();
192        List<GenPolynomial<GenPolynomial<BigRational>>> rlc = PolynomialList
193                        .<GenPolynomial<BigRational>> castToList(rl);
194        rqfac.polCoeff.coeffTable.addRelations(rlc);
195        //System.out.println("rrfac  = " + rrfac.toScript());
196        //System.out.println("rcfac  = " + rcfac.toScript());
197        //System.out.println("qfac   = " + qfac.toScript());
198        //System.out.println("rqfac  = " + rqfac.toScript());
199
200        //kl = 3; ll = 4; //
201        el = 2;
202
203        ar = rfac.random(kl, ll, el + 1, q);
204        br = rfac.random(kl, ll, el, q);
205        cr = rfac.random(kl, ll, el, q);
206        //cr = (RecSolvablePolynomial<BigRational>) cr.abs();
207        cr = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> monic(cr);
208        //cr = (RecSolvablePolynomial<BigRational>) fd.recursivePrimitivePart(cr).abs();
209        //cr = rfac.getONE();
210        //cr = rfac.parse("a+b+c+d");
211
212        //ar = rfac.parse("1/3 b^3 - 1/6");
213        //ar = rfac.parse("1/3 b^2 - 1/6");
214        //br = rfac.parse("( -1/2 ) b + 3 a");
215        //nok: cr = rfac.parse("b * a - 5 b");
216        //cr = rfac.parse("a - 5");
217
218        //System.out.println("ar = " + ar);
219        //System.out.println("br = " + br);
220        //System.out.println("cr = " + cr);
221
222        if (br.isZERO() || cr.isZERO()) {
223            br = rfac.parse("( -1/2 ) b + 3 a");
224            cr = rfac.parse("a * b - 5 b");
225        }
226
227        //ar = cr.multiply(ar); 
228        //br = cr.multiply(br);
229        ar = ar.multiply(cr);
230        br = br.multiply(cr);
231        //System.out.println("ar = " + ar);
232        //System.out.println("br = " + br);
233        //if (true) return;
234
235        long ts = System.currentTimeMillis();
236        //sr = rfac.getONE(); 
237        sr = fds.leftRecursiveUnivariateGcd(ar, br);
238        ts = System.currentTimeMillis() - ts;
239        //System.out.println("cr = " + cr);
240
241        long tp = System.currentTimeMillis();
242        dr = fd.leftRecursiveUnivariateGcd(ar, br);
243        tp = System.currentTimeMillis() - tp;
244        //System.out.println("cr = " + cr);
245        //System.out.println("dr = " + dr);
246        //System.out.println("sr = " + sr);
247        //System.out.println("time: ts = " + ts + ", tp = " + tp);
248        assertTrue("time: ts = " + ts + ", tp = " + tp, ts + tp > 0);
249
250        er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(dr, cr);
251        //System.out.println("er = " + er);
252        assertTrue("c | gcd(ac,bc): " + er, er.isZERO());
253
254        er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(ar, dr);
255        //System.out.println("er = " + er);
256        assertTrue("gcd(ac,bc) | ac: " + er, er.isZERO());
257
258        er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(br, dr);
259        //System.out.println("er = " + er);
260        assertTrue("gcd(ac,bc) | bc: " + er, er.isZERO());
261
262        GenSolvablePolynomial<SolvableQuotient<BigRational>> ap, bp, dp, gp, ep; // cp, apm, bpm, cpm, dpm, gpm;
263        ap = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, ar);
264        bp = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, br);
265        //cp = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, cr);
266        dp = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, dr);
267        //apm = ap.monic();
268        //bpm = bp.monic();
269        //cpm = cp.monic();
270        //dpm = dp.monic();
271        //System.out.println("ap  = " + ap);
272        //System.out.println("apm = " + apm);
273        //System.out.println("bp  = " + bp);
274        //System.out.println("bpm = " + bpm);
275        //System.out.println("cp  = " + cp);
276        //System.out.println("cpm = " + cpm);
277        //System.out.println("dp  = " + dp);
278        //System.out.println("dpm = " + dpm);
279
280        GreatestCommonDivisorAbstract<SolvableQuotient<BigRational>> fdq = new GreatestCommonDivisorPrimitive<SolvableQuotient<BigRational>>(
281                        qfac);
282        gp = fdq.leftBaseGcd(ap, bp);
283        //gpm = gp.monic();
284        //System.out.println("gp  = " + gp);
285        //System.out.println("gpm = " + gpm);
286
287        ep = FDUtil.<SolvableQuotient<BigRational>> leftBaseSparsePseudoRemainder(gp, dp);
288        //System.out.println("ep  = " + ep);
289        assertTrue("c | gcd(ac,bc): " + ep, ep.isZERO());
290
291        ep = FDUtil.<SolvableQuotient<BigRational>> leftBaseSparsePseudoRemainder(ap, gp);
292        //System.out.println("ep  = " + ep);
293        assertTrue("gcd(ac,bc)| ac): " + ep, ep.isZERO());
294
295        ep = FDUtil.<SolvableQuotient<BigRational>> leftBaseSparsePseudoRemainder(bp, gp);
296        //System.out.println("ep  = " + ep);
297        assertTrue("gcd(ac,bc)| bc): " + ep, ep.isZERO());
298    }
299
300
301    /**
302     * Test univariate recursive right gcd primitive.
303     */
304    @SuppressWarnings("cast")
305    public void testRecursiveRightGCDPrimitive() {
306        //String[] vars = new String[] { "a", "b", "c", "d" };
307        String[] vars = new String[] { "a", "b" };
308        dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, vars);
309        RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>();
310        dfac.addRelations(wl);
311        //System.out.println("dfac = " + dfac.toScript());
312        rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(1);
313        //System.out.println("rfac = " + rfac.toScript());
314
315        RecSolvablePolynomialRing<BigRational> rrfacTemp = rfac;
316        GenSolvablePolynomialRing<GenPolynomial<BigRational>> rrfac = rfac;
317
318        GenSolvablePolynomialRing<BigRational> rcfac = (GenSolvablePolynomialRing<BigRational>) rfac.coFac;
319        SolvableQuotientRing<BigRational> qfac = new SolvableQuotientRing<BigRational>(rcfac);
320        QuotSolvablePolynomialRing<BigRational> rqfac = new QuotSolvablePolynomialRing<BigRational>(qfac,
321                        rrfac);
322        List<GenSolvablePolynomial<GenPolynomial<BigRational>>> rl = rrfacTemp.coeffTable.relationList();
323        List<GenPolynomial<GenPolynomial<BigRational>>> rlc = PolynomialList
324                        .<GenPolynomial<BigRational>> castToList(rl);
325        rqfac.polCoeff.coeffTable.addRelations(rlc);
326        //System.out.println("rrfac  = " + rrfac.toScript());
327        //System.out.println("rcfac  = " + rcfac.toScript());
328        //System.out.println("qfac   = " + qfac.toScript());
329        //System.out.println("rqfac  = " + rqfac.toScript());
330
331        //kl = 3; ll = 4; //
332        el = 3;
333
334        ar = rfac.random(kl, ll, el + 1, q);
335        br = rfac.random(kl, ll, el, q);
336        cr = rfac.random(kl, ll, el, q);
337        //cr = (RecSolvablePolynomial<BigRational>) cr.abs();
338        cr = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> monic(cr);
339        //cr = (RecSolvablePolynomial<BigRational>) fd.recursivePrimitivePart(cr).abs();
340        //cr = rfac.getONE();
341        //cr = rfac.parse("a+b+c+d");
342
343        //ar = rfac.parse("1/3 b^3 - 1/6");
344        //ar = rfac.parse("1/3 b^2 - 1/6");
345        //br = rfac.parse("( -1/2 ) b + 3 a");
346        //nok: cr = rfac.parse("b * a - 5 b");
347        //cr = rfac.parse("a - 5");
348
349        //ar = rfac.parse("359/95 a b^2 + 275/124 a");
350        //br = rfac.parse("814/189 b + 135/44 a");
351        //cr = rfac.parse("b - 612/25");
352
353        //System.out.println("ar = " + ar);
354        //System.out.println("br = " + br);
355        //System.out.println("cr = " + cr);
356
357        if (br.isZERO() || cr.isZERO()) {
358            br = rfac.parse("( -1/2 ) b + 3 a");
359            cr = rfac.parse("a * b - 5 b");
360        }
361
362        ar = cr.multiply(ar);
363        br = cr.multiply(br);
364        //System.out.println("ar = " + ar);
365        //System.out.println("br = " + br);
366
367        long ts = System.currentTimeMillis();
368        //sr = rfac.getONE(); 
369        sr = fds.rightRecursiveUnivariateGcd(ar, br);
370        ts = System.currentTimeMillis() - ts;
371        //System.out.println("cr = " + cr);
372
373        long tp = System.currentTimeMillis();
374        dr = fd.rightRecursiveUnivariateGcd(ar, br);
375        tp = System.currentTimeMillis() - tp;
376        //System.out.println("cr = " + cr);
377        //System.out.println("dr = " + dr);
378        //System.out.println("sr = " + sr);
379        //System.out.println("time: ts = " + ts + ", tp = " + tp);
380        assertTrue("time: ts = " + ts + ", tp = " + tp, ts + tp > 0);
381
382        er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(dr,
383                        cr);
384        //System.out.println("er = " + er);
385        assertTrue("c | gcd(ca,cb): " + er, er.isZERO());
386
387        er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(ar,
388                        dr);
389        //System.out.println("er = " + er);
390        assertTrue("gcd(ca,cb) | ca: " + er, er.isZERO());
391
392        er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(br,
393                        dr);
394        //System.out.println("er = " + er);
395        assertTrue("gcd(ca,cb) | cb: " + er, er.isZERO());
396    }
397
398
399    /**
400     * Test arbitrary recursive gcd primitive.
401     */
402    @SuppressWarnings("cast")
403    public void testArbitraryRecursiveGCDPrimitive() {
404        String[] cvars = new String[] { "a", "b" };
405        String[] vars = new String[] { "c" };
406        dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, cvars);
407        RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>();
408        dfac.addRelations(wl);
409        //System.out.println("dfac = " + dfac.toScript());
410        rfac = new RecSolvablePolynomialRing<BigRational>(dfac, to, vars);
411        //rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(1);
412        //System.out.println("rfac = " + rfac.toScript());
413
414        //kl = 3; ll = 2;
415        el = 2;
416
417        ar0 = rfac.random(kl, ll, el + 1, q);
418        br0 = rfac.random(kl, ll, el, q);
419        cr = rfac.random(kl, ll, el, q);
420
421        //ar0 = rfac.parse("a + b c^2 ");
422        //br0 = rfac.parse("( a^2 - 1/3  ) c - 1/4");
423        //cr = rfac.parse("(b - 1/2 a^2) c");
424
425        //cr = (RecSolvablePolynomial<BigRational>) fd.recursivePrimitivePart(cr).abs();
426        cr = (RecSolvablePolynomial<BigRational>) cr.monic();
427        if (cr.isZERO()) {
428            cr = rfac.getONE();
429        }
430
431        //System.out.println("ar = " + ar);
432        //System.out.println("br = " + br);
433        //System.out.println("cr = " + cr);
434
435        // left gcd
436        ar = ar0.multiply(cr);
437        br = br0.multiply(cr);
438        //System.out.println("ar = " + ar);
439        //System.out.println("br = " + br);
440
441        dr = fd.leftRecursiveGcd(ar, br);
442        //System.out.println("cr = " + cr);
443        //System.out.println("dr = " + dr);
444
445        er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(dr, cr);
446        //System.out.println("er = " + er);
447        assertTrue("c | gcd(ac,bc): " + er, er.isZERO());
448
449        er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(ar, dr);
450        //System.out.println("er = " + er);
451        assertTrue("gcd(a,b) | a: " + er, er.isZERO());
452
453        er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveSparsePseudoRemainder(br, dr);
454        //System.out.println("er = " + er);
455        assertTrue("gcd(a,b) | b: " + er, er.isZERO());
456
457        // right gcd
458        ar = cr.multiply(ar0);
459        br = cr.multiply(br0);
460        //System.out.println("ar = " + ar);
461        //System.out.println("br = " + br);
462
463        dr = fd.rightRecursiveGcd(ar, br);
464        //System.out.println("cr = " + cr);
465        //System.out.println("dr = " + dr);
466
467        er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(dr,
468                        cr);
469        //System.out.println("er = " + er);
470        assertTrue("c | gcd(ca,cb) " + er, er.isZERO());
471
472        er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(ar,
473                        dr);
474        //System.out.println("er = " + er);
475        assertTrue("gcd(ca,cb) | ca " + er, er.isZERO());
476
477        er = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(br,
478                        dr);
479        //System.out.println("er = " + er);
480        assertTrue("gcd(ca,cb) | cb " + er, er.isZERO());
481    }
482
483
484    /**
485     * Test full gcd primitive.
486     */
487    public void testGCDPrimitive() {
488        String[] vars = new String[] { "a", "b", "c", "d" };
489        //String[] vars = new String[] { "a", "b" };
490        dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, vars);
491        RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>();
492        dfac.addRelations(wl);
493        //System.out.println("dfac = " + dfac.toScript());
494
495        //kl = 3; 
496        ll = 4;
497        el = 4;
498
499        //a = dfac.random(kl, ll, el, q);
500        //b = dfac.random(kl, ll, el, q);
501        //c = dfac.random(kl, ll, el, q);
502        //c = c.multiply(dfac.univariate(0));
503
504        a = dfac.parse("1/3 b^3 - 1/6 + d");
505        b = dfac.parse("( -1/2 ) b + 3 a^2 + d");
506        ////b = dfac.parse("( -1/2 ) b + 3 a^2 + c");
507        ////c = dfac.parse("(a - 5 b) + c + d");
508        ////ok: c = dfac.parse("(a - b) c");
509        ////c = dfac.parse("c (a - b)");
510        //c = dfac.parse("(a - b) + c + d ");
511        c = dfac.parse("(a - b) + c");
512        //c = dfac.parse("(a - b) + b^3");
513        //c = dfac.parse("(a - b) + d");
514
515        //a = dfac.parse("2 b^3 * d^2 + 2/3 a + 3/2");
516        //b = dfac.parse("2/3 d + 1/2 a^3 + 3/4");
517        //c = dfac.parse("c^2 * d - 1/2 a^3 * d + 5/4 d");
518
519        //c = (GenSolvablePolynomial<BigRational>) fd.primitivePart(c).abs();
520        c = c.monic();
521        if (c.isZERO()) {
522            c = dfac.getONE();
523        }
524        //System.out.println("a = " + a);
525        //System.out.println("b = " + b);
526        //System.out.println("c = " + c);
527
528        // left
529        a0 = a;
530        b0 = b;
531        a = a0.multiply(c);
532        b = b0.multiply(c);
533        //System.out.println("a = " + a);
534        //System.out.println("b = " + b);
535        //System.out.println("c = " + c);
536
537        d = fd.leftGcd(a, b);
538        //System.out.println("c = " + c);
539        //System.out.println("d = " + d);
540
541        e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(d, c);
542        //System.out.println("e = " + e);
543        assertTrue("c | gcd(ac,bc) " + e, e.isZERO());
544
545        e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(a, c);
546        //System.out.println("e = " + e);
547        assertTrue("c | ac " + e, e.isZERO());
548        e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(a, d);
549        //System.out.println("e = " + e);
550        assertTrue("gcd(a,b) | a " + e, e.isZERO());
551
552        e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(b, c);
553        //System.out.println("e = " + e);
554        assertTrue("c | bc " + e, e.isZERO());
555        e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(b, d);
556        //System.out.println("e = " + e);
557        assertTrue("gcd(a,b) | b " + e, e.isZERO());
558
559
560        // right
561        a = c.multiply(a0);
562        b = c.multiply(b0);
563        //System.out.println("a = " + a);
564        //System.out.println("b = " + b);
565        //System.out.println("c = " + c);
566
567        d = fd.rightGcd(a, b);
568        //System.out.println("c  = " + c);
569        //System.out.println("d  = " + d);
570
571        e = FDUtil.<BigRational> rightBaseSparsePseudoRemainder(d, c);
572        //System.out.println("e = " + e);
573        assertTrue("c | gcd(ac,bc): " + e, e.isZERO());
574
575        e = FDUtil.<BigRational> rightBaseSparsePseudoRemainder(a, c);
576        //System.out.println("e = " + e);
577        assertTrue("c | ac: " + e, e.isZERO());
578        e = FDUtil.<BigRational> rightBaseSparsePseudoRemainder(b, c);
579        //System.out.println("e = " + e);
580        assertTrue("c | bc: " + e, e.isZERO());
581
582        e = FDUtil.<BigRational> rightBaseSparsePseudoRemainder(a, d);
583        //System.out.println("e = " + e);
584        //e = FDUtil.<BigRational> divideRightPolynomial(a,d);
585        //System.out.println("e = " + e);
586        assertTrue("gcd(a,b) | a: " + e, e.isZERO());
587
588        e = FDUtil.<BigRational> rightBaseSparsePseudoRemainder(b, d);
589        //System.out.println("e = " + e);
590        //e = FDUtil.<BigRational> divideRightPolynomial(b,d);
591        //System.out.println("e = " + e);
592        assertTrue("gcd(a,b) | b: " + e, e.isZERO());
593    }
594
595}