Source code

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