Source code

001/*
002 * $Id: ElementaryIntegrationTest.java 4512 2013-07-26 10:23:37Z axelclk $
003 */
004
005package edu.jas.integrate;
006
007
008import junit.framework.Test;
009import junit.framework.TestCase;
010import junit.framework.TestSuite;
011
012import org.apache.log4j.BasicConfigurator;
013//import org.apache.log4j.Logger;
014
015import edu.jas.arith.BigRational;
016import edu.jas.poly.GenPolynomial;
017import edu.jas.poly.GenPolynomialRing;
018import edu.jas.poly.TermOrder;
019import edu.jas.poly.PolyUtil;
020import edu.jas.ufd.Quotient;
021import edu.jas.ufd.QuotientRing;
022
023import edu.jas.kern.ComputerThreads;
024
025
026/**
027 * Quotient over BigRational GenPolynomial tests with JUnit. 
028 * @author Heinz Kredel.
029 */
030
031public class ElementaryIntegrationTest 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>ElementaryIntegrationTest</CODE> object.
043     * @param name String.
044     */
045    public ElementaryIntegrationTest(String name) {
046        super(name);
047    }
048
049    /**
050     * suite.
051     */ 
052    public static Test suite() {
053        TestSuite suite= new TestSuite(ElementaryIntegrationTest.class);
054        return suite;
055    }
056
057    //private final static int bitlen = 100;
058
059    TermOrder tord;
060    QuotientRing<BigRational> qfac;
061    GenPolynomialRing<BigRational> mfac;
062    ElementaryIntegration<BigRational> integrator;
063    QuotIntegral<BigRational> rint;
064
065    Quotient< BigRational > a;
066    Quotient< BigRational > b;
067    Quotient< BigRational > c;
068    Quotient< BigRational > d;
069    Quotient< BigRational > e;
070
071    int rl = 1; // only univariate polynomials
072    int kl = 5;
073    int ll = 3; //6;
074    int el = 4;
075    float q = 0.4f;
076
077    protected void setUp() {
078        a = b = c = d = e = null;
079        tord = new TermOrder( TermOrder.INVLEX );
080        BigRational br = new BigRational(1);
081        String[] vars = new String[]{ "x" };
082        mfac = new GenPolynomialRing<BigRational>( br, rl, tord, vars );
083        qfac = new QuotientRing<BigRational>( mfac );
084        integrator = new ElementaryIntegration<BigRational>(br);
085    }
086
087    protected void tearDown() {
088        a = b = c = d = e = null;
089        //qfac.terminate();
090        qfac = null;
091        ComputerThreads.terminate();
092    }
093
094
095    /**
096     * Test rational integral.
097     */
098    public void testRational() {
099        for (int i = 0; i < 3; i++) {
100            a = qfac.random(kl, ll+2*i, el+i, q );
101            //System.out.println("a = " + a);
102//             if ( a.isZERO() || a.isONE() ) {
103//                 continue;
104//             }
105            b = integrator.deriviative(a);
106            //System.out.println("b =  " + b);
107            rint = integrator.integrate(b);
108            //System.out.println("QuotIntegral: " + rint);
109
110            assertTrue("isIntegral ", integrator.isIntegral(rint));
111        }
112    }
113
114
115    /**
116     * Test 1/p pure logarithm integral.
117     */
118    public void testPureLogarithm1() {
119        for (int i = 0; i < 3; i++) {
120            a = qfac.random(kl, ll+i, el+i, q );
121            //System.out.println("a = " + a);
122//             if ( a.isZERO() || a.isONE() ) {
123//                 continue;
124//             }
125            b = new Quotient<BigRational>(qfac,qfac.getONE().num,a.den);
126            //System.out.println("b =  " + b);
127            rint = integrator.integrate(b);
128            //System.out.println("QuotIntegral: " + rint);
129
130            assertTrue("isIntegral ", integrator.isIntegral(rint));
131        }
132    }
133
134
135    /**
136     * Test p'/p pure logarithm integral.
137     * 
138     */
139    public void testPureLogarithmD() {
140        for (int i = 0; i < 3; i++) {
141            a = qfac.random(kl, ll+i, el+i, q );
142            //System.out.println("a = " + a);
143//             if ( a.isZERO() || a.isONE() ) {
144//                 continue;
145//             }
146            GenPolynomial<BigRational> pp = PolyUtil.<BigRational> baseDeriviative(a.den);
147            b = new Quotient<BigRational>(qfac, pp ,a.den);
148            //System.out.println("b =  " + b);
149            rint = integrator.integrate(b);
150            //System.out.println("QuotIntegral: " + rint);
151
152            assertTrue("isIntegral ", integrator.isIntegral(rint));
153        }
154    }
155
156
157    /**
158     * Test mixed rational with p'/p logarithm integral.
159     */
160    public void testRationalWithLogarithmD() {
161        for (int i = 0; i < 3; i++) {
162            a = qfac.random(kl, ll+i, el+i, q );
163            //System.out.println("a = " + a);
164//             if ( a.isZERO() || a.isONE() ) {
165//                 continue;
166//             }
167
168            b = integrator.deriviative(a);
169            //System.out.println("b =  " + b);
170
171            GenPolynomial<BigRational> pp = PolyUtil.<BigRational> baseDeriviative(a.den);
172            c = new Quotient<BigRational>(qfac, pp ,a.den);
173            //System.out.println("c =  " + c);
174
175            e = b.sum(c); 
176            //System.out.println("e =  " + e);
177
178            rint = integrator.integrate(e);
179            //System.out.println("QuotIntegral: " + rint);
180
181            assertTrue("isIntegral ", integrator.isIntegral(rint));
182        }
183    }
184
185
186    /**
187     * Test mixed rational with 1/p logarithm integral.
188     */
189    public void xtestRationalWithLogarithm1() {
190        for (int i = 0; i < 3; i++) {
191            a = qfac.random(kl, ll+i, el+i, q );
192            //System.out.println("a = " + a);
193//             if ( a.isZERO() || a.isONE() ) {
194//                 continue;
195//             }
196
197            b = integrator.deriviative(a);
198            //System.out.println("b =  " + b);
199
200            d = new Quotient<BigRational>(qfac,qfac.getONE().num,a.den);
201            //System.out.println("d =  " + d);
202
203            e = b.sum(d);
204            //System.out.println("e =  " + e);
205
206            rint = integrator.integrate(e);
207            //System.out.println("QuotIntegral: " + rint);
208
209            assertTrue("isIntegral ", integrator.isIntegral(rint));
210        }
211    }
212
213
214    /**
215     * Test mixed rational with p'/p + 1/p logarithm integral.
216     * 
217     */
218    public void testRationalWithLogarithm() {
219        for (int i = 0; i < 3; i++) {
220            a = qfac.random(kl, ll+i, el+i, q );
221            //System.out.println("a = " + a);
222//             if ( a.isZERO() || a.isONE() ) {
223//                 continue;
224//             }
225
226            b = integrator.deriviative(a);
227            //System.out.println("b =  " + b);
228
229            GenPolynomial<BigRational> pp = PolyUtil.<BigRational> baseDeriviative(a.den);
230            c = new Quotient<BigRational>(qfac, pp ,a.den);
231            //System.out.println("c =  " + c);
232
233            d = new Quotient<BigRational>(qfac,qfac.getONE().num,a.den);
234            //System.out.println("d =  " + d);
235
236            e = b.sum(c).sum(d);
237            //System.out.println("e =  " + e);
238
239            rint = integrator.integrate(e);
240            //System.out.println("QuotIntegral: " + rint);
241
242            assertTrue("isIntegral ", integrator.isIntegral(rint));
243        }
244    }
245
246
247    /**
248     * Test rational integral with quotient coefficients.
249     */
250    public void testRationalRecursive() {
251        QuotientRing<Quotient<BigRational>> qqfac;
252        GenPolynomialRing<Quotient<BigRational>> qmfac;
253        ElementaryIntegration<Quotient<BigRational>> qintegrator;
254        QuotIntegral<Quotient<BigRational>> qrint;
255        String[] vars = new String[]{ "y" };
256
257        qmfac = new GenPolynomialRing<Quotient<BigRational>>(qfac,1,tord,vars);
258        qqfac = new QuotientRing<Quotient<BigRational>>(qmfac);
259
260        qintegrator = new ElementaryIntegration<Quotient<BigRational>>(qfac);
261
262        Quotient< Quotient< BigRational > > qa, qb;
263
264        for (int i = 0; i < 2; i++) {
265            qa = qqfac.random(2, ll, el, q );
266            //System.out.println("qa = " + qa);
267            //             if ( a.isZERO() || a.isONE() ) {
268            //                 continue;
269            //             }
270            qb = qintegrator.deriviative(qa);
271            //System.out.println("qb =  " + qb);
272            qrint = qintegrator.integrate(qb);
273            //System.out.println("QuotIntegral: " + qrint);
274
275            assertTrue("isIntegral ", qintegrator.isIntegral(qrint));
276        }
277    }
278
279
280    /**
281     * Test mixed rational integral.
282     */
283    public void testMixedRational() {
284        //integrate( (3*x^16-19*x^15+43*x^14-20*x^13-91*x^12+183*x^11-81*x^10-166*x^9+271*x^8-101*x^7-127*x^6+168*x^5-53*x^4-31*x^3+41*x^2-2*x-2)/(4*x^14-20*x^13+28*x^12+24*x^11-108*x^10+84*x^9+76*x^8-176*x^7+76*x^6+84*x^5-108*x^4+24*x^3+28*x^2-20*x+4), x)
285
286        BigRational br = new BigRational(1);
287        String[] vars = new String[]{ "x" };
288        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(br,vars);
289        QuotientRing<BigRational> qfac = new QuotientRing<BigRational>(pfac);
290        GenPolynomial<BigRational> n = pfac.parse("(3*x^16-19*x^15+43*x^14-20*x^13-91*x^12+183*x^11-81*x^10-166*x^9+271*x^8-101*x^7-127*x^6+168*x^5-53*x^4-31*x^3+41*x^2-2*x-2)");
291        GenPolynomial<BigRational> d = pfac.parse("(4*x^14-20*x^13+28*x^12+24*x^11-108*x^10+84*x^9+76*x^8-176*x^7+76*x^6+84*x^5-108*x^4+24*x^3+28*x^2-20*x+4)");
292        //System.out.println("n = " + n);
293        //System.out.println("d = " + d);
294        Quotient<BigRational> a = new Quotient<BigRational>(qfac,n,d);
295        //System.out.println("a = " + a);
296
297        QuotIntegral<BigRational> rint = integrator.integrate(a);
298        //System.out.println("QuotIntegral: " + rint);
299        assertTrue("isIntegral ", integrator.isIntegral(rint));
300
301        Quotient<BigRational> b = qfac.parse("{ 3*x^16-19*x^15+43*x^14-20*x^13-91*x^12+183*x^11-81*x^10-166*x^9+271*x^8-101*x^7-127*x^6+168*x^5-53*x^4-31*x^3+41*x^2-2*x-2 | 4*x^14-20*x^13+28*x^12+24*x^11-108*x^10+84*x^9+76*x^8-176*x^7+76*x^6+84*x^5-108*x^4+24*x^3+28*x^2-20*x+4 }");
302        //System.out.println("b = " + b);
303        assertEquals("a == b: ", a, b);
304
305        rint = integrator.integrate(b);
306        //System.out.println("QuotIntegral: " + rint);
307        assertTrue("isIntegral ", integrator.isIntegral(rint));
308    }
309
310}