Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.application;
006
007
008import java.util.ArrayList;
009import java.util.List;
010
011import edu.jas.arith.BigRational;
012import edu.jas.gb.WordGroebnerBaseSeq;
013// import edu.jas.kern.ComputerThreads;
014import edu.jas.poly.GenWordPolynomial;
015import edu.jas.poly.GenWordPolynomialRing;
016import edu.jas.poly.PolynomialList;
017import edu.jas.poly.TermOrder;
018
019import junit.framework.Test;
020import junit.framework.TestCase;
021import junit.framework.TestSuite;
022
023
024/**
025 * WordIdeal tests with JUnit.
026 * @author Heinz Kredel
027 */
028public class WordIdealTest extends TestCase {
029
030
031    /**
032     * main
033     */
034    public static void main(String[] args) {
035        junit.textui.TestRunner.run(suite());
036    }
037
038
039    /**
040     * Constructs a <CODE>WordIdealTest</CODE> object.
041     * @param name String.
042     */
043    public WordIdealTest(String name) {
044        super(name);
045        //ComputerThreads.terminate();
046    }
047
048
049    /**
050     * suite.
051     */
052    public static Test suite() {
053        TestSuite suite = new TestSuite(WordIdealTest.class);
054        return suite;
055    }
056
057
058    TermOrder to;
059
060
061    GenWordPolynomialRing<BigRational> fac;
062
063
064    List<GenWordPolynomial<BigRational>> L, M;
065
066
067    PolynomialList<BigRational> F;
068
069
070    List<GenWordPolynomial<BigRational>> G;
071
072
073    WordGroebnerBaseSeq<BigRational> bb;
074
075
076    GenWordPolynomial<BigRational> a, b, c, d, e;
077
078
079    int kl = 3; //10
080
081
082    int ll = 5; //7
083
084
085    int el = 2;
086
087
088    @Override
089    protected void setUp() {
090        BigRational coeff = new BigRational(17, 1);
091        to = new TermOrder( /*TermOrder.INVLEX*/);
092        String[] vars = new String[] { "x", "y", "z" };
093        //WordFactory wf = new WordFactory(vars);
094        fac = new GenWordPolynomialRing<BigRational>(coeff, vars);
095        bb = new WordGroebnerBaseSeq<BigRational>();
096        //bb = GBFactory.getImplementation(coeff);
097        //bb.timestatus.setNotActive(); // allow infintite computation
098        a = b = c = d = e = null;
099    }
100
101
102    @Override
103    protected void tearDown() {
104        a = b = c = d = e = null;
105        fac = null;
106        bb = null;
107    }
108
109
110    /**
111     * Test Ideal sum.
112     */
113    public void testIdealSum() {
114        WordIdeal<BigRational> I, J, K;
115        L = new ArrayList<GenWordPolynomial<BigRational>>();
116
117        a = fac.random(kl, ll, el);
118        b = fac.random(kl, ll, el);
119        c = fac.random(kl, ll, el);
120        d = fac.random(kl, ll, el);
121        e = d; //fac.random(kl, ll, el);
122
123        //System.out.println("a = " + a);
124        //System.out.println("b = " + b);
125        //System.out.println("c = " + c);
126        //System.out.println("d = " + d);
127
128        L.add(a);
129        //System.out.println("L = " + L.size() );
130
131        I = new WordIdeal<BigRational>(fac, L, true, bb);
132        assertTrue("isGB( I )", I.isGB());
133
134        I = new WordIdeal<BigRational>(fac, L, false, bb);
135        assertTrue("isGB( I )", I.isGB());
136
137        L = bb.GB(L);
138        assertTrue("isGB( { a } )", bb.isGB(L));
139
140        I = new WordIdeal<BigRational>(fac, L, true, bb);
141        assertTrue("isGB( I )", I.isGB());
142
143        I = new WordIdeal<BigRational>(fac, L, false, bb);
144        assertTrue("isGB( I )", I.isGB());
145
146        String s = I.toScript() + "\n" + I.toString();
147        //System.out.println("#s = " + s.length() + ": " + s);
148        assertTrue("#s >= 46: " + s + ", #s = " + s.length(), s.length() >= 46);
149
150        K = I.getZERO();
151        assertTrue("K == 0: " + K, K.isZERO());
152        K = I.getONE();
153        assertTrue("K == 1: " + K, K.isONE());
154
155        //assertTrue("not isZERO( b )", !b.isZERO());
156        L.add(b);
157        //System.out.println("L = " + L.size() );
158
159        I = new WordIdeal<BigRational>(fac, L, false, bb);
160        assertTrue("not isZERO( I )", !I.isZERO());
161        //assertTrue("not isONE( I )", !I.isONE() );
162        //assertTrue("not isGB( I )", !I.isGB() );
163
164        L = bb.GB(L);
165        assertTrue("isGB( { a, b } )", bb.isGB(L));
166
167        I = new WordIdeal<BigRational>(fac, L, true, bb);
168        assertTrue("not isZERO( I )", !I.isZERO());
169        // assertTrue("not isONE( I )", !I.isONE() );
170        assertTrue("isGB( I )", I.isGB());
171
172        J = I;
173        K = J.sum(I);
174        //assertTrue("not isZERO( K )", !K.isZERO());
175        assertTrue("isGB( K )", K.isGB());
176        assertTrue("equals( K, I )", K.equals(I));
177        assertEquals("compareTo( K, I )", K.compareTo(I), 0);
178
179        K = J.sum(I.getList());
180        assertTrue("isGB( K )", K.isGB());
181        assertTrue("equals( K, I )", K.equals(I));
182        assertEquals("compareTo( K, I )", K.compareTo(I), 0);
183
184        K = J.sum(I.getList().get(0));
185        assertTrue("isGB( K )", K.isGB());
186        assertTrue("equals( K, I )", K.equals(I));
187        assertEquals("compareTo( K, I )", K.compareTo(I), 0);
188
189        L = new ArrayList<GenWordPolynomial<BigRational>>();
190
191        L.add(c);
192        assertTrue("isGB( { c } )", bb.isGB(L));
193
194        J = new WordIdeal<BigRational>(fac, L, true, bb);
195        K = J.sum(I);
196        assertTrue("isGB( K )", K.isGB());
197        assertTrue("K contains(I)", K.contains(I));
198        assertTrue("K contains(J)", K.contains(J));
199
200        L = new ArrayList<GenWordPolynomial<BigRational>>();
201        L.add(d);
202
203        assertTrue("isGB( { d } )", bb.isGB(L));
204        J = new WordIdeal<BigRational>(fac, L, true, bb);
205        I = K;
206        K = J.sum(I);
207        assertTrue("isGB( K )", K.isGB());
208        assertTrue("K contains(I)", K.contains(I));
209        assertTrue("K contains(J)", K.contains(J));
210
211        L = new ArrayList<GenWordPolynomial<BigRational>>();
212        L.add(e);
213
214        assertTrue("isGB( { e } )", bb.isGB(L));
215        J = new WordIdeal<BigRational>(fac, L, true, bb);
216        I = K;
217        K = J.sum(I);
218        assertTrue("isGB( K )", K.isGB());
219        assertTrue("equals( K, I )", K.equals(I));
220        assertTrue("K contains(J)", K.contains(I));
221        assertTrue("I contains(K)", I.contains(K));
222        assertEquals("compareTo( K, I )", K.compareTo(I), 0);
223
224        L.clear();
225        e = fac.parse("x x");
226        L.add(e);
227        I = new WordIdeal<BigRational>(fac, L, true, bb);
228        I.doGB();
229        J = I.power(3);
230        J = J.power(2);
231        K = I.power(6);
232        //System.out.println("I = " + I);
233        //System.out.println("J = " + J);
234        //System.out.println("K = " + K);
235        assertEquals("equals( (I**3)**2, I**6 )", K, J);
236    }
237
238
239    /**
240     * Test WordIdeal product. Sometimes non-terminating.
241     */
242    public void testWordIdealProduct() {
243        WordIdeal<BigRational> I, J, K, H, G;
244        a = fac.random(kl, ll, el);
245        b = fac.random(kl, ll, el);
246        c = fac.random(kl, ll, el);
247        d = c; //fac.random(kl, ll, el);
248        e = d; //fac.random(kl, ll, el);
249
250        //System.out.println("a = " + a);
251        //System.out.println("b = " + b);
252        //System.out.println("c = " + c);
253        //System.out.println("d = " + d);
254
255        L = new ArrayList<GenWordPolynomial<BigRational>>();
256        L.add(a);
257
258        I = new WordIdeal<BigRational>(fac, L, false, bb);
259        assertTrue("not isONE( I )", !I.isONE() || a.isConstant());
260        assertTrue("isGB( I )", I.isGB());
261
262        L = new ArrayList<GenWordPolynomial<BigRational>>();
263        L.add(b);
264
265        J = new WordIdeal<BigRational>(fac, L, false, bb);
266        assertTrue("not isONE( J )", !J.isONE() || a.isConstant() || b.isConstant());
267        assertTrue("isGB( J )", J.isGB());
268
269        K = I.product(J);
270        //System.out.println("I = " + I);
271        //System.out.println("J = " + J);
272        //System.out.println("K = " + K);
273        H = J.product(I);
274        //System.out.println("H = " + H);
275        G = K.sum(H);
276        //System.out.println("G = " + G);
277        assertTrue("isGB( K )", K.isGB());
278        assertTrue("isGB( H )", H.isGB());
279        assertTrue("isGB( G )", G.isGB());
280        //non-com 
281        assertTrue("I contains(K)", I.contains(K));
282        assertTrue("J contains(H)", J.contains(H));
283
284        K = I.product(J.getList().get(0));
285        //System.out.println("I = " + I);
286        //System.out.println("J = " + J);
287        //System.out.println("K = " + K);
288        assertTrue("isGB( K )", K.isGB());
289        assertTrue("I contains(K)", I.contains(K));
290
291
292        L = new ArrayList<GenWordPolynomial<BigRational>>();
293        L.add(a);
294        //L.add(c);
295        L = bb.GB(L); // may be infinite with c
296
297        I = new WordIdeal<BigRational>(fac, L, true, bb);
298        //System.out.println("I = " + I);
299        assertTrue("isGB( I )", I.isGB());
300
301        //System.out.println("J = " + J);
302        K = I.product(J);
303        //System.out.println("K = " + K);
304        assertTrue("isGB( K )", K.isGB());
305        assertTrue("I contains(K)", I.contains(K));
306        assertTrue("J contains(K)", J.contains(K));
307
308        M = I.normalform(K.getList());
309        H = new WordIdeal<BigRational>(fac, M, false, bb);
310        //System.out.println("I = " + I);
311        //System.out.println("K = " + K);
312        //System.out.println("H = " + H);
313        assertTrue("isGB( H )", H.isGB());
314        assertTrue("isZERO( H )", H.isZERO());
315    }
316
317
318    /**
319     * Test WordIdeal common zeros.
320     */
321    public void testWordIdealCommonZeros() {
322        WordIdeal<BigRational> I, J;
323        L = new ArrayList<GenWordPolynomial<BigRational>>();
324
325        I = new WordIdeal<BigRational>(fac, L, true, bb);
326        assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1);
327
328        a = fac.getZERO();
329        L.add(a);
330        I = new WordIdeal<BigRational>(fac, L, true, bb);
331        assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1);
332
333        b = fac.getONE();
334        L.add(b);
335        I = new WordIdeal<BigRational>(fac, L, true, bb);
336        assertEquals("commonZeroTest( I )", I.commonZeroTest(), -1);
337
338        L = new ArrayList<GenWordPolynomial<BigRational>>();
339        a = fac.random(kl, ll, el);
340        if (!a.isZERO() && !a.isConstant()) {
341            L.add(a);
342            I = new WordIdeal<BigRational>(fac, L, true, bb);
343            assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1);
344        }
345
346        L = (List<GenWordPolynomial<BigRational>>) fac.univariateList();
347        //System.out.println("L = " + L);
348        I = new WordIdeal<BigRational>(fac, L, true, bb);
349        assertEquals("commonZeroTest( I )", I.commonZeroTest(), 0);
350
351        J = I.product(I);
352        //System.out.println("J = " + J);
353        assertEquals("commonZeroTest( J )", J.commonZeroTest(), 0);
354
355        L.remove(0);
356        I = new WordIdeal<BigRational>(fac, L, true, bb);
357        assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1);
358    }
359
360
361    /**
362     * Test WordIdeal contraction.
363     */
364    public void testContraction() {
365        BigRational coeff = new BigRational(17, 1);
366        String[] vs = new String[] { "beta", "x", "y", "z" };
367        GenWordPolynomialRing<BigRational> fac2 = new GenWordPolynomialRing<BigRational>(coeff, vs);
368
369        WordIdeal<BigRational> I, J, K;
370        L = new ArrayList<GenWordPolynomial<BigRational>>();
371        a = fac2.getZERO();
372        L.add(a);
373        //b = fac2.getONE();
374        //L.add(b);
375
376        b = fac2.random(3).monic();
377        b = fac2.valueOf(b);
378        L.add(b);
379
380        c = fac.random(4).monic();
381        c = fac2.valueOf(c);
382        L.add(c);
383
384        I = new WordIdeal<BigRational>(fac2, L, false, bb);
385        //System.out.println("I = " + I);
386        I.doGB();
387        //System.out.println("I = " + I);
388
389        // now intersect with word polynomial ring
390        //System.out.println("fac = " + fac.toScript());
391        J = I.intersect(fac);
392        //System.out.println("J = " + J);
393
394        List<GenWordPolynomial<BigRational>> ex = new ArrayList<GenWordPolynomial<BigRational>>();
395        for (GenWordPolynomial<BigRational> p : J.getList()) {
396            GenWordPolynomial<BigRational> pe = fac2.valueOf(p);
397            ex.add(pe);
398        }
399        K = new WordIdeal<BigRational>(fac2, ex, false, bb);
400        //System.out.println("K = " + K);
401
402        assertTrue("intersect ", I.contains(K));
403    }
404
405
406    /**
407     * Test WordIdeal intersection.
408     */
409    public void testIntersection() {
410        WordIdeal<BigRational> I, J, K;
411
412        // first ideal
413        L = new ArrayList<GenWordPolynomial<BigRational>>();
414        b = fac.random(3).monic();
415        L.add(b);
416        c = fac.random(4).monic();
417        L.add(c);
418
419        I = new WordIdeal<BigRational>(fac, L, false, bb);
420        //System.out.println("I = " + I);
421
422        // second ideal
423        L.clear();
424        a = fac.random(3).monic();
425        L.add(a);
426
427        J = new WordIdeal<BigRational>(fac, L, false, bb);
428        //System.out.println("J = " + J);
429
430        // now intersect with word ideal
431        K = I.intersect(J);
432        //System.out.println("I cap J = K = " + K);
433        assertTrue("intersect ", I.contains(K));
434        assertTrue("intersect ", J.contains(K));
435
436        // now intersect with list of word ideals
437        List<WordIdeal<BigRational>> Bl = new ArrayList<WordIdeal<BigRational>>();
438        Bl.add(J);
439        K = I.intersect(Bl);
440        //System.out.println("I cap J = K = " + K);
441        assertTrue("intersect ", I.contains(K));
442        assertTrue("intersect ", J.contains(K));
443    }
444
445}