Source code

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