001 /*
002 * $Id: IteratorsTest.java 3444 2010-12-25 17:13:53Z kredel $
003 */
004
005 package edu.jas.util;
006
007
008 import java.util.ArrayList;
009 import java.util.HashSet;
010 import java.util.Iterator;
011 import java.util.List;
012 import java.util.Set;
013
014 import junit.framework.Test;
015 import junit.framework.TestCase;
016 import junit.framework.TestSuite;
017
018 import edu.jas.arith.BigInteger;
019
020
021 /**
022 * Iterator tests with JUnit.
023 * @author Heinz Kredel.
024 */
025
026 public class IteratorsTest extends TestCase {
027
028
029 /**
030 * main.
031 */
032 public static void main(String[] args) {
033 junit.textui.TestRunner.run(suite());
034 }
035
036
037 /**
038 * Constructs a <CODE>ListUtilTest</CODE> object.
039 * @param name String.
040 */
041 public IteratorsTest(String name) {
042 super(name);
043 }
044
045
046 /**
047 */
048 public static Test suite() {
049 TestSuite suite = new TestSuite(IteratorsTest.class);
050 return suite;
051 }
052
053
054 @Override
055 protected void setUp() {
056 }
057
058
059 @Override
060 protected void tearDown() {
061 }
062
063
064 /**
065 * Test cartesian product.
066 *
067 */
068 public void testCartesianProduct() {
069 BigInteger ai = new BigInteger();
070 int s1 = 5;
071 int s2 = 3;
072 int s = 1;
073 for (int i = 0; i < s1; i++) {
074 s *= s2;
075 }
076 //System.out.println("s = " + s);
077 List<Iterable<BigInteger>> tlist = new ArrayList<Iterable<BigInteger>>(s1);
078 for (int i = 0; i < s1; i++) {
079 List<BigInteger> list = new ArrayList<BigInteger>(s2);
080 for (int j = 0; j < s2; j++) {
081 list.add(ai.fromInteger(j));
082 }
083 tlist.add(list);
084 }
085 //System.out.println("tlist = " + tlist);
086 int t = 0;
087 for (List<BigInteger> tuple : new CartesianProduct<BigInteger>(tlist)) {
088 t++;
089 //System.out.println("tuple = " + tuple);
090 assertTrue("|tuple| == " + s1 + " ", s1 == tuple.size());
091 }
092 assertTrue("#tuple == " + s + " == " + t + " ", t == s);
093 }
094
095
096 /**
097 * Test power set.
098 *
099 */
100 public void testPowerSet() {
101 BigInteger ai = new BigInteger();
102 int s1 = 5;
103 int s = 1;
104 for (int i = 0; i < s1; i++) {
105 s *= 2;
106 }
107 //System.out.println("s = " + s);
108 List<BigInteger> tlist = new ArrayList<BigInteger>(s1);
109 for (int j = 0; j < s1; j++) {
110 tlist.add(ai.random(7));
111 }
112 //System.out.println("tlist = " + tlist);
113 int t = 0;
114 for (List<BigInteger> tuple : new PowerSet<BigInteger>(tlist)) {
115 t++;
116 //System.out.println("tuple = " + tuple);
117 }
118 assertTrue("#tuple == " + s + " == " + t + " ", t == s);
119 }
120
121
122 /**
123 * Test k-subset set.
124 *
125 */
126 public void testKsubSet() {
127 BigInteger ai = new BigInteger();
128 int s1 = 5;
129 int s = 1;
130 for (int i = 0; i < s1; i++) {
131 s *= 2;
132 }
133 //System.out.println("s = " + s);
134 List<BigInteger> tlist = new ArrayList<BigInteger>(s1);
135 for (int j = 0; j < s1; j++) {
136 tlist.add(ai.random(7));
137 }
138 //System.out.println("tlist = " + tlist);
139 int t = 0;
140 for (int k = 0; k <= s1; k++) {
141 for (List<BigInteger> tuple : new KsubSet<BigInteger>(tlist, k)) {
142 t++;
143 //System.out.println("tuple = " + tuple);
144 assertTrue("|tuple| == " + k + " ", k == tuple.size());
145 }
146 }
147 assertTrue("#tuple == " + s + " == " + t + " ", t == s);
148 }
149
150
151 /**
152 * Test infinite cartesian product.
153 *
154 */
155 public void testInfiniteCartesianProductTwoList() {
156 BigInteger ai = new BigInteger();
157 ai.setNonNegativeIterator();
158 int s1 = 2;
159 //System.out.println("s1 = " + s1);
160 List<Iterable<BigInteger>> tlist = new ArrayList<Iterable<BigInteger>>(s1);
161 for (int i = 0; i < s1; i++) {
162 tlist.add(ai);
163 }
164 //System.out.println("tlist = " + tlist);
165 Set<List<BigInteger>> set = new HashSet<List<BigInteger>>();
166
167 int s2 = 5;
168 int s = 1;
169 for (int i = 0; i < s1; i++) {
170 s *= s2;
171 }
172 //System.out.println("s = " + s);
173 List<Iterable<BigInteger>> ftlist = new ArrayList<Iterable<BigInteger>>(s1);
174 for (int i = 0; i < s1; i++) {
175 List<BigInteger> list = new ArrayList<BigInteger>(s2);
176 for (int j = 0; j < s2; j++) {
177 list.add(ai.fromInteger(j));
178 }
179 ftlist.add(list);
180 }
181 //System.out.println("tlist = " + tlist);
182 int r = 0;
183 for (List<BigInteger> tuple : new CartesianProduct<BigInteger>(ftlist)) {
184 r++;
185 set.add(tuple);
186 }
187 //System.out.println("set = " + set.size());
188 //System.out.println("set = " + r);
189
190 int t = 0;
191 int h = 0;
192 Iterable<List<BigInteger>> ib = new CartesianProductInfinite<BigInteger>(tlist);
193 Iterator<List<BigInteger>> iter = ib.iterator();
194 while (iter.hasNext()) {
195 List<BigInteger> tuple = iter.next();
196 t++;
197 //System.out.println("tuple = " + tuple);
198 //assertTrue("|tuple| == " + s1 + " ", s1 == tuple.size());
199 if (set.contains(tuple)) {
200 h++;
201 }
202 if (h >= r) {
203 break;
204 }
205 assertTrue("#tuple <= 125 " + t, t <= 125);
206 }
207 //System.out.println("#tuple = " + t + ", #set = " + r);
208 }
209
210
211 /**
212 * Test infinite cartesian product.
213 *
214 */
215 public void testInfiniteCartesianProduct() {
216 BigInteger ai = new BigInteger();
217 ai.setNonNegativeIterator();
218 int s1 = 4;
219 //System.out.println("s1 = " + s1);
220 List<Iterable<BigInteger>> tlist = new ArrayList<Iterable<BigInteger>>(s1);
221 for (int i = 0; i < s1; i++) {
222 tlist.add(ai);
223 }
224 //System.out.println("tlist = " + tlist);
225 Set<List<BigInteger>> set = new HashSet<List<BigInteger>>();
226
227 int s2 = 5;
228 int s = 1;
229 for (int i = 0; i < s1; i++) {
230 s *= s2;
231 }
232 //System.out.println("s = " + s);
233 List<Iterable<BigInteger>> ftlist = new ArrayList<Iterable<BigInteger>>(s1);
234 for (int i = 0; i < s1; i++) {
235 List<BigInteger> list = new ArrayList<BigInteger>(s2);
236 for (int j = 0; j < s2; j++) {
237 list.add(ai.fromInteger(j));
238 }
239 ftlist.add(list);
240 }
241 //System.out.println("tlist = " + tlist);
242 int r = 0;
243 for (List<BigInteger> tuple : new CartesianProduct<BigInteger>(ftlist)) {
244 r++;
245 set.add(tuple);
246 }
247 //System.out.println("set = " + set.size());
248 //System.out.println("set = " + r);
249
250 int t = 0;
251 int h = 0;
252 Iterable<List<BigInteger>> ib = new CartesianProductInfinite<BigInteger>(tlist);
253 Iterator<List<BigInteger>> iter = ib.iterator();
254 while (iter.hasNext()) {
255 List<BigInteger> tuple = iter.next();
256 t++;
257 //System.out.println("tuple = " + tuple);
258 //assertTrue("|tuple| == " + s1 + " ", s1 == tuple.size());
259 if (set.contains(tuple)) {
260 h++;
261 }
262 if (h >= r) {
263 break;
264 }
265 assertTrue("#tuple <= 3281 " + t, t <= 3281);
266 }
267 //System.out.println("#tuple = " + t + ", #set = " + r);
268 }
269
270
271 /**
272 * Test Long iterator.
273 *
274 */
275 public void testLong() {
276 LongIterable li = new LongIterable();
277 li.setNonNegativeIterator();
278 long s = 0L;
279 long t = 0L;
280 for (Long i : li) {
281 //System.out.println("i = " + i);
282 s = i;
283 assertTrue("t == i", t == i);
284 t++;
285 if (t > 1000L) { //% 100000000L == 0L ) {
286 //System.out.println("i = " + i);
287 break;
288 }
289 }
290 //System.out.println("t = " + t);
291 assertTrue("i == 1000", s == 1000L);
292
293 li.setAllIterator();
294 s = 0L;
295 t = 0L;
296 for (Long i : li) {
297 //System.out.println("i = " + i);
298 s = i;
299 //assertTrue("t == i", t == i );
300 t++;
301 if (t >= 1000L) { //% 100000000L == 0L ) {
302 //System.out.println("i = " + i);
303 break;
304 }
305 }
306 //System.out.println("t = " + t);
307 assertTrue("i == 500", s == 500L);
308 }
309
310 }