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 ElementaryIntegrationCzichowskiTest 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>ElementaryIntegrationCzichowskiTest</CODE> object.
040     * @param name String.
041     */
042    public ElementaryIntegrationCzichowskiTest(String name) {
043        super(name);
044    }
045
046
047    /**
048     * suite.
049     */
050    public static Test suite() {
051        TestSuite suite = new TestSuite(ElementaryIntegrationCzichowskiTest.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 ElementaryIntegrationCzichowski<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     */
158    public void testPureLogarithmD() {
159        for (int i = 0; i < 3; i++) {
160            a = qfac.random(kl, ll + i, el + i, q);
161            //System.out.println("a = " + a);
162            //             if ( a.isZERO() || a.isONE() ) {
163            //                 continue;
164            //             }
165            GenPolynomial<BigRational> pp = PolyUtil.<BigRational> baseDerivative(a.den);
166            b = new Quotient<BigRational>(qfac, pp, a.den);
167            //System.out.println("b =  " + b);
168            rint = integrator.integrate(b);
169            //System.out.println("QuotIntegral: " + rint);
170
171            assertTrue("isIntegral ", integrator.isIntegral(rint));
172            assertFalse("rint not empty: " + rint, rint.toString().isEmpty());
173            assertTrue("rint contains: " + rint, rint.toString().indexOf("integral") >= 0);
174        }
175    }
176
177
178    /**
179     * Test mixed rational with p'/p logarithm integral.
180     */
181    public void testRationalWithLogarithmD() {
182        for (int i = 0; i < 3; i++) {
183            a = qfac.random(kl, ll + i, el + i, q);
184            //System.out.println("a = " + a);
185            //             if ( a.isZERO() || a.isONE() ) {
186            //                 continue;
187            //             }
188
189            b = integrator.derivative(a);
190            //System.out.println("b =  " + b);
191
192            GenPolynomial<BigRational> pp = PolyUtil.<BigRational> baseDerivative(a.den);
193            c = new Quotient<BigRational>(qfac, pp, a.den);
194            //System.out.println("c =  " + c);
195
196            e = b.sum(c);
197            //System.out.println("e =  " + e);
198
199            rint = integrator.integrate(e);
200            //System.out.println("QuotIntegral: " + rint);
201
202            assertTrue("isIntegral ", integrator.isIntegral(rint));
203            assertFalse("rint not empty: " + rint, rint.toString().isEmpty());
204            assertTrue("rint contains: " + rint, rint.toString().indexOf("integral") >= 0);
205        }
206    }
207
208
209    /**
210     * Test mixed rational with 1/p logarithm integral.
211     */
212    public void xtestRationalWithLogarithm1() {
213        for (int i = 0; i < 3; i++) {
214            a = qfac.random(kl, ll + i, el + i, q);
215            //System.out.println("a = " + a);
216            //             if ( a.isZERO() || a.isONE() ) {
217            //                 continue;
218            //             }
219
220            b = integrator.derivative(a);
221            //System.out.println("b =  " + b);
222
223            d = new Quotient<BigRational>(qfac, qfac.getONE().num, a.den);
224            //System.out.println("d =  " + d);
225
226            e = b.sum(d);
227            //System.out.println("e =  " + e);
228
229            rint = integrator.integrate(e);
230            //System.out.println("QuotIntegral: " + rint);
231
232            assertTrue("isIntegral ", integrator.isIntegral(rint));
233            assertFalse("rint not empty: " + rint, rint.toString().isEmpty());
234            assertTrue("rint contains: " + rint, rint.toString().indexOf("integral") >= 0);
235        }
236    }
237
238
239    /**
240     * Test mixed rational with p'/p + 1/p logarithm integral.
241     * 
242     */
243    public void testRationalWithLogarithm() {
244        for (int i = 0; i < 3; i++) {
245            a = qfac.random(kl, ll + i, el + i, q);
246            //System.out.println("a = " + a);
247            //             if ( a.isZERO() || a.isONE() ) {
248            //                 continue;
249            //             }
250
251            b = integrator.derivative(a);
252            //System.out.println("b =  " + b);
253
254            GenPolynomial<BigRational> pp = PolyUtil.<BigRational> baseDerivative(a.den);
255            c = new Quotient<BigRational>(qfac, pp, a.den);
256            //System.out.println("c =  " + c);
257
258            d = new Quotient<BigRational>(qfac, qfac.getONE().num, a.den);
259            //System.out.println("d =  " + d);
260
261            e = b.sum(c).sum(d);
262            //System.out.println("e =  " + e);
263
264            rint = integrator.integrate(e);
265            //System.out.println("QuotIntegral: " + rint);
266
267            assertTrue("isIntegral ", integrator.isIntegral(rint));
268            assertFalse("rint not empty: " + rint, rint.toString().isEmpty());
269            assertTrue("rint contains: " + rint, rint.toString().indexOf("integral") >= 0);
270        }
271    }
272
273
274    /**
275     * Test rational integral with quotient coefficients.
276     */
277    public void testRationalRecursive() {
278        QuotientRing<Quotient<BigRational>> qqfac;
279        GenPolynomialRing<Quotient<BigRational>> qmfac;
280        ElementaryIntegration<Quotient<BigRational>> qintegrator;
281        QuotIntegral<Quotient<BigRational>> qrint;
282        String[] vars = new String[] { "y" };
283
284        qmfac = new GenPolynomialRing<Quotient<BigRational>>(qfac, 1, tord, vars);
285        qqfac = new QuotientRing<Quotient<BigRational>>(qmfac);
286
287        qintegrator = new ElementaryIntegration<Quotient<BigRational>>(qfac);
288
289        Quotient<Quotient<BigRational>> qa, qb;
290
291        for (int i = 0; i < 2; i++) {
292            qa = qqfac.random(2, ll, el, q);
293            //System.out.println("qa = " + qa);
294            //             if ( a.isZERO() || a.isONE() ) {
295            //                 continue;
296            //             }
297            qb = qintegrator.derivative(qa);
298            //System.out.println("qb =  " + qb);
299            qrint = qintegrator.integrate(qb);
300            //System.out.println("QuotIntegral: " + qrint);
301
302            assertTrue("isIntegral ", qintegrator.isIntegral(qrint));
303            assertFalse("qrint not empty: " + qrint, qrint.toString().isEmpty());
304            assertTrue("qrint contains: " + qrint, qrint.toString().indexOf("integral") >= 0);
305        }
306    }
307
308
309    /**
310     * Test mixed rational integral.
311     */
312    public void testMixedRational() {
313        //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)
314
315        BigRational br = new BigRational(1);
316        String[] vars = new String[] { "x" };
317        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(br, vars);
318        QuotientRing<BigRational> qfac = new QuotientRing<BigRational>(pfac);
319        GenPolynomial<BigRational> n = pfac.parse(
320                        "(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)");
321        GenPolynomial<BigRational> d = pfac.parse(
322                        "(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)");
323        //System.out.println("n = " + n);
324        //System.out.println("d = " + d);
325        Quotient<BigRational> a = new Quotient<BigRational>(qfac, n, d);
326        //System.out.println("a = " + a);
327
328        QuotIntegral<BigRational> rint = integrator.integrate(a);
329        //System.out.println("QuotIntegral: " + rint);
330        assertTrue("isIntegral ", integrator.isIntegral(rint));
331
332        Quotient<BigRational> b = qfac.parse(
333                        "{ 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 }");
334        //System.out.println("b = " + b);
335        assertEquals("a == b: ", a, b);
336
337        rint = integrator.integrate(b);
338        //System.out.println("QuotIntegral: " + rint);
339        assertTrue("isIntegral ", integrator.isIntegral(rint));
340        assertFalse("rint not empty: " + rint, rint.toString().isEmpty());
341        assertTrue("rint contains: " + rint, rint.toString().indexOf("integral") >= 0);
342    }
343
344}