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