Source code

001/*
002 * $Id: GenSolvablePolynomialTest.java 5863 2018-07-20 11:13:34Z kredel $
003 */
004
005package edu.jas.poly;
006
007import java.util.Map;
008import java.util.List;
009import java.util.ArrayList;
010
011import junit.framework.Test;
012import junit.framework.TestCase;
013import junit.framework.TestSuite;
014
015
016import edu.jas.arith.BigRational;
017import edu.jas.poly.GenSolvablePolynomial;
018import edu.jas.poly.GenSolvablePolynomialRing;
019import edu.jas.structure.RingElem;
020//import edu.jas.structure.RingFactory;
021
022
023/**
024 * GenSolvablePolynomial Test using JUnit.
025 * <b>Note:</b> not optimal since GenSolvablePolynomial does not 
026 * implement RingElem&lt;GenSolvablePolynomial&gt;
027 * @author Heinz Kredel
028 */
029
030public class GenSolvablePolynomialTest extends TestCase {
031
032    /**
033     * main
034     */
035    public static void main (String[] args) {
036        junit.textui.TestRunner.run( suite() );
037    }
038
039    /**
040     * Constructs a <CODE>GenSolvablePolynomialTest</CODE> object.
041     * @param name String.
042     */
043    public GenSolvablePolynomialTest(String name) {
044        super(name);
045    }
046
047    /**
048     * suite.
049     */ 
050    public static Test suite() {
051        TestSuite suite= new TestSuite(GenSolvablePolynomialTest.class);
052        return suite;
053    }
054
055    //private final static int bitlen = 100;
056
057    int rl = 6;  // even for Weyl 
058    int kl = 10;
059    int ll = 7;
060    int el = 4;
061    float q = 0.5f;
062
063    protected void setUp() {
064        // a = b = c = d = e = null;
065    }
066
067    protected void tearDown() {
068        // a = b = c = d = e = null;
069    }
070
071
072    /**
073     * Test constructors and factory.
074     */
075    public void testConstructors() {
076        // rational numbers
077        BigRational rf = new BigRational();
078        // System.out.println("rf = " + rf);
079
080        //BigRational r = rf.fromInteger( 99 );
081        // System.out.println("r = " + r);
082        //r = rf.random( 9 );
083        // System.out.println("r = " + r);
084
085        // polynomials over rational numbers
086        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(rf,2);
087        // System.out.println("pf = " + pf);
088
089        GenSolvablePolynomial<BigRational> p = pf.getONE();
090        // System.out.println("p = " + p);
091        p = pf.random( 9 );
092        // System.out.println("p = " + p);
093        p = pf.getZERO();
094        // System.out.println("p = " + p);
095
096        RingElem< GenPolynomial<BigRational> > pe = new GenSolvablePolynomial<BigRational>( pf );
097        //System.out.println("pe = " + pe);
098        //System.out.println("p.equals(pe) = " + p.equals(pe) );
099        //System.out.println("p.equals(p) = " + p.equals(p) );
100        assertTrue("p.equals(pe) = ", p.equals(pe) );
101        assertTrue("p.equals(p) = ", p.equals(p) );
102
103        pe = pe.sum( p ); // why not p = p.add(pe) ?
104        //System.out.println("pe = " + pe);
105        assertTrue("pe.isZERO() = ", pe.isZERO());
106        p = pf.random( 9 );
107        p = (GenSolvablePolynomial<BigRational>)p.subtract( p ); 
108        //System.out.println("p = " + p);
109        //System.out.println("p.isZERO() = " + p.isZERO());
110        assertTrue("p.isZERO() = ", p.isZERO());
111
112
113        // polynomials over (polynomials over rational numbers)
114        GenSolvablePolynomialRing< GenPolynomial<BigRational> > ppf = new GenSolvablePolynomialRing< GenPolynomial<BigRational> >(pf,3);
115        // System.out.println("ppf = " + ppf);
116
117        GenSolvablePolynomial< GenPolynomial<BigRational> > pp = ppf.getONE();
118        // System.out.println("pp = " + pp);
119        pp = ppf.random( 2 );
120        // System.out.println("pp = " + pp);
121        pp = ppf.getZERO();
122        // System.out.println("pp = " + pp);
123
124        RingElem< GenPolynomial< GenPolynomial<BigRational> > > ppe = new GenSolvablePolynomial< GenPolynomial<BigRational> >( ppf );
125        // System.out.println("ppe = " + ppe);
126        // System.out.println("pp.equals(ppe) = " + pp.equals(ppe) );
127        // System.out.println("pp.equals(pp) = " + pp.equals(pp) );
128        assertTrue("pp.equals(ppe) = ", pp.equals(ppe) );
129        assertTrue("pp.equals(pp) = ", pp.equals(pp) );
130
131        ppe = ppe.sum( pp ); // why not pp = pp.add(ppe) ?
132        //System.out.println("ppe = " + ppe);
133        assertTrue("ppe.isZERO() = ", ppe.isZERO());
134        pp = ppf.random( 2 );
135        pp = (GenSolvablePolynomial< GenPolynomial<BigRational>>)pp.subtract( pp ); 
136        //System.out.println("pp = " + pp);
137        //System.out.println("pp.isZERO() = " + pp.isZERO());
138        assertTrue("pp.isZERO() = ", pp.isZERO());
139
140
141        // polynomials over (polynomials over (polynomials over rational numbers))
142        GenSolvablePolynomialRing< GenPolynomial< GenPolynomial<BigRational> > > pppf = new GenSolvablePolynomialRing< GenPolynomial< GenPolynomial<BigRational> > >(ppf,4);
143        // System.out.println("pppf = " + pppf);
144
145        GenSolvablePolynomial< GenPolynomial< GenPolynomial<BigRational> > > ppp = pppf.getONE();
146        //System.out.println("ppp = " + ppp);
147        ppp = pppf.random( 2 );
148        // System.out.println("ppp = " + ppp);
149        ppp = pppf.getZERO();
150        // System.out.println("ppp = " + ppp);
151
152        RingElem< GenPolynomial< GenPolynomial< GenPolynomial<BigRational> > > > pppe = new GenSolvablePolynomial< GenPolynomial< GenPolynomial<BigRational> > >( pppf );
153        // System.out.println("pppe = " + pppe);
154        // System.out.println("ppp.equals(pppe) = " + ppp.equals(pppe) );
155        // System.out.println("ppp.equals(ppp) = " + ppp.equals(ppp) );
156        assertTrue("ppp.equals(pppe) = ", ppp.equals(pppe) );
157        assertTrue("ppp.equals(ppp) = ", ppp.equals(ppp) );
158
159        pppe = pppe.sum( ppp ); // why not ppp = ppp.add(pppe) ?
160        // System.out.println("pppe = " + pppe);
161        assertTrue("pppe.isZERO() = ", pppe.isZERO());
162        ppp = pppf.random( 2 );
163        ppp = (GenSolvablePolynomial<GenPolynomial<GenPolynomial<BigRational>>>)ppp.subtract( ppp ); 
164        // System.out.println("ppp = " + ppp);
165        // System.out.println("ppp.isZERO() = " + ppp.isZERO());
166        assertTrue("ppp.isZERO() = ", ppp.isZERO());
167    }
168
169
170    /**
171     * Test extension and contraction.
172     */
173    public void testExtendContract() {
174        // rational numbers
175        BigRational cf = new BigRational( 99 );
176        // System.out.println("cf = " + cf);
177
178        // polynomials over rational numbers
179        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(cf,rl);
180        // System.out.println("pf = " + pf);
181
182        GenSolvablePolynomial<BigRational> a = pf.random(kl,ll,el,q);
183        //System.out.println("a = " + a);
184
185        int k = rl;
186        GenSolvablePolynomialRing<BigRational> pfe = pf.extend(k);
187        GenSolvablePolynomialRing<BigRational> pfec = pfe.contract(k);
188        assertEquals("pf == pfec",pf,pfec);
189
190        GenSolvablePolynomial<BigRational> ae 
191            = (GenSolvablePolynomial<BigRational>)a.extend(pfe,0,0);
192
193        Map<ExpVector,GenPolynomial<BigRational>> m = ae.contract(pfec);
194        List<GenPolynomial<BigRational>> ml = new ArrayList<GenPolynomial<BigRational>>( m.values() );
195        GenSolvablePolynomial<BigRational> aec = (GenSolvablePolynomial<BigRational>)ml.get(0);
196        assertEquals("a == aec",a,aec);
197        //System.out.println("ae = " + ae);
198        //System.out.println("aec = " + aec);
199    }
200
201
202    /**
203     * Test extension and contraction for Weyl relations.
204     */
205    public void testExtendContractWeyl() {
206        // rational numbers
207        BigRational cf = new BigRational( 99 );
208        // System.out.println("cf = " + cf);
209
210        // polynomials over rational numbers
211        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(cf,rl);
212        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
213        //wl.generate(pf);
214        pf.addRelations(wl);
215        // System.out.println("pf = " + pf);
216
217        GenSolvablePolynomial<BigRational> a = pf.random(kl,ll,el,q);
218        //System.out.println("a = " + a);
219
220        int k = rl;
221        GenSolvablePolynomialRing<BigRational> pfe = pf.extend(k);
222        GenSolvablePolynomialRing<BigRational> pfec = pfe.contract(k);
223        assertEquals("pf == pfec",pf,pfec);
224
225        GenSolvablePolynomial<BigRational> ae 
226            = (GenSolvablePolynomial<BigRational>)a.extend(pfe,0,0);
227
228        Map<ExpVector,GenPolynomial<BigRational>> m = ae.contract(pfec);
229        List<GenPolynomial<BigRational>> ml = new ArrayList<GenPolynomial<BigRational>>( m.values() );
230        GenSolvablePolynomial<BigRational> aec = (GenSolvablePolynomial<BigRational>)ml.get(0);
231        assertEquals("a == aec",a,aec);
232        //System.out.println("ae = " + ae);
233        //System.out.println("aec = " + aec);
234    }
235
236
237    /**
238     * Test reversion.
239     */
240    public void testReverse() {
241        // rational numbers
242        BigRational cf = new BigRational( 99 );
243        // System.out.println("cf = " + cf);
244
245        // polynomials over rational numbers
246        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(cf,rl);
247        //System.out.println("pf = " + pf);
248
249        GenSolvablePolynomial<BigRational> a = pf.random(kl,ll,el,q);
250        //System.out.println("a = " + a);
251
252        GenSolvablePolynomialRing<BigRational> pfr = pf.reverse();
253        GenSolvablePolynomialRing<BigRational> pfrr = pfr.reverse();
254        assertEquals("pf == pfrr",pf,pfrr);
255        //System.out.println("pfr = " + pfr);
256
257        GenSolvablePolynomial<BigRational> ar 
258            = (GenSolvablePolynomial<BigRational>)a.reverse(pfr);
259        GenSolvablePolynomial<BigRational> arr 
260            = (GenSolvablePolynomial<BigRational>)ar.reverse(pfrr);
261        assertEquals("a == arr",a,arr);
262        //System.out.println("ar = " + ar);
263        //System.out.println("arr = " + arr);
264    }
265
266
267    /**
268     * Test reversion for Weyl relations.
269     * 
270     */
271    public void testReverseWeyl() {
272        // rational numbers
273        BigRational cf = new BigRational( 99 );
274        // System.out.println("cf = " + cf);
275
276        // polynomials over rational numbers
277        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(cf,rl);
278        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
279        wl.generate(pf);
280        //System.out.println("pf = " + pf);
281
282        GenSolvablePolynomial<BigRational> a = pf.random(kl,ll,el,q);
283        //System.out.println("a = " + a);
284
285        GenSolvablePolynomialRing<BigRational> pfr = pf.reverse();
286        GenSolvablePolynomialRing<BigRational> pfrr = pfr.reverse();
287        assertEquals("pf == pfrr",pf,pfrr);
288        //System.out.println("pfr = " + pfr);
289
290        GenSolvablePolynomial<BigRational> ar 
291            = (GenSolvablePolynomial<BigRational>)a.reverse(pfr);
292        GenSolvablePolynomial<BigRational> arr 
293            = (GenSolvablePolynomial<BigRational>)ar.reverse(pfrr);
294        assertEquals("a == arr",a,arr);
295        //System.out.println("ar = " + ar);
296        //System.out.println("arr = " + arr);
297    }
298
299
300    /**
301     * Test recursion.
302     */
303    public void testRecursion() {
304        // rational numbers
305        BigRational rf = new BigRational();
306        // System.out.println("rf = " + rf);
307
308        String[] vars = new String[] { "a", "b", "c", "d" };
309        TermOrder to = new TermOrder(TermOrder.INVLEX);
310        // polynomials over rational numbers
311        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(rf,4,to,vars);
312        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
313        //wl.generate(pf);
314        pf.addRelations(wl);
315        //System.out.println("pf = " + pf);
316
317        GenSolvablePolynomial<BigRational> sp = pf.random(5);
318        //System.out.println("sp = " + sp);
319        sp = (GenSolvablePolynomial<BigRational>) sp.subtract(sp);
320        assertTrue("sp == 0 ",sp.isZERO());
321  
322        // polynomials over (solvable) polynomials over rational numbers
323        GenSolvablePolynomialRing<GenPolynomial<BigRational>> rpf 
324            = new GenSolvablePolynomialRing<GenPolynomial<BigRational>>(pf,2);
325        RelationGenerator<GenPolynomial<BigRational>> rwl = new WeylRelations<GenPolynomial<BigRational>>();
326        //rwl.generate(rpf);
327        rpf.addRelations(rwl);
328        //System.out.println("rpf = " + rpf);
329
330        GenSolvablePolynomial<GenPolynomial<BigRational>> rsp = rpf.random(5);
331        //System.out.println("rsp = " + rsp);
332        rsp = (GenSolvablePolynomial<GenPolynomial<BigRational>>) rsp.subtract(rsp);
333        assertTrue("rsp == 0 ",rsp.isZERO());
334    }
335
336}