Source code

001/*
002 * $Id: GenSolvablePolynomialTest.java 4142 2012-08-26 13:30:59Z 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        WeylRelations<BigRational> wl = new WeylRelations<BigRational>(pf);
215        wl.generate();
216        // System.out.println("pf = " + pf);
217
218        GenSolvablePolynomial<BigRational> a = pf.random(kl,ll,el,q);
219        //System.out.println("a = " + a);
220
221        int k = rl;
222        GenSolvablePolynomialRing<BigRational> pfe = pf.extend(k);
223        GenSolvablePolynomialRing<BigRational> pfec = pfe.contract(k);
224        assertEquals("pf == pfec",pf,pfec);
225
226        GenSolvablePolynomial<BigRational> ae 
227            = (GenSolvablePolynomial<BigRational>)a.extend(pfe,0,0);
228
229        Map<ExpVector,GenPolynomial<BigRational>> m = ae.contract(pfec);
230        List<GenPolynomial<BigRational>> ml = new ArrayList<GenPolynomial<BigRational>>( m.values() );
231        GenSolvablePolynomial<BigRational> aec = (GenSolvablePolynomial<BigRational>)ml.get(0);
232        assertEquals("a == aec",a,aec);
233        //System.out.println("ae = " + ae);
234        //System.out.println("aec = " + aec);
235    }
236
237
238    /**
239     * Test reversion.
240     */
241    public void testReverse() {
242        // rational numbers
243        BigRational cf = new BigRational( 99 );
244        // System.out.println("cf = " + cf);
245
246        // polynomials over rational numbers
247        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(cf,rl);
248        //System.out.println("pf = " + pf);
249
250        GenSolvablePolynomial<BigRational> a = pf.random(kl,ll,el,q);
251        //System.out.println("a = " + a);
252
253        GenSolvablePolynomialRing<BigRational> pfr = pf.reverse();
254        GenSolvablePolynomialRing<BigRational> pfrr = pfr.reverse();
255        assertEquals("pf == pfrr",pf,pfrr);
256        //System.out.println("pfr = " + pfr);
257
258        GenSolvablePolynomial<BigRational> ar 
259            = (GenSolvablePolynomial<BigRational>)a.reverse(pfr);
260        GenSolvablePolynomial<BigRational> arr 
261            = (GenSolvablePolynomial<BigRational>)ar.reverse(pfrr);
262        assertEquals("a == arr",a,arr);
263        //System.out.println("ar = " + ar);
264        //System.out.println("arr = " + arr);
265    }
266
267
268    /**
269     * Test reversion for Weyl relations.
270     * 
271     */
272    public void testReverseWeyl() {
273        // rational numbers
274        BigRational cf = new BigRational( 99 );
275        // System.out.println("cf = " + cf);
276
277        // polynomials over rational numbers
278        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(cf,rl);
279        WeylRelations<BigRational> wl = new WeylRelations<BigRational>(pf);
280        wl.generate();
281        //System.out.println("pf = " + pf);
282
283        GenSolvablePolynomial<BigRational> a = pf.random(kl,ll,el,q);
284        //System.out.println("a = " + a);
285
286        GenSolvablePolynomialRing<BigRational> pfr = pf.reverse();
287        GenSolvablePolynomialRing<BigRational> pfrr = pfr.reverse();
288        assertEquals("pf == pfrr",pf,pfrr);
289        //System.out.println("pfr = " + pfr);
290
291        GenSolvablePolynomial<BigRational> ar 
292            = (GenSolvablePolynomial<BigRational>)a.reverse(pfr);
293        GenSolvablePolynomial<BigRational> arr 
294            = (GenSolvablePolynomial<BigRational>)ar.reverse(pfrr);
295        assertEquals("a == arr",a,arr);
296        //System.out.println("ar = " + ar);
297        //System.out.println("arr = " + arr);
298    }
299
300
301    /**
302     * Test recursion.
303     */
304    public void testRecursion() {
305        // rational numbers
306        BigRational rf = new BigRational();
307        // System.out.println("rf = " + rf);
308
309        String[] vars = new String[] { "a", "b", "c", "d" };
310        TermOrder to = new TermOrder(TermOrder.INVLEX);
311        // polynomials over rational numbers
312        GenSolvablePolynomialRing<BigRational> pf = new GenSolvablePolynomialRing<BigRational>(rf,4,to,vars);
313        WeylRelations<BigRational> wl = new WeylRelations<BigRational>(pf);
314        wl.generate();
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        WeylRelations<GenPolynomial<BigRational>> rwl = new WeylRelations<GenPolynomial<BigRational>>(rpf);
326        rwl.generate();
327        //System.out.println("rpf = " + rpf);
328
329        GenSolvablePolynomial<GenPolynomial<BigRational>> rsp = rpf.random(5);
330        //System.out.println("rsp = " + rsp);
331        rsp = (GenSolvablePolynomial<GenPolynomial<BigRational>>) rsp.subtract(rsp);
332        assertTrue("rsp == 0 ",rsp.isZERO());
333    }
334
335}