Source code

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