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. 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.derivative(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> baseDerivative(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.derivative(a); 199 //System.out.println("b = " + b); 200 201 GenPolynomial<BigRational> pp = PolyUtil.<BigRational> baseDerivative(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.derivative(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.derivative(a); 257 //System.out.println("b = " + b); 258 259 GenPolynomial<BigRational> pp = PolyUtil.<BigRational> baseDerivative(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.derivative(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}