001/*
002 * $Id: GCDModEvalTest.java 5863 2018-07-20 11:13:34Z kredel $
003 */
004
005package edu.jas.ufd;
006
007
008import java.util.ArrayList;
009import java.util.List;
010
011import junit.framework.Test;
012import junit.framework.TestCase;
013import junit.framework.TestSuite;
014
015
016import edu.jas.arith.ModInteger;
017import edu.jas.arith.ModIntegerRing;
018import edu.jas.arith.PrimeList;
019import edu.jas.poly.ExpVector;
020import edu.jas.poly.GenPolynomial;
021import edu.jas.poly.GenPolynomialRing;
022import edu.jas.poly.PolyUtil;
023import edu.jas.poly.TermOrder;
024
025
026/**
027 * GCD Modular Evaluation algorithm tests with JUnit.
028 * @author Heinz Kredel
029 */
030
031public class GCDModEvalTest extends TestCase {
032
033
034    /**
035     * main.
036     */
037    public static void main(String[] args) {
038        junit.textui.TestRunner.run(suite());
039    }
040
041
042    /**
043     * Constructs a <CODE>GCDModEvalTest</CODE> object.
044     * @param name String.
045     */
046    public GCDModEvalTest(String name) {
047        super(name);
048    }
049
050
051    /**
052     */
053    public static Test suite() {
054        TestSuite suite = new TestSuite(GCDModEvalTest.class);
055        return suite;
056    }
057
058
059    GreatestCommonDivisorAbstract<ModInteger> ufd;
060
061
062    TermOrder to = new TermOrder(TermOrder.INVLEX);
063
064
065    GenPolynomialRing<ModInteger> dfac;
066
067
068    GenPolynomialRing<ModInteger> cfac;
069
070
071    GenPolynomialRing<GenPolynomial<ModInteger>> rfac;
072
073
074    PrimeList primes = new PrimeList();
075
076
077    ModIntegerRing mi;
078
079
080    ModInteger ai;
081
082
083    ModInteger bi;
084
085
086    ModInteger ci;
087
088
089    ModInteger di;
090
091
092    ModInteger ei;
093
094
095    GenPolynomial<ModInteger> a;
096
097
098    GenPolynomial<ModInteger> b;
099
100
101    GenPolynomial<ModInteger> c;
102
103
104    GenPolynomial<ModInteger> d;
105
106
107    GenPolynomial<ModInteger> e;
108
109
110    GenPolynomial<GenPolynomial<ModInteger>> ar;
111
112
113    GenPolynomial<GenPolynomial<ModInteger>> br;
114
115
116    GenPolynomial<GenPolynomial<ModInteger>> cr;
117
118
119    GenPolynomial<GenPolynomial<ModInteger>> dr;
120
121
122    GenPolynomial<GenPolynomial<ModInteger>> er;
123
124
125    int rl = 3;
126
127
128    int kl = 4;
129
130
131    int ll = 5;
132
133
134    int el = 3;
135
136
137    float q = 0.3f;
138
139
140    @Override
141    protected void setUp() {
142        a = b = c = d = e = null;
143        ai = bi = ci = di = ei = null;
144        ar = br = cr = dr = er = null;
145        //mi = new ModIntegerRing(primes.get(0),true);
146        mi = new ModIntegerRing(19, true);
147        //mi = new ModIntegerRing(19*17,true); // failing tests
148        //mi = new ModIntegerRing(primes.get(0).multiply(primes.get(1)),false); // failing tests
149        //ufd = new GreatestCommonDivisorPrimitive<ModInteger>();
150        ufd = new GreatestCommonDivisorModEval<ModInteger>();
151        String[] vars = ExpVector.STDVARS(rl);
152        String[] cvars = ExpVector.STDVARS(rl - 1);
153        String[] rvars = new String[] { vars[rl - 1] };
154        dfac = new GenPolynomialRing<ModInteger>(mi, rl, to, vars);
155        cfac = new GenPolynomialRing<ModInteger>(mi, rl - 1, to, cvars);
156        rfac = new GenPolynomialRing<GenPolynomial<ModInteger>>(cfac, 1, to, rvars);
157        //System.out.println("mi = " + mi);
158    }
159
160
161    @Override
162    protected void tearDown() {
163        a = b = c = d = e = null;
164        ai = bi = ci = di = ei = null;
165        ar = br = cr = dr = er = null;
166        mi = null;
167        ufd = null;
168        dfac = null;
169        cfac = null;
170        rfac = null;
171    }
172
173
174    /**
175     * Test modular evaluation gcd.
176     */
177    public void testModEvalGcd() {
178
179        //GreatestCommonDivisorAbstract<ModInteger> ufd_me
180        //   = new GreatestCommonDivisorModEval();
181
182        for (int i = 0; i < 1; i++) {
183            a = dfac.random(kl * (i + 2), ll + 2 * i, el + 0 * i, q);
184            b = dfac.random(kl * (i + 2), ll + 2 * i, el + 0 * i, q);
185            c = dfac.random(kl * (i + 2), ll + 2 * i, el + 0 * i, q);
186            c = c.multiply(dfac.univariate(0));
187            //a = ufd.basePrimitivePart(a);
188            //b = ufd.basePrimitivePart(b);
189
190            if (a.isZERO() || b.isZERO() || c.isZERO()) {
191                // skip for this turn
192                continue;
193            }
194            assertTrue("length( c" + i + " ) <> 0", c.length() > 0);
195            //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() );
196            //assertTrue(" not isONE( c"+i+" )", !c.isONE() );
197
198            a = a.multiply(c);
199            b = b.multiply(c);
200            //System.out.println("a  = " + a);
201            //System.out.println("b  = " + b);
202
203            d = ufd.gcd(a, b);
204
205            c = ufd.basePrimitivePart(c).abs();
206            e = PolyUtil.<ModInteger> basePseudoRemainder(d, c);
207            //System.out.println("c  = " + c);
208            //System.out.println("d  = " + d);
209            assertTrue("c | gcd(ac,bc) " + e, e.isZERO());
210
211            e = PolyUtil.<ModInteger> basePseudoRemainder(a, d);
212            //System.out.println("e = " + e);
213            assertTrue("gcd(a,b) | a" + e, e.isZERO());
214
215            e = PolyUtil.<ModInteger> basePseudoRemainder(b, d);
216            //System.out.println("e = " + e);
217            assertTrue("gcd(a,b) | b" + e, e.isZERO());
218        }
219    }
220
221
222    /**
223     * Test base quotioent and remainder.
224     */
225    public void testBaseQR() {
226
227        dfac = new GenPolynomialRing<ModInteger>(mi, 1, to);
228
229        for (int i = 0; i < 5; i++) {
230            a = dfac.random(kl * (i + 2), ll + 2 * i, el + 2 * i, q);
231            c = dfac.random(kl * (i + 2), ll + 2 * i, el + 2 * i, q);
232            //a = ufd.basePrimitivePart(a).abs();
233            //c = ufd.basePrimitivePart(c);
234            do {
235                ci = mi.random(kl * (i + 2));
236                ci = ci.sum(mi.getONE());
237            } while (ci.isZERO());
238
239            //System.out.println("a  = " + a);
240            //System.out.println("c  = " + c);
241            //System.out.println("ci = " + ci);
242
243            if (a.isZERO() || c.isZERO()) {
244                // skip for this turn
245                continue;
246            }
247            assertTrue("length( c" + i + " ) <> 0", c.length() > 0);
248            //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() );
249            //assertTrue(" not isONE( c"+i+" )", !c.isONE() );
250
251            b = a.multiply(c);
252            //System.out.println("b  = " + b);
253            d = PolyUtil.<ModInteger> basePseudoRemainder(b, c);
254            //System.out.println("d  = " + d);
255
256            assertTrue("rem(ac,c) == 0", d.isZERO());
257
258            b = a.multiply(ci);
259            //System.out.println("b  = " + b);
260            d = b.divide(ci);
261            //System.out.println("d  = " + d);
262
263            assertEquals("a == ac/c", a, d);
264
265            b = a.multiply(c);
266            //System.out.println("b  = " + b);
267            d = PolyUtil.<ModInteger> basePseudoDivide(b, c);
268            //System.out.println("d  = " + d);
269
270            assertEquals("a == ac/c", a, d);
271        }
272    }
273
274
275    /**
276     * Test base content and primitive part.
277     */
278    public void testBaseContentPP() {
279
280        for (int i = 0; i < 13; i++) {
281            c = dfac.random(kl * (i + 2), ll + 2 * i, el + i, q);
282            c = c.multiply(mi.random(kl * (i + 2)));
283
284            if (c.isZERO()) {
285                // skip for this turn
286                continue;
287            }
288            assertTrue("length( c" + i + " ) <> 0", c.length() > 0);
289            //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() );
290            //assertTrue(" not isONE( c"+i+" )", !c.isONE() );
291
292            ci = ufd.baseContent(c);
293            d = ufd.basePrimitivePart(c);
294            //System.out.println("c  = " + c);
295            //System.out.println("ci = " + ci);
296            //System.out.println("d  = " + d);
297
298            a = d.multiply(ci);
299            assertEquals("c == cont(c)pp(c)", c, a);
300        }
301    }
302
303
304    /**
305     * Test base gcd.
306     */
307    public void testBaseGcd() {
308
309        dfac = new GenPolynomialRing<ModInteger>(mi, 1, to);
310
311        for (int i = 0; i < 5; i++) {
312            a = dfac.random(kl * (i + 2), ll + 2 * i, el + 2 * i, q);
313            b = dfac.random(kl * (i + 2), ll + 2 * i, el + 2 * i, q);
314            c = dfac.random(kl * (i + 2), ll + 2 * i, el + 2 * i, q);
315            //a = ufd.basePrimitivePart(a);
316            //b = ufd.basePrimitivePart(b);
317            //c = ufd.basePrimitivePart(c).abs();
318
319            //System.out.println("a  = " + a);
320            //System.out.println("b  = " + b);
321            //System.out.println("c  = " + c);
322
323            if (a.isZERO() || b.isZERO() || c.isZERO()) {
324                // skip for this turn
325                continue;
326            }
327            assertTrue("length( c" + i + " ) <> 0", c.length() > 0);
328            //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() );
329            //assertTrue(" not isONE( c"+i+" )", !c.isONE() );
330
331            a = a.multiply(c);
332            b = b.multiply(c);
333
334            d = ufd.baseGcd(a, b);
335            e = PolyUtil.<ModInteger> basePseudoRemainder(d, c);
336            //System.out.println("d  = " + d);
337
338            assertTrue("c | gcd(ac,bc) " + e, e.isZERO());
339        }
340    }
341
342
343    /**
344     * Test recursive quotioent and remainder.
345     */
346    public void testRecursiveQR() {
347        dfac = new GenPolynomialRing<ModInteger>(mi, 2, to);
348        cfac = new GenPolynomialRing<ModInteger>(mi, 2 - 1, to);
349        rfac = new GenPolynomialRing<GenPolynomial<ModInteger>>(cfac, 1, to);
350
351        for (int i = 0; i < 5; i++) {
352            a = dfac.random(kl * (i + 1), ll + i, el + i, q);
353            a = ufd.basePrimitivePart(a).abs();
354
355            c = dfac.random(kl * (i + 1), ll + i, el + i, q);
356            c = ufd.basePrimitivePart(a).abs();
357            cr = PolyUtil.<ModInteger> recursive(rfac, c);
358
359            c = cfac.random(kl * (i + 1), ll + 2 * i, el + 2 * i, q);
360            c = ufd.basePrimitivePart(c).abs();
361
362            ar = PolyUtil.<ModInteger> recursive(rfac, a);
363            //System.out.println("ar = " + ar);
364            //System.out.println("a  = " + a);
365            //System.out.println("c  = " + c);
366            //System.out.println("cr = " + cr);
367
368            if (cr.isZERO() || c.isZERO()) {
369                // skip for this turn
370                continue;
371            }
372            assertTrue("length( cr" + i + " ) <> 0", cr.length() > 0);
373            //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() );
374            //assertTrue(" not isONE( c"+i+" )", !c.isONE() );
375
376            br = ar.multiply(cr);
377            //System.out.println("br = " + br);
378            dr = PolyUtil.<ModInteger> recursivePseudoRemainder(br, cr);
379            //System.out.println("dr = " + dr);
380            d = PolyUtil.<ModInteger> distribute(dfac, dr);
381            //System.out.println("d  = " + d);
382
383            assertTrue("rem(ac,c) == 0", d.isZERO());
384
385            br = ar.multiply(c);
386            //System.out.println("br = " + br);
387            dr = PolyUtil.<ModInteger> recursiveDivide(br, c);
388            //System.out.println("dr = " + dr);
389            d = PolyUtil.<ModInteger> distribute(dfac, dr);
390            //System.out.println("d  = " + d);
391
392            assertEquals("a == ac/c", a, d);
393        }
394    }
395
396
397    /**
398     * Test recursive content and primitive part.
399     */
400    public void testRecursiveContentPP() {
401        dfac = new GenPolynomialRing<ModInteger>(mi, 2, to);
402        cfac = new GenPolynomialRing<ModInteger>(mi, 2 - 1, to);
403        rfac = new GenPolynomialRing<GenPolynomial<ModInteger>>(cfac, 1, to);
404
405        for (int i = 0; i < 3; i++) {
406            cr = rfac.random(kl * (i + 2), ll + 2 * i, el + i, q);
407            //System.out.println("cr = " + cr);
408
409            assertTrue("length( cr" + i + " ) <> 0", cr.length() > 0);
410            //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() );
411            //assertTrue(" not isONE( c"+i+" )", !c.isONE() );
412
413            c = ufd.recursiveContent(cr);
414            dr = ufd.recursivePrimitivePart(cr);
415            //System.out.println("c  = " + c);
416            //System.out.println("dr = " + dr);
417
418            ar = dr.multiply(c);
419            assertEquals("c == cont(c)pp(c)", cr, ar);
420        }
421    }
422
423
424    /**
425     * Test recursive gcd.
426     */
427    public void testRecursiveGCD() {
428        dfac = new GenPolynomialRing<ModInteger>(mi, 2, to);
429        cfac = new GenPolynomialRing<ModInteger>(mi, 2 - 1, to);
430        rfac = new GenPolynomialRing<GenPolynomial<ModInteger>>(cfac, 1, to);
431
432        for (int i = 0; i < 2; i++) {
433            ar = rfac.random(kl, ll, el + i, q);
434            br = rfac.random(kl, ll, el, q);
435            cr = rfac.random(kl, ll, el, q);
436            //System.out.println("ar = " + ar);
437            //System.out.println("br = " + br);
438            //System.out.println("cr = " + cr);
439
440            if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
441                // skip for this turn
442                continue;
443            }
444            assertTrue("length( cr" + i + " ) <> 0", cr.length() > 0);
445            //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() );
446            //assertTrue(" not isONE( c"+i+" )", !c.isONE() );
447
448            ar = ar.multiply(cr);
449            br = br.multiply(cr);
450            //System.out.println("ar = " + ar);
451            //System.out.println("br = " + br);
452
453            dr = ufd.recursiveUnivariateGcd(ar, br);
454            //System.out.println("dr = " + dr);
455
456            er = PolyUtil.<ModInteger> recursivePseudoRemainder(dr, cr);
457            //System.out.println("er = " + er);
458
459            assertTrue("c | gcd(ac,bc) " + er, er.isZERO());
460        }
461    }
462
463
464    /**
465     * Test arbitrary recursive gcd.
466     */
467    public void testArbitraryRecursiveGCD() {
468        dfac = new GenPolynomialRing<ModInteger>(mi, 2, to);
469        cfac = new GenPolynomialRing<ModInteger>(mi, 2 - 1, to);
470        rfac = new GenPolynomialRing<GenPolynomial<ModInteger>>(cfac, 1, to);
471
472        for (int i = 0; i < 2; i++) {
473            ar = rfac.random(kl, ll, el + i, q);
474            br = rfac.random(kl, ll, el, q);
475            cr = rfac.random(kl, ll, el, q);
476            //System.out.println("ar = " + ar);
477            //System.out.println("br = " + br);
478            //System.out.println("cr = " + cr);
479
480            if (ar.isZERO() || br.isZERO() || cr.isZERO()) {
481                // skip for this turn
482                continue;
483            }
484            assertTrue("length( cr" + i + " ) <> 0", cr.length() > 0);
485            //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() );
486            //assertTrue(" not isONE( c"+i+" )", !c.isONE() );
487
488            ar = ar.multiply(cr);
489            br = br.multiply(cr);
490            //System.out.println("ar = " + ar);
491            //System.out.println("br = " + br);
492
493            dr = ufd.recursiveGcd(ar, br);
494            //System.out.println("dr = " + dr);
495
496            er = PolyUtil.<ModInteger> recursivePseudoRemainder(dr, cr);
497            //System.out.println("er = " + er);
498
499            assertTrue("c | gcd(ac,bc) " + er, er.isZERO());
500        }
501    }
502
503
504    /**
505     * Test content and primitive part.
506     */
507    public void testContentPP() {
508        dfac = new GenPolynomialRing<ModInteger>(mi, 3, to);
509
510        for (int i = 0; i < 3; i++) {
511            c = dfac.random(kl * (i + 2), ll + 2 * i, el + i, q);
512            //System.out.println("cr = " + cr);
513            if (c.isZERO()) {
514                continue;
515            }
516
517            assertTrue("length( c" + i + " ) <> 0", c.length() > 0);
518            //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() );
519            //assertTrue(" not isONE( c"+i+" )", !c.isONE() );
520
521            a = ufd.content(c);
522            e = a.extend(dfac, 0, 0L);
523            b = ufd.primitivePart(c);
524            //System.out.println("c  = " + c);
525            //System.out.println("a  = " + a);
526            //System.out.println("e  = " + e);
527            //System.out.println("b  = " + b);
528
529            d = e.multiply(b);
530            assertEquals("c == cont(c)pp(c)", d, c);
531        }
532    }
533
534
535    /**
536     * Test gcd 3 variables.
537     */
538    public void testGCD3() {
539        dfac = new GenPolynomialRing<ModInteger>(mi, 3, to);
540
541        for (int i = 0; i < 4; i++) {
542            a = dfac.random(kl, ll, el + i, q);
543            b = dfac.random(kl, ll, el, q);
544            c = dfac.random(kl, ll, el, q);
545            //System.out.println("a = " + a);
546            //System.out.println("b = " + b);
547            //System.out.println("c = " + c);
548
549            if (a.isZERO() || b.isZERO() || c.isZERO()) {
550                // skip for this turn
551                continue;
552            }
553            assertTrue("length( c" + i + " ) <> 0", c.length() > 0);
554            //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() );
555            //assertTrue(" not isONE( c"+i+" )", !c.isONE() );
556
557            a = a.multiply(c);
558            b = b.multiply(c);
559            //System.out.println("a = " + a);
560            //System.out.println("b = " + b);
561
562            d = ufd.gcd(a, b);
563            //System.out.println("d = " + d);
564
565            e = PolyUtil.<ModInteger> basePseudoRemainder(d, c);
566            //System.out.println("e = " + e);
567
568            assertTrue("c | gcd(ac,bc) " + e, e.isZERO());
569        }
570    }
571
572
573    /**
574     * Test gcd.
575     */
576    public void testGCD() {
577        // dfac = new GenPolynomialRing<ModInteger>(mi,3,to);
578
579        for (int i = 0; i < 1; i++) {
580            a = dfac.random(kl, ll, el, q);
581            b = dfac.random(kl, ll, el, q);
582            c = dfac.random(kl, ll, el, q);
583            //System.out.println("a = " + a);
584            //System.out.println("b = " + b);
585            //System.out.println("c = " + c);
586
587            if (a.isZERO() || b.isZERO() || c.isZERO()) {
588                // skip for this turn
589                continue;
590            }
591            assertTrue("length( c" + i + " ) <> 0", c.length() > 0);
592            //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() );
593            //assertTrue(" not isONE( c"+i+" )", !c.isONE() );
594
595            a = a.multiply(c);
596            b = b.multiply(c);
597            //System.out.println("a = " + a);
598            //System.out.println("b = " + b);
599
600            d = ufd.gcd(a, b);
601            //System.out.println("d = " + d);
602
603            e = PolyUtil.<ModInteger> basePseudoRemainder(d, c);
604            //System.out.println("e = " + e);
605            assertTrue("c | gcd(ac,bc) " + e, e.isZERO());
606
607            e = PolyUtil.<ModInteger> basePseudoRemainder(a, d);
608            //System.out.println("e = " + e);
609            assertTrue("gcd(a,b) | a " + e, e.isZERO());
610
611            e = PolyUtil.<ModInteger> basePseudoRemainder(b, d);
612            //System.out.println("e = " + e);
613            assertTrue("gcd(a,b) | b " + e, e.isZERO());
614        }
615    }
616
617
618    /**
619     * Test lcm.
620     */
621    public void testLCM() {
622        dfac = new GenPolynomialRing<ModInteger>(mi, 3, to);
623
624        for (int i = 0; i < 1; i++) {
625            a = dfac.random(kl, ll, el, q);
626            b = dfac.random(kl, ll, el, q);
627            c = dfac.random(kl, 3, 2, q);
628            //System.out.println("a = " + a);
629            //System.out.println("b = " + b);
630            //System.out.println("c = " + c);
631
632            if (a.isZERO() || b.isZERO() || c.isZERO()) {
633                // skip for this turn
634                continue;
635            }
636            assertTrue("length( a" + i + " ) <> 0", a.length() > 0);
637            //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() );
638            //assertTrue(" not isONE( c"+i+" )", !c.isONE() );
639
640            a = a.multiply(c);
641            b = b.multiply(c);
642
643            c = ufd.gcd(a, b);
644            //System.out.println("c = " + c);
645
646            d = ufd.lcm(a, b);
647            //System.out.println("d = " + d);
648
649            e = c.multiply(d);
650            //System.out.println("e = " + e);
651            c = a.multiply(b);
652            //System.out.println("c = " + c);
653
654            assertEquals("ab == gcd(a,b)lcm(ab)", c, e);
655        }
656    }
657
658
659    /**
660     * Test co-prime factors.
661     */
662    public void testCoPrime() {
663
664        dfac = new GenPolynomialRing<ModInteger>(mi, 3, to);
665
666        a = dfac.random(kl, 3, 2, q);
667        b = dfac.random(kl, 3, 2, q);
668        c = dfac.random(kl, 3, 2, q);
669        //System.out.println("a  = " + a);
670        //System.out.println("b  = " + b);
671        //System.out.println("c  = " + c);
672
673        if (a.isZERO() || b.isZERO() || c.isZERO()) {
674            // skip for this turn
675            return;
676        }
677        assertTrue("length( a ) <> 0", a.length() > 0);
678
679        d = a.multiply(a).multiply(b).multiply(b).multiply(b).multiply(c);
680        e = a.multiply(b).multiply(c);
681        //System.out.println("d  = " + d);
682        //System.out.println("c  = " + c);
683
684        List<GenPolynomial<ModInteger>> F = new ArrayList<GenPolynomial<ModInteger>>(5);
685        F.add(d);
686        F.add(a);
687        F.add(b);
688        F.add(c);
689        F.add(e);
690        //System.out.println("F = " + F);
691        List<GenPolynomial<ModInteger>> P = ufd.coPrime(F);
692        //System.out.println("P = " + P);
693
694        assertTrue("is co-prime ", ufd.isCoPrime(P));
695        assertTrue("is co-prime of ", ufd.isCoPrime(P, F));
696
697        //P = ufd.coPrimeSquarefree(F);
698        //System.out.println("F = " + F);
699        //System.out.println("P = " + P);
700        //assertTrue("is co-prime ", ufd.isCoPrime(P) );
701        //assertTrue("is co-prime of ", ufd.isCoPrime(P,F) );
702
703        P = ufd.coPrimeRec(F);
704        //System.out.println("F = " + F);
705        //System.out.println("P = " + P);
706
707        assertTrue("is co-prime ", ufd.isCoPrime(P));
708        assertTrue("is co-prime of ", ufd.isCoPrime(P, F));
709    }
710
711
712    /**
713     * Test resultant.
714     */
715    public void testResultant() {
716        mi = new ModIntegerRing(163, true);
717        dfac = new GenPolynomialRing<ModInteger>(mi,3,to);
718        //System.out.println("dfac = " + dfac);
719
720        GreatestCommonDivisorAbstract<ModInteger> ufdm = new GreatestCommonDivisorModEval<ModInteger>();
721        GreatestCommonDivisorSubres<ModInteger> ufds = new GreatestCommonDivisorSubres<ModInteger>();
722
723        for (int i = 0; i < 1; i++) {
724            a = dfac.random(kl, ll, el, q);
725            b = dfac.random(kl, ll, el, q);
726            c = dfac.random(kl, ll, el, q);
727            //System.out.println("a = " + a);
728            //System.out.println("b = " + b);
729
730            if (a.isZERO() || b.isZERO() || c.isZERO()) {
731                // skip for this turn
732                continue;
733            }
734            if (c.isConstant()) {
735                c = dfac.univariate(0,1);
736            }
737            assertTrue("length( c" + i + " ) <> 0", c.length() > 0);
738
739            d = ufdm.resultant(a, b);
740            //System.out.println("d = " + d);
741            e = ufds.resultant(a, b);
742            //System.out.println("e = " + e);
743            assertEquals("d == e: " + d.subtract(e), d.abs().signum(), e.abs().signum());
744            //assertEquals("d == e: " + d.subtract(e), d, e);
745
746            //System.out.println("c = " + c);
747            GenPolynomial<ModInteger> ac = a.multiply(c);
748            GenPolynomial<ModInteger> bc = b.multiply(c);
749            //System.out.println("ac = " + ac);
750            //System.out.println("bc = " + bc);
751
752            d = ufdm.resultant(ac, bc);
753            //System.out.println("d = " + d);
754            //assertTrue("d == 0: " + d, d.isZERO());
755
756            e = ufds.resultant(ac, bc);
757            //System.out.println("e = " + e);
758            //assertTrue("e == 0: " + e, e.isZERO());
759
760            assertEquals("d == e: " + d.subtract(e), d.abs().signum(), e.abs().signum());
761        }
762    }
763
764}