Source code

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