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