001/*
002 * $Id$
003 */
004
005package edu.jas.ps;
006
007
008import java.util.ArrayList;
009import java.util.List;
010import java.util.Map;
011import java.util.Set;
012import java.util.TreeMap;
013import java.util.TreeSet;
014
015import junit.framework.Test;
016import junit.framework.TestCase;
017import junit.framework.TestSuite;
018
019import edu.jas.arith.BigInteger;
020import edu.jas.arith.ModInteger;
021import edu.jas.arith.ModIntegerRing;
022import edu.jas.poly.ExpVector;
023import edu.jas.poly.GenPolynomial;
024import edu.jas.poly.GenPolynomialRing;
025import edu.jas.poly.TermOrder;
026import edu.jas.util.CartesianProductInfinite;
027import edu.jas.util.CartesianProductLong;
028import edu.jas.util.LongIterable;
029
030
031/**
032 * Iterator tests with JUnit.
033 * @author Heinz Kredel
034 */
035
036public class IteratorsTest extends TestCase {
037
038
039    /**
040     * main.
041     */
042    public static void main(String[] args) {
043        junit.textui.TestRunner.run(suite());
044    }
045
046
047    /**
048     * Constructs a <CODE>ListUtilTest</CODE> object.
049     * @param name String.
050     */
051    public IteratorsTest(String name) {
052        super(name);
053    }
054
055
056    /**
057     */
058    public static Test suite() {
059        TestSuite suite = new TestSuite(IteratorsTest.class);
060        return suite;
061    }
062
063
064    @Override
065    protected void setUp() {
066    }
067
068
069    @Override
070    protected void tearDown() {
071    }
072
073
074    /**
075     * Test ExpVector iterator.
076     */
077    public void testExpVector() {
078        int n = 5;
079        LongIterable li = new LongIterable();
080        li.setNonNegativeIterator();
081
082        List<Iterable<Long>> tlist = new ArrayList<Iterable<Long>>(n);
083        for (int i = 0; i < n; i++) {
084            tlist.add(li);
085        }
086        //System.out.println("tlist = " + tlist);
087
088        Set<ExpVector> set = new TreeSet<ExpVector>((new TermOrder()).getDescendComparator());
089
090        Iterable<List<Long>> ib = new CartesianProductInfinite<Long>(tlist);
091
092        long t = 0L;
093        for (List<Long> i : ib) {
094            //System.out.println("i = " + i);
095            ExpVector e = ExpVector.create(i);
096            //System.out.println("e = " + e);
097            assertFalse("e in set", set.contains(e));
098            set.add(e);
099            t++;
100            if (t > 100L) {
101                //System.out.println("i = " + i);
102                break;
103            }
104        }
105        //System.out.println("set = " + set);
106        assertTrue("#set", set.size() == t);
107    }
108
109
110    /**
111     * Test GenPolynomial iterator.
112     */
113    public void testGenPolynomial() {
114        ModIntegerRing mi = new ModIntegerRing(5, true);
115        int n = 3;
116        GenPolynomialRing<ModInteger> ring = new GenPolynomialRing<ModInteger>(mi, n);
117
118        Set<GenPolynomial<ModInteger>> set = new TreeSet<GenPolynomial<ModInteger>>();
119
120        long t = 0;
121        for (GenPolynomial<ModInteger> p : ring) {
122            //System.out.println("p = " + p);
123            if (set.contains(p)) {
124                System.out.println("p = " + p);
125                System.out.println("set = " + set);
126                assertFalse("p in set ", true);
127            }
128            set.add(p);
129            t++;
130            if (t > 650L) {
131                //System.out.println("i = " + i);
132                break;
133            }
134        }
135        //System.out.println("set = " + set);
136        assertTrue("#set", set.size() == t);
137    }
138
139
140    /**
141     * Test GenPolynomial monomial iterator.
142     */
143    public void testGenPolynomialMonomial() {
144        BigInteger bi = new BigInteger(1);
145        int n = 3;
146        GenPolynomialRing<BigInteger> ring = new GenPolynomialRing<BigInteger>(bi, n);
147
148        Set<GenPolynomial<BigInteger>> set = new TreeSet<GenPolynomial<BigInteger>>();
149
150        long t = 0;
151        for (GenPolynomial<BigInteger> p : ring) {
152            //System.out.println("p = " + p);
153            if (set.contains(p)) {
154                System.out.println("p = " + p);
155                //System.out.println("set = " + set);
156                assertFalse("p in set ", true);
157            }
158            set.add(p);
159            t++;
160            if (t > 650L) {
161                //System.out.println("i = " + i);
162                break;
163            }
164        }
165        //System.out.println("set = " + set);
166        assertTrue("#set", set.size() == t);
167    }
168
169
170    /**
171     * Test total degree ExpVector iterator.
172     */
173    public void testTotalDegExpVector() {
174        int n = 4;
175
176        Set<ExpVector> set = new TreeSet<ExpVector>((new TermOrder()).getDescendComparator());
177
178        Map<Long, Set<ExpVector>> degset = new TreeMap<Long, Set<ExpVector>>();
179
180        long t = 0L;
181        for (long k = 0; k < 14; k++) {
182            LongIterable li = new LongIterable();
183            li.setNonNegativeIterator();
184            li.setUpperBound(k);
185            List<LongIterable> tlist = new ArrayList<LongIterable>(n);
186            for (int i = 0; i < n; i++) {
187                tlist.add(li); // can reuse li
188            }
189            long kdeg = k;
190            //if ( kdeg > 5 ) { // kdeg < k ok but kdeg > k not allowed
191            //    kdeg -= 2;
192            //}
193            Iterable<List<Long>> ib = new CartesianProductLong(tlist, kdeg);
194            //System.out.println("kdeg = " + kdeg);
195            for (List<Long> i : ib) {
196                //System.out.println("i = " + i);
197                ExpVector e = ExpVector.create(i);
198                long tdeg = e.totalDeg();
199                //System.out.println("e = " + e + ", deg = " + tdeg);
200                assertTrue("tdeg == k", tdeg == kdeg);
201                Set<ExpVector> es = degset.get(tdeg);
202                if (es == null) {
203                    es = new TreeSet<ExpVector>((new TermOrder()).getDescendComparator());
204                    degset.put(tdeg, es);
205                }
206                es.add(e);
207                //assertFalse("e in set", set.contains(e) );
208                set.add(e);
209                t++;
210                if (t > 500000L) {
211                    //System.out.println("i = " + i);
212                    break;
213                }
214            }
215        }
216        //System.out.println("waste = " + w + ", of " + t);
217        //System.out.println("set = " + set);
218        //System.out.println("degset = " + degset);
219        for (Set<ExpVector> es : degset.values()) {
220            assertFalse("es != null", es == null);
221            //System.out.println("#es = " + es.size() + ", es = " + es);
222            //System.out.println("#es = " + es.size() + ", deg = " + es.iterator().next().totalDeg());
223        }
224        assertTrue("#set", set.size() == t);
225    }
226
227
228    /**
229     * Test total degree ExpVector iterator.
230     */
231    public void testTotalDegExpVectorIteratorInf() {
232        int n = 4;
233
234        Set<ExpVector> set = new TreeSet<ExpVector>((new TermOrder()).getDescendComparator());
235
236        ExpVectorIterable eitbl = new ExpVectorIterable(n);
237        long t = 0;
238        for (ExpVector e : eitbl) {
239            //System.out.println("e = " + e + ", deg = " + e.totalDeg());
240            t++;
241            if (t > 500L) {
242                //System.out.println("i = " + i);
243                break;
244            }
245            assertFalse("e in set", set.contains(e));
246            set.add(e);
247        }
248    }
249
250
251    /**
252     * Test total degree ExpVector iterator.
253     */
254    public void testTotalDegExpVectorIteratorFin() {
255        int n = 4;
256
257        Set<ExpVector> set = new TreeSet<ExpVector>((new TermOrder()).getDescendComparator());
258
259        ExpVectorIterable eitbl = new ExpVectorIterable(n, 5);
260        long t = 0;
261        for (ExpVector e : eitbl) {
262            //System.out.println("e = " + e + ", deg = " + e.totalDeg());
263            t++;
264            if (t > 500L) {
265                //System.out.println("i = " + i);
266                break;
267            }
268            assertFalse("e in set", set.contains(e));
269            set.add(e);
270        }
271
272    }
273
274
275    /**
276     * Test total degree ExpVector iterator.
277     */
278    public void testTotalDegExpVectorIteratorAllFin() {
279        int n = 4;
280
281        Set<ExpVector> set = new TreeSet<ExpVector>((new TermOrder()).getDescendComparator());
282
283        ExpVectorIterable eitbl = new ExpVectorIterable(n, true, 5);
284        long t = 0;
285        for (ExpVector e : eitbl) {
286            //System.out.println("e = " + e + ", deg = " + e.totalDeg());
287            t++;
288            if (t > 500L) {
289                //System.out.println("i = " + i);
290                break;
291            }
292            assertFalse("e in set", set.contains(e));
293            set.add(e);
294        }
295    }
296
297}