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}