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