001 /*
002 * $Id: SolvableGroebnerBaseSeqTest.java 3421 2010-12-23 20:40:38Z kredel $
003 */
004
005 package edu.jas.gb;
006
007 import java.util.ArrayList;
008 import java.util.List;
009
010 import junit.framework.Test;
011 import junit.framework.TestCase;
012 import junit.framework.TestSuite;
013
014 import org.apache.log4j.BasicConfigurator;
015 //import org.apache.log4j.Logger;
016
017 import edu.jas.arith.BigRational;
018 import edu.jas.poly.GenSolvablePolynomial;
019 import edu.jas.poly.GenSolvablePolynomialRing;
020 import edu.jas.poly.PolynomialList;
021 import edu.jas.poly.RelationTable;
022 import edu.jas.poly.TermOrder;
023 import edu.jas.poly.WeylRelations;
024
025 /**
026 * Solvable Groebner base sequential tests with JUnit.
027 * @author Heinz Kredel.
028 */
029
030 public class SolvableGroebnerBaseSeqTest extends TestCase {
031
032 //private static final Logger logger = Logger.getLogger(SolvableGroebnerBaseSeqTest.class);
033
034 /**
035 * main.
036 */
037 public static void main (String[] args) {
038 BasicConfigurator.configure();
039 junit.textui.TestRunner.run( suite() );
040 }
041
042 /**
043 * Constructs a <CODE>SolvableGroebnerBaseSeqTest</CODE> object.
044 * @param name String.
045 */
046 public SolvableGroebnerBaseSeqTest(String name) {
047 super(name);
048 }
049
050 /**
051 * suite.
052 */
053 public static Test suite() {
054 TestSuite suite= new TestSuite(SolvableGroebnerBaseSeqTest.class);
055 return suite;
056 }
057
058 int port = 4711;
059 String host = "localhost";
060
061 GenSolvablePolynomial<BigRational> a;
062 GenSolvablePolynomial<BigRational> b;
063 GenSolvablePolynomial<BigRational> c;
064 GenSolvablePolynomial<BigRational> d;
065 GenSolvablePolynomial<BigRational> e;
066
067 List<GenSolvablePolynomial<BigRational>> L;
068 PolynomialList<BigRational> F;
069 PolynomialList<BigRational> G;
070
071 GenSolvablePolynomialRing<BigRational> ring;
072
073 SolvableGroebnerBase<BigRational> sbb;
074
075 BigRational cfac;
076 TermOrder tord;
077 RelationTable<BigRational> table;
078
079 int rl = 4; //4; //3;
080 int kl = 10;
081 int ll = 4;
082 int el = 2;
083 float q = 0.3f; //0.4f
084
085 protected void setUp() {
086 cfac = new BigRational(9);
087 tord = new TermOrder();
088 ring = new GenSolvablePolynomialRing<BigRational>(cfac,rl,tord);
089 table = ring.table;
090 a = b = c = d = e = null;
091 sbb = new SolvableGroebnerBaseSeq<BigRational>();
092
093 a = ring.random(kl, ll, el, q );
094 b = ring.random(kl, ll, el, q );
095 c = ring.random(kl, ll, el, q );
096 d = ring.random(kl, ll, el, q );
097 e = d; //ring.random(kl, ll, el, q );
098 }
099
100 protected void tearDown() {
101 a = b = c = d = e = null;
102 ring = null;
103 tord = null;
104 table = null;
105 cfac = null;
106 sbb = null;
107 }
108
109
110 /**
111 * Test sequential GBase.
112 */
113 public void testSequentialGBase() {
114
115 if ( a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO() ) {
116 return;
117 }
118
119 assertTrue("not isZERO( a )", !a.isZERO() );
120
121 L = new ArrayList<GenSolvablePolynomial<BigRational>>();
122 L.add(a);
123
124 L = sbb.leftGB( L );
125 assertTrue("isLeftGB( { a } )", sbb.isLeftGB(L) );
126
127 assertTrue("not isZERO( b )", !b.isZERO() );
128 L.add(b);
129 //System.out.println("L = " + L.size() );
130
131 L = sbb.leftGB( L );
132 assertTrue("isLeftGB( { a, b } )", sbb.isLeftGB(L) );
133
134 assertTrue("not isZERO( c )", !c.isZERO() );
135 L.add(c);
136
137 L = sbb.leftGB( L );
138 assertTrue("isLeftGB( { a, b, c } )", sbb.isLeftGB(L) );
139
140 assertTrue("not isZERO( d )", !d.isZERO() );
141 L.add(d);
142
143 L = sbb.leftGB( L );
144 assertTrue("isLeftGB( { a, b, c, d } )", sbb.isLeftGB(L) );
145
146 assertTrue("not isZERO( e )", !e.isZERO() );
147 L.add(e);
148
149 L = sbb.leftGB( L );
150 assertTrue("isLeftGB( { a, b, c, d, e } )", sbb.isLeftGB(L) );
151 }
152
153
154 /**
155 * Test Weyl sequential GBase.
156 *
157 */
158 public void testWeylSequentialGBase() {
159
160 int rloc = 4;
161 ring = new GenSolvablePolynomialRing<BigRational>(cfac,rloc);
162
163 WeylRelations<BigRational> wl = new WeylRelations<BigRational>(ring);
164 wl.generate();
165 table = ring.table;
166
167 a = ring.random(kl, ll, el, q );
168 b = ring.random(kl, ll, el, q );
169 c = ring.random(kl, ll, el, q );
170 d = ring.random(kl, ll, el, q );
171 e = d; //ring.random(kl, ll, el, q );
172
173 if ( a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO() ) {
174 return;
175 }
176
177 assertTrue("not isZERO( a )", !a.isZERO() );
178
179 L = new ArrayList<GenSolvablePolynomial<BigRational>>();
180 L.add(a);
181
182 L = sbb.leftGB( L );
183 assertTrue("isLeftGB( { a } )", sbb.isLeftGB(L) );
184
185 assertTrue("not isZERO( b )", !b.isZERO() );
186 L.add(b);
187 //System.out.println("L = " + L.size() );
188
189 L = sbb.leftGB( L );
190 assertTrue("isLeftGB( { a, b } )", sbb.isLeftGB(L) );
191
192 assertTrue("not isZERO( c )", !c.isZERO() );
193 L.add(c);
194
195 L = sbb.leftGB( L );
196 assertTrue("isLeftGB( { a, b, c } )", sbb.isLeftGB(L) );
197
198 assertTrue("not isZERO( d )", !d.isZERO() );
199 L.add(d);
200
201 L = sbb.leftGB( L );
202 assertTrue("isLeftGB( { a, b, c, d } )", sbb.isLeftGB(L) );
203
204 assertTrue("not isZERO( e )", !e.isZERO() );
205 L.add(e);
206
207 L = sbb.leftGB( L );
208 assertTrue("isLeftGB( { a, b, c, d, e } )", sbb.isLeftGB(L) );
209 }
210
211
212 /**
213 * Test sequential twosided GBase.
214 *
215 */
216 public void testSequentialTSGBase() {
217
218 if ( a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO() ) {
219 return;
220 }
221
222 assertTrue("not isZERO( a )", !a.isZERO() );
223
224 L = new ArrayList<GenSolvablePolynomial<BigRational>>();
225 L.add(a);
226
227 L = sbb.twosidedGB( L );
228 //System.out.println("L = " + L.size() );
229 assertTrue("isTwosidedGB( { a } )", sbb.isTwosidedGB(L) );
230
231 assertTrue("not isZERO( b )", !b.isZERO() );
232 L.add(b);
233
234 L = sbb.twosidedGB( L );
235 //System.out.println("L = " + L.size() );
236 assertTrue("isTwosidedGB( { a, b } )", sbb.isTwosidedGB(L) );
237
238 assertTrue("not isZERO( c )", !c.isZERO() );
239 L.add(c);
240
241 L = sbb.twosidedGB( L );
242 //System.out.println("L = " + L.size() );
243 assertTrue("isTwosidedGB( { a, b, c } )", sbb.isTwosidedGB(L) );
244
245 assertTrue("not isZERO( d )", !d.isZERO() );
246 L.add(d);
247
248 L = sbb.twosidedGB( L );
249 //System.out.println("L = " + L.size() );
250 assertTrue("isTwosidedGB( { a, b, c, d } )", sbb.isTwosidedGB(L) );
251
252 assertTrue("not isZERO( e )", !e.isZERO() );
253 L.add(e);
254
255 L = sbb.twosidedGB( L );
256 //System.out.println("L = " + L.size() );
257 assertTrue("isTwosidedGB( { a, b, c, d, e } )", sbb.isTwosidedGB(L) );
258 }
259
260
261
262 /**
263 * Test Weyl sequential twosided GBase
264 * is always 1.
265 */
266 public void testWeylSequentialTSGBase() {
267
268 int rloc = 4;
269 ring = new GenSolvablePolynomialRing<BigRational>(cfac,rloc);
270
271 WeylRelations<BigRational> wl = new WeylRelations<BigRational>(ring);
272 wl.generate();
273 table = ring.table;
274
275 a = ring.random(kl, ll, el, q );
276 b = ring.random(kl, ll, el, q );
277 c = ring.random(kl, ll, el, q );
278 d = ring.random(kl, ll, el, q );
279 e = d; //ring.random(kl, ll, el, q );
280
281 if ( a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO() ) {
282 return;
283 }
284
285 assertTrue("not isZERO( a )", !a.isZERO() );
286
287 L = new ArrayList<GenSolvablePolynomial<BigRational>>();
288 L.add(a);
289
290 //System.out.println("La = " + L );
291 L = sbb.twosidedGB( L );
292 //System.out.println("L = " + L );
293 assertTrue("isTwosidedGB( { a } )", sbb.isTwosidedGB(L) );
294
295 assertTrue("not isZERO( b )", !b.isZERO() );
296 L.add(b);
297
298 L = sbb.twosidedGB( L );
299 //System.out.println("L = " + L );
300 assertTrue("isTwosidedGB( { a, b } )", sbb.isTwosidedGB(L) );
301
302 assertTrue("not isZERO( c )", !c.isZERO() );
303 L.add(c);
304
305 L = sbb.twosidedGB( L );
306 //System.out.println("L = " + L );
307 assertTrue("isTwosidedGB( { a, b, c } )", sbb.isTwosidedGB(L) );
308
309 assertTrue("not isZERO( d )", !d.isZERO() );
310 L.add(d);
311
312 L = sbb.twosidedGB( L );
313 //System.out.println("L = " + L );
314 assertTrue("isTwosidedGB( { a, b, c, d } )", sbb.isTwosidedGB(L) );
315
316 assertTrue("not isZERO( e )", !e.isZERO() );
317 L.add(e);
318
319 L = sbb.twosidedGB( L );
320 //System.out.println("L = " + L );
321 assertTrue("isTwosidedGB( { a, b, c, d, e } )", sbb.isTwosidedGB(L) );
322 }
323
324
325 /**
326 * Test sequential extended GBase.
327 *
328 */
329 public void testSequentialExtendedGBase() {
330
331 L = new ArrayList<GenSolvablePolynomial<BigRational>>();
332
333 SolvableExtendedGB<BigRational> exgb;
334
335 if ( a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO() ) {
336 return;
337 }
338
339 assertTrue("not isZERO( a )", !a.isZERO() );
340 L.add(a);
341 //System.out.println("L = " + L );
342
343 exgb = sbb.extLeftGB( L );
344 //System.out.println("exgb = " + exgb );
345 assertTrue("isLeftGB( { a } )", sbb.isLeftGB(exgb.G) );
346 assertTrue("isLeftRmat( { a } )", sbb.isLeftReductionMatrix(exgb) );
347
348 assertTrue("not isZERO( b )", !b.isZERO() );
349 L.add(b);
350 //System.out.println("L = " + L );
351
352 exgb = sbb.extLeftGB( L );
353 //System.out.println("exgb = " + exgb );
354 assertTrue("isLeftGB( { a, b } )", sbb.isLeftGB(exgb.G) );
355 assertTrue("isLeftRmat( { a, b } )", sbb.isLeftReductionMatrix(exgb) );
356
357 assertTrue("not isZERO( c )", !c.isZERO() );
358 L.add(c);
359
360 exgb = sbb.extLeftGB( L );
361 //System.out.println("exgb = " + exgb );
362 assertTrue("isLeftGB( { a, b, c } )", sbb.isLeftGB(exgb.G) );
363 assertTrue("isLeftRmat( { a, b, c } )", sbb.isLeftReductionMatrix(exgb) );
364
365 assertTrue("not isZERO( d )", !d.isZERO() );
366 L.add(d);
367
368 exgb = sbb.extLeftGB( L );
369 //System.out.println("exgb = " + exgb );
370 assertTrue("isLeftGB( { a, b, c, d } )", sbb.isLeftGB(exgb.G) );
371 assertTrue("isLeftRmat( { a, b, c, d } )", sbb.isLeftReductionMatrix(exgb) );
372
373
374 assertTrue("not isZERO( e )", !e.isZERO() );
375 L.add(e);
376
377 exgb = sbb.extLeftGB( L );
378 //System.out.println("exgb = " + exgb );
379 assertTrue("isLeftGB( { a, b, c, d, e } )", sbb.isLeftGB(exgb.G) );
380 assertTrue("isLeftRmat( { a, b, c, d, e } )", sbb.isLeftReductionMatrix(exgb) );
381 }
382
383
384 /**
385 * Test Weyl sequential extended GBase.
386 *
387 */
388 public void testWeylSequentialExtendedGBase() {
389
390 int rloc = 4;
391 ring = new GenSolvablePolynomialRing<BigRational>(cfac,rloc);
392
393 WeylRelations<BigRational> wl = new WeylRelations<BigRational>(ring);
394 wl.generate();
395 table = ring.table;
396
397 a = ring.random(kl, ll, el, q );
398 b = ring.random(kl, ll, el, q );
399 c = ring.random(kl, ll, el, q );
400 d = ring.random(kl, ll, el, q );
401 e = d; //ring.random(kl, ll, el, q );
402
403 SolvableExtendedGB<BigRational> exgb;
404
405 assertTrue("not isZERO( a )", !a.isZERO() );
406
407 L = new ArrayList<GenSolvablePolynomial<BigRational>>();
408 L.add(a);
409
410 exgb = sbb.extLeftGB( L );
411 // System.out.println("exgb = " + exgb );
412 assertTrue("isLeftGB( { a } )", sbb.isLeftGB(exgb.G) );
413 assertTrue("isRmat( { a } )", sbb.isLeftReductionMatrix(exgb) );
414
415 assertTrue("not isZERO( b )", !b.isZERO() );
416 L.add(b);
417 //System.out.println("L = " + L.size() );
418
419 exgb = sbb.extLeftGB( L );
420 //System.out.println("exgb = " + exgb );
421 assertTrue("isLeftGB( { a, b } )", sbb.isLeftGB(exgb.G) );
422 assertTrue("isRmat( { a, b } )", sbb.isLeftReductionMatrix(exgb) );
423
424 assertTrue("not isZERO( c )", !c.isZERO() );
425 L.add(c);
426
427 exgb = sbb.extLeftGB( L );
428 //System.out.println("exgb = " + exgb );
429 assertTrue("isLeftGB( { a, b, c } )", sbb.isLeftGB(exgb.G) );
430 assertTrue("isRmat( { a, b, c } )", sbb.isLeftReductionMatrix(exgb) );
431
432 assertTrue("not isZERO( d )", !d.isZERO() );
433 L.add(d);
434
435 exgb = sbb.extLeftGB( L );
436 //System.out.println("exgb = " + exgb );
437 assertTrue("isLeftGB( { a, b, c, d } )", sbb.isLeftGB(exgb.G) );
438 assertTrue("isRmat( { a, b, c, d } )", sbb.isLeftReductionMatrix(exgb) );
439
440 assertTrue("not isZERO( e )", !e.isZERO() );
441 L.add(e);
442
443 exgb = sbb.extLeftGB( L );
444 //System.out.println("exgb = " + exgb );
445 assertTrue("isLeftGB( { a, b, c, d, e } )", sbb.isLeftGB(exgb.G) );
446 assertTrue("isRmat( { a, b, c, d, e } )", sbb.isLeftReductionMatrix(exgb) );
447 }
448
449 }