001/*
002 * $Id$
003 */
004
005package edu.jas.gbufd;
006
007
008import java.util.ArrayList;
009import java.util.List;
010
011import edu.jas.arith.BigInteger;
012import edu.jas.kern.ComputerThreads;
013import edu.jas.poly.GenSolvablePolynomial;
014import edu.jas.poly.GenSolvablePolynomialRing;
015import edu.jas.poly.PolynomialList;
016import edu.jas.poly.RelationGenerator;
017import edu.jas.poly.RelationTable;
018import edu.jas.poly.WeylRelations;
019import edu.jas.util.ListUtil;
020
021import junit.framework.Test;
022import junit.framework.TestCase;
023import junit.framework.TestSuite;
024
025
026/**
027 * Solvable Reduction tests with JUnit.
028 * @author Heinz Kredel
029 */
030
031public class SolvablePseudoReductionTest extends TestCase {
032
033
034    /**
035     * main
036     */
037    public static void main(String[] args) {
038        junit.textui.TestRunner.run(suite());
039        ComputerThreads.terminate();
040    }
041
042
043    /**
044     * Constructs a <CODE>SolvablePseudoReductionTest</CODE> object.
045     * @param name String.
046     */
047    public SolvablePseudoReductionTest(String name) {
048        super(name);
049    }
050
051
052    /**
053     * suite.
054     */
055    public static Test suite() {
056        TestSuite suite = new TestSuite(SolvablePseudoReductionTest.class);
057        return suite;
058    }
059
060
061    GenSolvablePolynomialRing<BigInteger> fac;
062
063
064    RelationTable table;
065
066
067    GenSolvablePolynomial<BigInteger> a, b, c, d, e, f, g, h;
068
069
070    List<GenSolvablePolynomial<BigInteger>> L;
071
072
073    PolynomialList<BigInteger> F, G;
074
075
076    SolvablePseudoReduction<BigInteger> sred;
077
078
079    //SolvablePseudoReduction<BigInteger> sredpar;
080
081
082    int rl = 4;
083
084
085    int kl = 10;
086
087
088    int ll = 5;
089
090
091    int el = 3;
092
093
094    float q = 0.4f;
095
096
097    @Override
098    protected void setUp() {
099        a = b = c = d = e = null;
100        String[] vars = new String[] { "w", "x", "y", "z" };
101        fac = new GenSolvablePolynomialRing<BigInteger>(new BigInteger(0), vars);
102        sred = new SolvablePseudoReductionSeq<BigInteger>();
103        //sredpar = new SolvablePseudoReductionPar<BigInteger>();
104    }
105
106
107    @Override
108    protected void tearDown() {
109        a = b = c = d = e = null;
110        fac = null;
111        sred = null;
112        //sredpar = null;
113    }
114
115
116    /**
117     * Test constants and empty list reduction.
118     */
119    public void testIntReduction0() {
120        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
121
122        a = fac.random(kl, ll, el, q);
123        c = fac.getONE();
124        d = fac.getZERO();
125
126        e = sred.leftNormalform(L, c);
127        assertTrue("isONE( e )", e.isONE());
128
129        e = sred.leftNormalform(L, d);
130        assertTrue("isZERO( e )", e.isZERO());
131
132
133        L.add(c);
134        e = sred.leftNormalform(L, c);
135        assertTrue("isZERO( e )", e.isZERO());
136
137        e = sred.leftNormalform(L, a);
138        assertTrue("isZERO( e )", e.isZERO());
139
140        e = sred.leftNormalform(L, d);
141        assertTrue("isZERO( e )", e.isZERO());
142
143
144        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
145        L.add(d);
146        e = sred.leftNormalform(L, c);
147        assertTrue("isONE( e )", e.isONE());
148
149        e = sred.leftNormalform(L, d);
150        assertTrue("isZERO( e )", e.isZERO());
151    }
152
153
154    /**
155     * Test constants and empty list reduction.
156     */
157    public void testWeylIntReduction0() {
158        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
159        RelationGenerator<BigInteger> wl = new WeylRelations<BigInteger>();
160        wl.generate(fac);
161
162        a = fac.random(kl, ll, el, q);
163        c = fac.getONE();
164        d = fac.getZERO();
165
166        e = sred.leftNormalform(L, c);
167        assertTrue("isONE( e )", e.isONE());
168
169        e = sred.leftNormalform(L, d);
170        assertTrue("isZERO( e )", e.isZERO());
171
172
173        L.add(c);
174        e = sred.leftNormalform(L, c);
175        assertTrue("isZERO( e )", e.isZERO());
176
177        e = sred.leftNormalform(L, a);
178        assertTrue("isZERO( e )", e.isZERO());
179
180        e = sred.leftNormalform(L, d);
181        assertTrue("isZERO( e )", e.isZERO());
182
183
184        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
185        L.add(d);
186        e = sred.leftNormalform(L, c);
187        assertTrue("isONE( e )", e.isONE());
188
189        e = sred.leftNormalform(L, d);
190        assertTrue("isZERO( e )", e.isZERO());
191    }
192
193
194    /**
195     * Test Int reduction.
196     */
197    public void testIntReduction() {
198        a = fac.random(kl, ll, el, q);
199        b = fac.random(kl, ll, el, q);
200
201        assertTrue("not isZERO( a )", !a.isZERO());
202
203        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
204        L.add(a);
205
206        e = sred.leftNormalform(L, a);
207        assertTrue("isZERO( e )", e.isZERO());
208
209        assertTrue("not isZERO( b )", !b.isZERO());
210
211        L.add(b);
212        e = sred.leftNormalform(L, a);
213        assertTrue("isZERO( e ) some times", e.isZERO());
214    }
215
216
217    /**
218     * Test Weyl Integer reduction.
219     */
220    public void testWeylIntReduction() {
221        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
222
223        RelationGenerator<BigInteger> wl = new WeylRelations<BigInteger>();
224        wl.generate(fac);
225
226        a = fac.random(kl, ll, el, q);
227        b = fac.random(kl, ll, el, q);
228
229        assertTrue("not isZERO( a )", !a.isZERO());
230
231        L.add(a);
232
233        e = sred.leftNormalform(L, a);
234        assertTrue("isZERO( e )", e.isZERO());
235
236        assertTrue("not isZERO( b )", !b.isZERO());
237
238        L.add(b);
239        e = sred.leftNormalform(L, a);
240        assertTrue("isZERO( e ) some times", e.isZERO());
241    }
242
243
244    /**
245     * Test Int reduction recording.
246     */
247    public void testIntReductionRecording() {
248        List<GenSolvablePolynomial<BigInteger>> row = null;
249        PseudoReductionEntry<BigInteger> mf;
250
251        a = fac.random(kl, ll, el, q);
252        b = fac.random(kl, ll, el, q);
253        c = fac.random(kl, ll, el, q);
254        d = fac.random(kl, ll, el, q);
255
256        assertTrue("not isZERO( a )", !a.isZERO());
257
258        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
259
260        L.add(a);
261        mf = sred.leftNormalformFactor(L, a);
262        f = a.multiply(mf.multiplicator);
263        row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO());
264        //d = sred.leftNormalform( row, L, a );
265        d = sred.leftNormalform(row, L, f);
266        assertTrue("isZERO( d )", d.isZERO());
267        assertTrue("is leftReduction ", sred.isLeftReductionNF(row, L, f, d));
268
269        L.add(b);
270        mf = sred.leftNormalformFactor(L, b);
271        f = b.multiply(mf.multiplicator);
272        row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO());
273        //e = sred.leftNormalform( row, L, b );
274        d = sred.leftNormalform(row, L, f);
275        assertTrue("is leftReduction ", sred.isLeftReductionNF(row, L, f, d));
276
277        L.add(c);
278        mf = sred.leftNormalformFactor(L, c);
279        f = c.multiply(mf.multiplicator);
280        row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO());
281        d = sred.leftNormalform(row, L, f);
282        assertTrue("is leftReduction ", sred.isLeftReductionNF(row, L, f, d));
283
284        L.add(d);
285        mf = sred.leftNormalformFactor(L, d);
286        f = d.multiply(mf.multiplicator);
287        row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO());
288        e = sred.leftNormalform(row, L, f);
289        assertTrue("is leftReduction ", sred.isLeftReductionNF(row, L, f, e));
290    }
291
292
293    /*
294     * Test Int reduction parallel.
295     public void testIntReductionPar() {
296     a = fac.random(kl, ll, el, q );
297     b = fac.random(kl, ll, el, q );
298
299     assertTrue("not isZERO( a )", !a.isZERO() );
300
301     L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
302     L.add(a);
303
304     e = sredpar.leftNormalform( L, a );
305     assertTrue("isZERO( e )", e.isZERO() );
306
307     assertTrue("not isZERO( b )", !b.isZERO() );
308
309     L.add(b);
310     e = sredpar.leftNormalform( L, a );
311     assertTrue("isZERO( e ) some times", e.isZERO() );
312     }
313    */
314
315
316    /*
317     * Test Weyl Integer reduction parallel.
318     public void testWeylIntReductionPar() {
319     L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
320
321     RelationGenerator<BigInteger> wl = new WeylRelations<BigInteger>();
322     wl.generate(fac);
323
324     a = fac.random(kl, ll, el, q );
325     b = fac.random(kl, ll, el, q );
326
327     assertTrue("not isZERO( a )", !a.isZERO() );
328
329     L.add(a);
330
331     e = sredpar.leftNormalform( L, a );
332     assertTrue("isZERO( e )", e.isZERO() );
333
334     assertTrue("not isZERO( b )", !b.isZERO() );
335
336     L.add(b);
337     e = sredpar.leftNormalform( L, a );
338     assertTrue("isZERO( e ) some times", e.isZERO() );
339     }
340    */
341
342
343    /**
344     * Right test constants and empty list reduction.
345     */
346    public void testIntRightReduction0() {
347        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
348
349        a = fac.random(kl, ll, el, q);
350        c = fac.getONE();
351        d = fac.getZERO();
352
353        e = sred.rightNormalform(L, c);
354        assertTrue("isONE( e )", e.isONE());
355
356        e = sred.rightNormalform(L, d);
357        assertTrue("isZERO( e )", e.isZERO());
358
359
360        L.add(c);
361        e = sred.rightNormalform(L, c);
362        assertTrue("isZERO( e )", e.isZERO());
363
364        e = sred.rightNormalform(L, a);
365        assertTrue("isZERO( e )", e.isZERO());
366
367        e = sred.rightNormalform(L, d);
368        assertTrue("isZERO( e )", e.isZERO());
369
370
371        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
372        L.add(d);
373        e = sred.rightNormalform(L, c);
374        assertTrue("isONE( e )", e.isONE());
375
376        e = sred.rightNormalform(L, d);
377        assertTrue("isZERO( e )", e.isZERO());
378    }
379
380
381    /**
382     * Right test constants and empty list reduction.
383     */
384    public void testWeylIntRightReduction0() {
385        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
386        RelationGenerator<BigInteger> wl = new WeylRelations<BigInteger>();
387        wl.generate(fac);
388
389        a = fac.random(kl, ll, el, q);
390        c = fac.getONE();
391        d = fac.getZERO();
392
393        e = sred.rightNormalform(L, c);
394        assertTrue("isONE( e )", e.isONE());
395
396        e = sred.rightNormalform(L, d);
397        assertTrue("isZERO( e )", e.isZERO());
398
399
400        L.add(c);
401        e = sred.rightNormalform(L, c);
402        assertTrue("isZERO( e )", e.isZERO());
403
404        e = sred.rightNormalform(L, a);
405        assertTrue("isZERO( e )", e.isZERO());
406
407        e = sred.rightNormalform(L, d);
408        assertTrue("isZERO( e )", e.isZERO());
409
410
411        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
412        L.add(d);
413        e = sred.rightNormalform(L, c);
414        assertTrue("isONE( e )", e.isONE());
415
416        e = sred.rightNormalform(L, d);
417        assertTrue("isZERO( e )", e.isZERO());
418    }
419
420
421    /**
422     * Right test Int reduction.
423     */
424    public void testIntRightReduction() {
425        a = fac.random(kl, ll, el, q);
426        b = fac.random(kl, ll, el, q);
427        assertTrue("not isZERO( a )", !a.isZERO());
428
429        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
430        L.add(a);
431
432        e = sred.rightNormalform(L, a);
433        assertTrue("isZERO( e )", e.isZERO());
434
435        assertTrue("not isZERO( b )", !b.isZERO());
436
437        L.add(b);
438        e = sred.rightNormalform(L, a);
439        assertTrue("isZERO( e ) some times", e.isZERO());
440    }
441
442
443    /**
444     * Right test Weyl Integer reduction.
445     */
446    public void testWeylIntRightReduction() {
447        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
448
449        RelationGenerator<BigInteger> wl = new WeylRelations<BigInteger>();
450        wl.generate(fac);
451
452        a = fac.random(kl, ll, el, q);
453        b = fac.random(kl, ll, el, q);
454
455        assertTrue("not isZERO( a )", !a.isZERO());
456
457        L.add(a);
458
459        e = sred.rightNormalform(L, a);
460        assertTrue("isZERO( e )", e.isZERO());
461
462        assertTrue("not isZERO( b )", !b.isZERO());
463
464        L.add(b);
465        e = sred.rightNormalform(L, a);
466        assertTrue("isZERO( e ) some times", e.isZERO());
467    }
468
469
470    /**
471     * Right test Int reduction recording.
472     */
473    public void testIntRightReductionRecording() {
474        List<GenSolvablePolynomial<BigInteger>> row = null;
475        PseudoReductionEntry<BigInteger> mf;
476
477        a = fac.random(kl, ll, el, q);
478        b = fac.random(kl, ll, el, q);
479        c = fac.random(kl, ll, el, q);
480        d = fac.random(kl, ll, el, q);
481
482        assertTrue("not isZERO( a )", !a.isZERO());
483
484        L = new ArrayList<GenSolvablePolynomial<BigInteger>>();
485
486        L.add(a);
487        mf = sred.rightNormalformFactor(L, a);
488        f = a.multiply(mf.multiplicator);
489        row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO());
490        //d = sred.rightNormalform( row, L, a );
491        d = sred.rightNormalform(row, L, f);
492        assertTrue("isZERO( d )", d.isZERO());
493        assertTrue("is rightReduction ", sred.isRightReductionNF(row, L, f, d));
494
495        L.add(b);
496        mf = sred.rightNormalformFactor(L, b);
497        f = b.multiply(mf.multiplicator);
498        row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO());
499        //e = sred.rightNormalform( row, L, b );
500        d = sred.rightNormalform(row, L, f);
501        assertTrue("is rightReduction ", sred.isRightReductionNF(row, L, f, d));
502
503        L.add(c);
504        mf = sred.rightNormalformFactor(L, c);
505        f = c.multiply(mf.multiplicator);
506        row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO());
507        d = sred.rightNormalform(row, L, f);
508        assertTrue("is rightReduction ", sred.isRightReductionNF(row, L, f, d));
509
510        L.add(d);
511        mf = sred.rightNormalformFactor(L, d);
512        f = d.multiply(mf.multiplicator);
513        row = ListUtil.<GenSolvablePolynomial<BigInteger>> fill(L.size(), fac.getZERO());
514        e = sred.rightNormalform(row, L, f);
515        assertTrue("is rightReduction ", sred.isRightReductionNF(row, L, f, e));
516    }
517
518}