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