Source code

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