001/*
002 * $Id: ElementaryIntegrationCzichowskiTest.java 5863 2018-07-20 11:13:34Z kredel $
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    //private final static int bitlen = 100;
057
058    TermOrder tord;
059
060
061    QuotientRing<BigRational> qfac;
062
063
064    GenPolynomialRing<BigRational> mfac;
065
066
067    ElementaryIntegration<BigRational> integrator;
068
069
070    QuotIntegral<BigRational> rint;
071
072
073    Quotient<BigRational> a;
074
075
076    Quotient<BigRational> b;
077
078
079    Quotient<BigRational> c;
080
081
082    Quotient<BigRational> d;
083
084
085    Quotient<BigRational> e;
086
087
088    int rl = 1; // only univariate polynomials
089
090
091    int kl = 5;
092
093
094    int ll = 3; //6;
095
096
097    int el = 4;
098
099
100    float q = 0.4f;
101
102
103    @Override
104    protected void setUp() {
105        a = b = c = d = e = null;
106        tord = new TermOrder(TermOrder.INVLEX);
107        BigRational br = new BigRational(1);
108        String[] vars = new String[] { "x" };
109        mfac = new GenPolynomialRing<BigRational>(br, rl, tord, vars);
110        qfac = new QuotientRing<BigRational>(mfac);
111        integrator = new ElementaryIntegrationCzichowski<BigRational>(br);
112    }
113
114
115    @Override
116    protected void tearDown() {
117        a = b = c = d = e = null;
118        //qfac.terminate();
119        qfac = null;
120        ComputerThreads.terminate();
121    }
122
123
124    /**
125     * Test rational integral.
126     */
127    public void testRational() {
128        for (int i = 0; i < 3; i++) {
129            a = qfac.random(kl, ll + 2 * i, el + i, q);
130            //System.out.println("a = " + a);
131            //             if ( a.isZERO() || a.isONE() ) {
132            //                 continue;
133            //             }
134            b = integrator.deriviative(a);
135            //System.out.println("b =  " + b);
136            rint = integrator.integrate(b);
137            //System.out.println("QuotIntegral: " + rint);
138
139            assertTrue("isIntegral ", integrator.isIntegral(rint));
140        }
141    }
142
143
144    /**
145     * Test 1/p pure logarithm integral.
146     */
147    public void testPureLogarithm1() {
148        for (int i = 0; i < 3; i++) {
149            a = qfac.random(kl, ll + i, el + i, q);
150            //System.out.println("a = " + a);
151            //             if ( a.isZERO() || a.isONE() ) {
152            //                 continue;
153            //             }
154            b = new Quotient<BigRational>(qfac, qfac.getONE().num, a.den);
155            //System.out.println("b =  " + b);
156            rint = integrator.integrate(b);
157            //System.out.println("QuotIntegral: " + rint);
158
159            assertTrue("isIntegral ", integrator.isIntegral(rint));
160        }
161    }
162
163
164    /**
165     * Test p'/p pure logarithm integral.
166     * 
167     */
168    public void testPureLogarithmD() {
169        for (int i = 0; i < 3; i++) {
170            a = qfac.random(kl, ll + i, el + i, q);
171            //System.out.println("a = " + a);
172            //             if ( a.isZERO() || a.isONE() ) {
173            //                 continue;
174            //             }
175            GenPolynomial<BigRational> pp = PolyUtil.<BigRational> baseDeriviative(a.den);
176            b = new Quotient<BigRational>(qfac, pp, a.den);
177            //System.out.println("b =  " + b);
178            rint = integrator.integrate(b);
179            //System.out.println("QuotIntegral: " + rint);
180
181            assertTrue("isIntegral ", integrator.isIntegral(rint));
182        }
183    }
184
185
186    /**
187     * Test mixed rational with p'/p logarithm integral.
188     */
189    public void testRationalWithLogarithmD() {
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            GenPolynomial<BigRational> pp = PolyUtil.<BigRational> baseDeriviative(a.den);
201            c = new Quotient<BigRational>(qfac, pp, a.den);
202            //System.out.println("c =  " + c);
203
204            e = b.sum(c);
205            //System.out.println("e =  " + e);
206
207            rint = integrator.integrate(e);
208            //System.out.println("QuotIntegral: " + rint);
209
210            assertTrue("isIntegral ", integrator.isIntegral(rint));
211        }
212    }
213
214
215    /**
216     * Test mixed rational with 1/p logarithm integral.
217     */
218    public void xtestRationalWithLogarithm1() {
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            d = new Quotient<BigRational>(qfac, qfac.getONE().num, a.den);
230            //System.out.println("d =  " + d);
231
232            e = b.sum(d);
233            //System.out.println("e =  " + e);
234
235            rint = integrator.integrate(e);
236            //System.out.println("QuotIntegral: " + rint);
237
238            assertTrue("isIntegral ", integrator.isIntegral(rint));
239        }
240    }
241
242
243    /**
244     * Test mixed rational with p'/p + 1/p logarithm integral.
245     * 
246     */
247    public void testRationalWithLogarithm() {
248        for (int i = 0; i < 3; i++) {
249            a = qfac.random(kl, ll + i, el + i, q);
250            //System.out.println("a = " + a);
251            //             if ( a.isZERO() || a.isONE() ) {
252            //                 continue;
253            //             }
254
255            b = integrator.deriviative(a);
256            //System.out.println("b =  " + b);
257
258            GenPolynomial<BigRational> pp = PolyUtil.<BigRational> baseDeriviative(a.den);
259            c = new Quotient<BigRational>(qfac, pp, a.den);
260            //System.out.println("c =  " + c);
261
262            d = new Quotient<BigRational>(qfac, qfac.getONE().num, a.den);
263            //System.out.println("d =  " + d);
264
265            e = b.sum(c).sum(d);
266            //System.out.println("e =  " + e);
267
268            rint = integrator.integrate(e);
269            //System.out.println("QuotIntegral: " + rint);
270
271            assertTrue("isIntegral ", integrator.isIntegral(rint));
272        }
273    }
274
275
276    /**
277     * Test rational integral with quotient coefficients.
278     */
279    public void testRationalRecursive() {
280        QuotientRing<Quotient<BigRational>> qqfac;
281        GenPolynomialRing<Quotient<BigRational>> qmfac;
282        ElementaryIntegration<Quotient<BigRational>> qintegrator;
283        QuotIntegral<Quotient<BigRational>> qrint;
284        String[] vars = new String[] { "y" };
285
286        qmfac = new GenPolynomialRing<Quotient<BigRational>>(qfac, 1, tord, vars);
287        qqfac = new QuotientRing<Quotient<BigRational>>(qmfac);
288
289        qintegrator = new ElementaryIntegration<Quotient<BigRational>>(qfac);
290
291        Quotient<Quotient<BigRational>> qa, qb;
292
293        for (int i = 0; i < 2; i++) {
294            qa = qqfac.random(2, ll, el, q);
295            //System.out.println("qa = " + qa);
296            //             if ( a.isZERO() || a.isONE() ) {
297            //                 continue;
298            //             }
299            qb = qintegrator.deriviative(qa);
300            //System.out.println("qb =  " + qb);
301            qrint = qintegrator.integrate(qb);
302            //System.out.println("QuotIntegral: " + qrint);
303
304            assertTrue("isIntegral ", qintegrator.isIntegral(qrint));
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    }
341
342}