Source code

001/*
002 * $Id: GCDLeftRightTest.java 5863 2018-07-20 11:13:34Z kredel $
003 */
004
005package edu.jas.fd;
006
007
008
009import edu.jas.arith.BigQuaternion;
010import edu.jas.arith.BigQuaternionRing;
011import edu.jas.gbufd.SolvableSyzygyAbstract;
012import edu.jas.gbufd.SolvableSyzygySeq;
013import edu.jas.kern.ComputerThreads;
014import edu.jas.poly.GenPolynomial;
015import edu.jas.poly.GenSolvablePolynomial;
016import edu.jas.poly.GenSolvablePolynomialRing;
017import edu.jas.poly.RecSolvablePolynomialRing;
018import edu.jas.poly.RelationGenerator;
019import edu.jas.poly.TermOrder;
020import edu.jas.poly.TermOrderByName;
021import edu.jas.poly.WeylRelationsIterated;
022import edu.jas.structure.GcdRingElem;
023
024import junit.framework.Test;
025import junit.framework.TestCase;
026import junit.framework.TestSuite;
027
028
029/**
030 * GCD LeftRight PRS algorithm tests with JUnit. <b>Note:</b> not in sync with
031 * implementation.
032 * @author Heinz Kredel
033 */
034
035public class GCDLeftRightTest extends TestCase {
036
037
038    /**
039     * main.
040     */
041    public static void main(String[] args) {
042        junit.textui.TestRunner.run(suite());
043        ComputerThreads.terminate();
044    }
045
046
047    /**
048     * Constructs a <CODE>GCDLeftRightTest</CODE> object.
049     * @param name String.
050     */
051    public GCDLeftRightTest(String name) {
052        super(name);
053    }
054
055
056    /**
057     */
058    public static Test suite() {
059        TestSuite suite = new TestSuite(GCDLeftRightTest.class);
060        return suite;
061    }
062
063
064    //GreatestCommonDivisorAbstract<BigQuaternion> fd;
065    GreatestCommonDivisorLR<BigQuaternion> fd;
066
067
068    TermOrder to = TermOrderByName.INVLEX;
069
070
071    BigQuaternionRing cfac;
072
073
074    GenSolvablePolynomialRing<BigQuaternion> dfac;
075
076
077    //GenSolvablePolynomialRing<GenPolynomial<BigQuaternion>> rfac;
078    RecSolvablePolynomialRing<BigQuaternion> rfac;
079
080
081    GenSolvablePolynomial<BigQuaternion> a, b, c, d, e, f, g, h, r, s;
082
083
084    GenSolvablePolynomial<GenPolynomial<BigQuaternion>> ar, br, cr, dr, er;
085
086
087    SolvableSyzygyAbstract<BigQuaternion> syz;
088
089
090    int rl = 4;
091
092
093    int kl = 2;
094
095
096    int ll = 4;
097
098
099    int el = 3;
100
101
102    float q = 0.35f;
103
104
105    @Override
106    protected void setUp() {
107        a = b = c = d = e = null;
108        ar = br = cr = dr = er = null;
109        String[] vars = new String[] { "a", "b", "c", "d" };
110        cfac = new BigQuaternionRing();
111        syz = new SolvableSyzygySeq<BigQuaternion>(cfac);
112        //System.out.println("syz = " + syz);
113        fd = new GreatestCommonDivisorLR<BigQuaternion>(cfac, syz);
114        //fd = new GreatestCommonDivisorFake<BigQuaternion>(cfac);
115        dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfac, rl, to, vars);
116        RelationGenerator<BigQuaternion> wl = new WeylRelationsIterated<BigQuaternion>();
117        dfac.addRelations(wl);
118        rfac = (RecSolvablePolynomialRing<BigQuaternion>) dfac.recursive(1);
119        //System.out.println("dfac = " + dfac);
120    }
121
122
123    @Override
124    protected void tearDown() {
125        a = b = c = d = e = null;
126        ar = br = cr = dr = er = null;
127        fd = null;
128        cfac = null;
129        dfac = null;
130        rfac = null;
131        syz = null;
132    }
133
134
135    /**
136     * Test base field gcd left - right.
137     */
138    public void testBaseGcdLeftRight() {
139        String[] uvars = new String[] { "x" };
140        dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfac, 1, to, uvars);
141        BigQuaternion cc;
142        for (int i = 0; i < 1; i++) {
143            a = dfac.random(kl * (i + 2), ll + i, el + 1, q);
144            b = dfac.random(kl * (i + 1), ll + i, el + 1, q);
145            c = dfac.random(kl * (i + 1), ll + 1, el + 0, q);
146            //c = dfac.getONE(); 
147            c = c.multiply(dfac.univariate(0));
148            cc = cfac.random(kl);
149            //c = c.multiplyLeft(cc);
150            if (c.isZERO() || cc.isZERO()) {
151                // skip for this turn
152                continue;
153            }
154            //a = fd.basePrimitivePart(a);
155            //b = fd.basePrimitivePart(b);
156            //c = (GenSolvablePolynomial<BigQuaternion>) fd.basePrimitivePart(c).abs();
157            //System.out.println("a  = " + a);
158            //System.out.println("b  = " + b);
159            //System.out.println("cc = " + cc);
160            //System.out.println("c  = " + c);
161
162            a = a.multiply(c).multiplyLeft(cc);
163            b = b.multiply(c).multiplyLeft(cc);
164            //System.out.println("a  = " + a);
165            //System.out.println("b  = " + b);
166
167            GCDcoFactors<BigQuaternion> cont = fd.leftRightBaseGcd(a, b);
168            //d = (GenSolvablePolynomial<BigQuaternion>) cont.left;
169            //System.out.println("cont = " + cont);
170            //System.out.println("cont.isGCD() = " + cont.isGCD());
171            assertTrue("cont.isGCD() ", cont.isGCD());
172        }
173    }
174
175
176    /**
177     * Test base field gcd right - left.
178     */
179    public void testBaseGcdRightLeft() {
180        String[] uvars = new String[] { "x" };
181        dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfac, 1, to, uvars);
182        BigQuaternion cc;
183        for (int i = 0; i < 1; i++) {
184            a = dfac.random(kl * (i + 2), ll + i, el + 1, q);
185            b = dfac.random(kl * (i + 1), ll + i, el + 1, q);
186            c = dfac.random(kl * (i + 1), ll + 1, el + 0, q);
187            //c = dfac.getONE(); 
188            c = c.multiply(dfac.univariate(0));
189            cc = cfac.random(kl);
190            //c = c.multiplyLeft(cc);
191            if (c.isZERO() || cc.isZERO()) {
192                // skip for this turn
193                continue;
194            }
195            //a = fd.basePrimitivePart(a);
196            //b = fd.basePrimitivePart(b);
197            //c = (GenSolvablePolynomial<BigQuaternion>) fd.basePrimitivePart(c).abs();
198            //System.out.println("a  = " + a);
199            //System.out.println("b  = " + b);
200            //System.out.println("cc = " + cc);
201            //System.out.println("c  = " + c);
202
203            a = c.multiply(cc).multiply(a);
204            b = c.multiply(cc).multiply(b);
205            //System.out.println("a  = " + a);
206            //System.out.println("b  = " + b);
207
208            GCDcoFactors<BigQuaternion> cont = fd.rightLeftBaseGcd(a, b);
209            //d = (GenSolvablePolynomial<BigQuaternion>) cont.left;
210            //System.out.println("cont = " + cont);
211            //System.out.println("cont.isGCD() = " + cont.isGCD());
212            assertTrue("cont.isGCD() ", cont.isGCD());
213        }
214    }
215
216
217    /**
218     * Test base field left gcd.
219     */
220    public void testBaseLeftGcd() {
221        String[] uvars = new String[] { "x" };
222        dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfac, 1, to, uvars);
223        BigQuaternion cc;
224        for (int i = 0; i < 1; i++) {
225            a = dfac.random(kl * (i + 2), ll + i, el + 1, q);
226            b = dfac.random(kl * (i + 1), ll + i, el + 1, q);
227            c = dfac.random(kl * (i + 1), ll + 1, el + 0, q);
228            //c = dfac.getONE(); 
229            c = c.multiply(dfac.univariate(0));
230            cc = cfac.random(kl);
231            c = c.multiplyLeft(cc);
232            if (c.isZERO() || cc.isZERO()) {
233                // skip for this turn
234                continue;
235            }
236            //a = fd.basePrimitivePart(a);
237            //b = fd.basePrimitivePart(b);
238            //c = (GenSolvablePolynomial<BigQuaternion>) fd.basePrimitivePart(c).abs();
239            //System.out.println("a  = " + a);
240            //System.out.println("b  = " + b);
241            ////System.out.println("cc = " + cc);
242            //System.out.println("c  = " + c);
243
244            a = c.multiply(a);
245            b = c.multiply(b);
246            //System.out.println("a  = " + a);
247            //System.out.println("b  = " + b);
248
249            d = fd.leftBaseGcd(a, b);
250            //System.out.println("c = " + c);
251            //System.out.println("d = " + d);
252            //assertTrue("cont.isGCD() ", cont.isGCD());
253
254            e = FDUtil.<BigQuaternion> rightBaseSparsePseudoRemainder(a, d);
255            //System.out.println("e = " + e);
256            assertTrue("e == 0 ", e.isZERO());
257            f = FDUtil.<BigQuaternion> rightBaseSparsePseudoRemainder(b, d);
258            //System.out.println("f = " + f);
259            assertTrue("f == 0 ", f.isZERO());
260        }
261    }
262
263
264    /**
265     * Test base field right gcd.
266     */
267    public void testBaseRightGcd() {
268        String[] uvars = new String[] { "x" };
269        dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfac, 1, to, uvars);
270        BigQuaternion cc;
271        for (int i = 0; i < 1; i++) {
272            a = dfac.random(kl * (i + 2), ll + i, el + 1, q);
273            b = dfac.random(kl * (i + 1), ll + i, el + 1, q);
274            c = dfac.random(kl * (i + 1), ll + 1, el + 0, q);
275            //c = dfac.getONE(); 
276            c = c.multiply(dfac.univariate(0));
277            cc = cfac.random(kl);
278            c = c.multiply(cc);
279            if (c.isZERO() || cc.isZERO()) {
280                // skip for this turn
281                continue;
282            }
283            //a = fd.basePrimitivePart(a);
284            //b = fd.basePrimitivePart(b);
285            //c = (GenSolvablePolynomial<BigQuaternion>) fd.basePrimitivePart(c).abs();
286            //System.out.println("a  = " + a);
287            //System.out.println("b  = " + b);
288            ////System.out.println("cc = " + cc);
289            //System.out.println("c  = " + c);
290
291            a = a.multiply(c);
292            b = b.multiply(c);
293            //System.out.println("a  = " + a);
294            //System.out.println("b  = " + b);
295
296            d = fd.rightBaseGcd(a, b);
297            //System.out.println("c = " + c);
298            //System.out.println("d = " + d);
299            //assertTrue("cont.isGCD() ", cont.isGCD());
300
301            e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(a, d);
302            //System.out.println("e = " + e);
303            assertTrue("e == 0 ", e.isZERO());
304            f = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(b, d);
305            //System.out.println("f = " + f);
306            assertTrue("f == 0 ", f.isZERO());
307        }
308    }
309
310
311    /**
312     * Test base integer gcd left - right.
313     */
314    public void testBaseIntegerGcdLeftRight() {
315        String[] uvars = new String[] { "x" };
316        cfac = new BigQuaternionRing(true);
317        syz = new SolvableSyzygySeq<BigQuaternion>(cfac);
318        //System.out.println("syz = " + syz);
319        dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfac, 1, to, uvars);
320        fd = new GreatestCommonDivisorLR<BigQuaternion>(cfac, syz);
321        BigQuaternion cc;
322        for (int i = 0; i < 1; i++) {
323            a = dfac.random(kl * (i + 2), ll + 1, el + 2, q);
324            b = dfac.random(kl * (i + 1), ll + 1, el + 2, q);
325            c = dfac.random(kl * (i + 1), ll + 1, el + 1, q);
326            //c = dfac.getONE(); 
327            c = c.multiply(dfac.univariate(0));
328            c = (GenSolvablePolynomial<BigQuaternion>) c.abs();
329            cc = cfac.random(kl);
330            //cc = cfac.getONE(); 
331            //c = c.multiplyLeft(cc);
332            if (c.isZERO() || cc.isZERO()) {
333                // skip for this turn
334                continue;
335            }
336            //a = fd.basePrimitivePart(a);
337            //b = fd.basePrimitivePart(b);
338            //c = (GenSolvablePolynomial<BigQuaternion>) fd.basePrimitivePart(c).abs();
339            // replace - by ~ in coefficents for polynomial tokenizer
340            //a = dfac.parse("( 3/2i1/2j1/2k~1/2 ) x^3 - ( 1i~1j0k~2 ) x + ( 11/2i15/2j1/2k~1/2 )");
341            //b = dfac.parse("( ~1i2j3k1 ) x^4 + ( 0i1j~2k0 ) x^2 + ( 1/2i~3/2j1/2k3/2 )");
342            //c = dfac.parse("( 1/2i1/2j~1/2k1/2 ) x^4 + ( 1i~1j0k0 ) x^3 + 1i1j0k1 x");
343
344            //System.out.println("a  = " + a);
345            //System.out.println("b  = " + b);
346            //System.out.println("cc = " + cc);
347            //System.out.println("c  = " + c);
348
349            a = a.multiply(c).multiplyLeft(cc);
350            b = b.multiply(c).multiplyLeft(cc);
351            //System.out.println("a  = " + a);
352            //System.out.println("b  = " + b);
353
354            GCDcoFactors<BigQuaternion> cont = fd.leftRightBaseGcd(a, b);
355            //d = (GenSolvablePolynomial<BigQuaternion>) cont.left;
356            //System.out.println("cont = " + cont);
357            //System.out.println("cont.isGCD() = " + cont.isGCD());
358            //System.out.println("r = " + cont.right + ", l=" + cont.left);
359            //System.out.println("c = " + c + ", cc = " + cc); 
360            assertTrue("cont.isGCD() ", cont.isGCD());
361        }
362    }
363
364
365    /**
366     * Test base integer gcd right - left.
367     */
368    public void testBaseIntegerGcdRightLeft() {
369        String[] uvars = new String[] { "x" };
370        cfac = new BigQuaternionRing(true);
371        syz = new SolvableSyzygySeq<BigQuaternion>(cfac);
372        //System.out.println("syz = " + syz);
373        dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfac, 1, to, uvars);
374        fd = new GreatestCommonDivisorLR<BigQuaternion>(cfac, syz);
375        BigQuaternion cc;
376        for (int i = 0; i < 1; i++) {
377            a = dfac.random(kl * (i + 2), ll + 1, el + 2, q);
378            b = dfac.random(kl * (i + 1), ll + 1, el + 2, q);
379            c = dfac.random(kl * (i + 1), ll + 1, el + 1, q);
380            //c = dfac.getONE(); 
381            c = c.multiply(dfac.univariate(0));
382            c = (GenSolvablePolynomial<BigQuaternion>) c.abs();
383            cc = cfac.random(kl);
384            //cc = cfac.getONE(); 
385            //c = c.multiplyLeft(cc);
386            if (c.isZERO() || cc.isZERO()) {
387                // skip for this turn
388                continue;
389            }
390            //System.out.println("a  = " + a);
391            //System.out.println("b  = " + b);
392            //System.out.println("cc = " + cc);
393            //System.out.println("c  = " + c);
394
395            a = a.multiply(c).multiplyLeft(cc);
396            b = b.multiply(c).multiplyLeft(cc);
397            //System.out.println("a  = " + a);
398            //System.out.println("b  = " + b);
399
400            GCDcoFactors<BigQuaternion> cont = fd.rightLeftBaseGcd(a, b);
401            //d = (GenSolvablePolynomial<BigQuaternion>) cont.left;
402            //System.out.println("cont = " + cont);
403            //System.out.println("cont.isGCD() = " + cont.isGCD());
404            //System.out.println("r = " + cont.right + ", l=" + cont.left);
405            //System.out.println("c = " + c + ", cc = " + cc); 
406            assertTrue("cont.isGCD() ", cont.isGCD());
407        }
408    }
409
410
411    /**
412     * Test base integral left gcd.
413     */
414    public void testBaseIntegralLeftGcd() {
415        String[] uvars = new String[] { "x" };
416        cfac = new BigQuaternionRing(true);
417        syz = new SolvableSyzygySeq<BigQuaternion>(cfac);
418        //System.out.println("syz = " + syz);
419        dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfac, 1, to, uvars);
420        fd = new GreatestCommonDivisorLR<BigQuaternion>(cfac, syz);
421        BigQuaternion cc;
422        for (int i = 0; i < 1; i++) {
423            a = dfac.random(kl * (i + 2), ll + i, el + 1, q);
424            b = dfac.random(kl * (i + 1), ll + i, el + 1, q);
425            c = dfac.random(kl * (i + 1), ll + 1, el + 0, q);
426            //c = dfac.getONE(); 
427            c = c.multiply(dfac.univariate(0));
428            cc = cfac.random(kl);
429            c = c.multiplyLeft(cc);
430            if (c.isZERO() || cc.isZERO()) {
431                // skip for this turn
432                continue;
433            }
434            // replace - by ~ in coefficents for polynomial tokenizer
435            //a = dfac.parse("( 1i0j~1k0 ) x^2 - ( 9/2i5/2j~1/2k~1/2 ) x + 5/2i5/2j9/2k3/2");
436            //b = dfac.parse("1i1j1k1 x^3 + ( 1i~1j1k1 )");
437            ////c = dfac.parse("( ~3i11j~3k~1 ) x^2 - ( 5i~10j~5k0 ) x");
438            //c = dfac.parse("( ~3i11j~3k~1 ) x - ( 5i~10j~5k0 ) ");
439
440            //System.out.println("a  = " + a);
441            //System.out.println("b  = " + b);
442            ////System.out.println("cc = " + cc);
443            //System.out.println("c  = " + c);
444
445            a = c.multiply(a);
446            b = c.multiply(b);
447            //System.out.println("a  = " + a);
448            //System.out.println("b  = " + b);
449
450            d = fd.leftBaseGcd(a, b);
451            //System.out.println("c = " + c);
452            //System.out.println("d = " + d);
453
454            e = FDUtil.<BigQuaternion> rightBaseSparsePseudoRemainder(a, d);
455            //System.out.println("e = " + e);
456            assertTrue("e == 0 ", e.isZERO());
457            f = FDUtil.<BigQuaternion> rightBaseSparsePseudoRemainder(b, d);
458            //System.out.println("f = " + f);
459            assertTrue("f == 0 ", f.isZERO());
460        }
461    }
462
463
464    /**
465     * Test base integral right gcd.
466     */
467    public void testBaseIntegralRightGcd() {
468        String[] uvars = new String[] { "x" };
469        cfac = new BigQuaternionRing(true);
470        syz = new SolvableSyzygySeq<BigQuaternion>(cfac);
471        //System.out.println("syz = " + syz);
472        dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfac, 1, to, uvars);
473        fd = new GreatestCommonDivisorLR<BigQuaternion>(cfac, syz);
474        BigQuaternion cc;
475        for (int i = 0; i < 1; i++) {
476            a = dfac.random(kl * (i + 2), ll + i, el + 1, q);
477            b = dfac.random(kl * (i + 1), ll + i, el + 1, q);
478            c = dfac.random(kl * (i + 1), ll + 1, el + 0, q);
479            //c = dfac.getONE(); 
480            c = c.multiply(dfac.univariate(0));
481            cc = cfac.random(kl);
482            c = c.multiply(cc);
483            if (c.isZERO() || cc.isZERO()) {
484                // skip for this turn
485                continue;
486            }
487            // replace - by ~ in coefficents for polynomial tokenizer
488            //a = dfac.parse("( 5/2i~1/2j~3/2k~3/2 ) x^2 - ( 1i0j0k~1 )");
489            //b = dfac.parse("( 1i~1j1k0 ) x^2 - 1i2j0k0 x + ( 1/2i1/2j~1/2k3/2 )");
490            //c = dfac.parse("( 0i~1j~2k~14 ) x");
491
492            //System.out.println("a  = " + a);
493            //System.out.println("b  = " + b);
494            ////System.out.println("cc = " + cc);
495            //System.out.println("c  = " + c);
496
497            a = a.multiply(c);
498            b = a.multiply(c);
499            //System.out.println("a  = " + a);
500            //System.out.println("b  = " + b);
501
502            d = fd.rightBaseGcd(a, b);
503            //System.out.println("c = " + c);
504            //System.out.println("d = " + d);
505            //d = fd.leftBasePrimitivePart(fd.rightBasePrimitivePart(d));
506            //System.out.println("d = " + d);
507
508            e = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(a, d);
509            //System.out.println("e = " + e);
510            assertTrue("e == 0 ", e.isZERO());
511            f = FDUtil.<BigQuaternion> leftBaseSparsePseudoRemainder(b, d);
512            //System.out.println("f = " + f);
513            assertTrue("f == 0 ", f.isZERO());
514        }
515    }
516
517
518    /**
519     * Test base integer quotient remainder.
520     */
521    public void testBaseQR() {
522        String[] uvars = new String[] { "x" };
523        cfac = new BigQuaternionRing(true);
524        syz = new SolvableSyzygySeq<BigQuaternion>(cfac);
525        //System.out.println("syz = " + syz);
526        dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfac, 1, to, uvars);
527        fd = new GreatestCommonDivisorLR<BigQuaternion>(cfac, syz);
528        GreatestCommonDivisorAbstract<BigQuaternion> fds = new GreatestCommonDivisorSimple<BigQuaternion>(
529                        cfac);
530        //BigQuaternion cc;
531        for (int i = 0; i < 1; i++) {
532            a = dfac.random(kl * (i + 2), ll + 1, el + 2, q);
533            b = dfac.random(kl * (i + 1), ll + 1, el + 2, q);
534            c = dfac.random(kl * (i + 1), ll + 1, el + 1, q);
535            //c = dfac.getONE(); 
536            c = c.multiply(dfac.univariate(0));
537            c = (GenSolvablePolynomial<BigQuaternion>) c.abs();
538            if (c.isZERO()) {
539                // skip for this turn
540                continue;
541            }
542            //System.out.println("a  = " + a);
543            //System.out.println("b  = " + b);
544            //System.out.println("c  = " + c);
545
546            a = a.multiply(c);
547            b = b.multiply(c);
548            //System.out.println("a  = " + a);
549            //System.out.println("b  = " + b);
550
551            GenSolvablePolynomial<BigQuaternion>[] aqr, bqr;
552
553            aqr = FDUtil.<BigQuaternion> leftBasePseudoQuotientRemainder(a, c);
554            bqr = FDUtil.<BigQuaternion> leftBasePseudoQuotientRemainder(b, c);
555            d = aqr[0];
556            e = bqr[0];
557
558            //System.out.println("d  = " + d + ", rem = " + aqr[1]);
559            //System.out.println("e  = " + e + ", rem = " + bqr[1]);
560            assertTrue("a rem == 0: ", aqr[1].isZERO());
561            assertTrue("b rem == 0: ", bqr[1].isZERO());
562
563            boolean t;
564            f = d.multiply(c);
565            //System.out.println("f  = " + f);
566            //System.out.println("a  = " + a);
567            t = f.equals(a);
568            //System.out.println("d*c == a: " + t);
569
570            BigQuaternion qa, qb, oa, ob;
571            qa = a.leadingBaseCoefficient();
572            qb = f.leadingBaseCoefficient();
573            GcdRingElem<BigQuaternion>[] oc = fd.leftOreCond(qa, qb);
574            oa = (BigQuaternion) oc[0];
575            ob = (BigQuaternion) oc[1];
576
577            a = a.multiplyLeft(oa);
578            f = f.multiplyLeft(ob);
579            //System.out.println("f  = " + f);
580            //System.out.println("a  = " + a);
581            t = f.equals(a);
582            //System.out.println("d*c == a: " + t);
583            assertTrue("d*c == a: ", t);
584
585
586            g = e.multiply(c);
587            //System.out.println("g  = " + g);
588            //System.out.println("b  = " + b);
589            t = g.equals(b);
590            //System.out.println("e*c == b: " + t);
591            assertTrue("e*c == b: ", t || true);
592
593            r = (GenSolvablePolynomial<BigQuaternion>) fds.leftBasePrimitivePart(b).abs();
594            s = (GenSolvablePolynomial<BigQuaternion>) fds.leftBasePrimitivePart(g).abs();
595            //System.out.println("pp(b)  = " + r);
596            //System.out.println("pp(g)  = " + s);
597            assertEquals("pp(b) == pp(g): ", r, s);
598
599            qa = b.leadingBaseCoefficient();
600            qb = g.leadingBaseCoefficient();
601            oc = fd.leftOreCond(qa, qb);
602            oa = (BigQuaternion) oc[0];
603            ob = (BigQuaternion) oc[1];
604
605            b = b.multiplyLeft(oa);
606            g = g.multiplyLeft(ob);
607            //System.out.println("g  = " + g);
608            //System.out.println("b  = " + b);
609            t = g.equals(b);
610            //System.out.println("e*c == b: " + t);
611            assertTrue("e*c == b: ", t);
612        }
613    }
614
615
616    /**
617     * Test base integral left / right pseudo division.
618     */
619    public void testBaseIntegralDivision() {
620        String[] uvars = new String[] { "x" };
621        cfac = new BigQuaternionRing(true);
622        syz = new SolvableSyzygySeq<BigQuaternion>(cfac);
623        //System.out.println("syz = " + syz);
624        dfac = new GenSolvablePolynomialRing<BigQuaternion>(cfac, 1, to, uvars);
625        fd = new GreatestCommonDivisorLR<BigQuaternion>(cfac, syz);
626        BigQuaternion cc;
627        for (int i = 0; i < 1; i++) {
628            a = dfac.random(kl * (i + 2), ll + i, el + 1, q);
629            b = dfac.random(kl * (i + 1), ll + i, el + 1, q);
630            c = dfac.random(kl * (i + 1), ll + 1, el + 0, q);
631            //c = dfac.getONE(); 
632            c = c.multiply(dfac.univariate(0));
633            cc = cfac.random(kl);
634            c = c.multiplyLeft(cc);
635            if (c.isZERO() || cc.isZERO()) {
636                // skip for this turn
637                continue;
638            }
639            // replace - by ~ in coefficents for polynomial tokenizer
640            //a = dfac.parse("( 1i~3j~3k~3 ) x^3 - ( 9i7j~12k~8 ) x^2 + 20i17j14k10 x + ( 19/2i27/2j~31/2k~7/2 ) ");
641            //b = dfac.parse("( 3i2j~1k0 ) x^4 + ( 2i1j~3k~1 ) x^3 + ( 3i0j2k~1 ) x + ( 5/2i3/2j1/2k~5/2 ) ");
642            //c = dfac.parse("0i0j4k0 x - ( 1/2i~1/2j~5/2k~5/2 ) ");
643
644            //System.out.println("a  = " + a);
645            //System.out.println("b  = " + b);
646            ////System.out.println("cc = " + cc);
647            //System.out.println("c  = " + c);
648
649            //System.out.println("ppl(a) = " + fd.leftPrimitivePart(a));
650            //System.out.println("ppl(b) = " + fd.leftPrimitivePart(b));
651            //System.out.println("ppr(a) = " + fd.rightPrimitivePart(a));
652            //System.out.println("ppr(b) = " + fd.rightPrimitivePart(b));
653            //b = fd.rightPrimitivePart(b);
654
655            s = b;
656            r = a;
657            while (!r.isZERO()) {
658                GenSolvablePolynomial<BigQuaternion>[] qr;
659                GenSolvablePolynomial<BigQuaternion> x, y, z;
660                qr = FDUtil.<BigQuaternion> rightBasePseudoQuotientRemainder(s, r);
661                y = qr[0];
662                x = qr[1];
663                z = (GenSolvablePolynomial<BigQuaternion>) r.multiply(y).sum(x);
664                //System.out.println("z = " + z + ", s = " + s);
665                BigQuaternion lz, ls;
666                lz = z.leadingBaseCoefficient();
667                ls = s.leadingBaseCoefficient();
668                GcdRingElem[] oc = fd.rightOreCond(lz, ls);
669                z = z.multiply((BigQuaternion) oc[0]);
670                s = s.multiply((BigQuaternion) oc[1]);
671                //System.out.println("z * oa = " + z);
672                //System.out.println("s * os = " + s);
673                //System.out.println("z * oz == s * os: " + z.equals(s));
674                assertEquals("z * oz == s * os: ", z, s);
675                s = r;
676                r = x;
677                //System.out.println("r  = " + r);
678            }
679            //System.out.println("s  = " + s);
680            //s = fd.rightPrimitivePart(s);
681            //s = fd.leftPrimitivePart(s);
682            //System.out.println("s  = " + s);
683            //System.out.println("c  = " + c + ", s==c: " + s.equals(c));
684            g = s;
685
686            GenSolvablePolynomial<BigQuaternion>[] qr;
687            qr = FDUtil.<BigQuaternion> rightBasePseudoQuotientRemainder(a, g);
688            d = qr[0];
689            h = (GenSolvablePolynomial<BigQuaternion>) g.multiply(d).sum(qr[1]);
690            //System.out.println("h  = " + h);
691            //System.out.println("a  = " + a);
692
693            BigQuaternion lh, la, lb;
694            lh = h.leadingBaseCoefficient();
695            la = a.leadingBaseCoefficient();
696            GcdRingElem[] oc = fd.rightOreCond(lh, la);
697            h = h.multiply((BigQuaternion) oc[0]);
698            s = a.multiply((BigQuaternion) oc[1]);
699            assertEquals("h * oh == a * oa: ", h, s);
700
701            //assertTrue("r==0: ", qr[1].isZERO());
702
703            qr = FDUtil.<BigQuaternion> rightBasePseudoQuotientRemainder(b, g);
704            e = qr[0];
705            h = (GenSolvablePolynomial<BigQuaternion>) g.multiply(e).sum(qr[1]);
706            //System.out.println("h  = " + h);
707            //System.out.println("b  = " + b);
708
709            lh = h.leadingBaseCoefficient();
710            lb = b.leadingBaseCoefficient();
711            oc = fd.rightOreCond(lh, lb);
712            h = h.multiply((BigQuaternion) oc[0]);
713            s = b.multiply((BigQuaternion) oc[1]);
714            assertEquals("h * oh == a * oa: ", h, s);
715
716
717            //System.out.println("d  = " + d + ", rem = " + qr[1]);
718            //System.out.println("e  = " + e + ", rem = " + qr[1]);
719            f = g.multiply(d);
720            g = g.multiply(e);
721            //System.out.println("f  = " + f + ", a==f? " + a.equals(f));
722            //System.out.println("g  = " + g + ", b==g? " + b.equals(g));
723
724            BigQuaternion lf, lg;
725            la = a.leadingBaseCoefficient();
726            lb = b.leadingBaseCoefficient();
727            lf = f.leadingBaseCoefficient();
728            lg = g.leadingBaseCoefficient();
729
730            oc = fd.rightOreCond(la, lf);
731            r = a.multiply((BigQuaternion) oc[0]);
732            s = f.multiply((BigQuaternion) oc[1]);
733            //System.out.println("a * oa = " + r);
734            //System.out.println("f * of = " + s);
735            //System.out.println("a * oa == f * of: " + r.equals(s));
736            assertEquals("a * oa == f * of: ", r, s);
737
738            oc = fd.rightOreCond(lb, lg);
739            r = b.multiply((BigQuaternion) oc[0]);
740            s = g.multiply((BigQuaternion) oc[1]);
741            //System.out.println("b * ob = " + r);
742            //System.out.println("g * og = " + s);
743            //System.out.println("b * ob == g * og: " + r.equals(s));
744            assertEquals("b * ob == g * og: ", r, s);
745
746        }
747    }
748}