001/* 002 * $Id: GroebnerBaseFGLMExamples.java 4106 2012-08-18 10:41:52Z suess $ 003 */ 004 005package edu.jas.gbufd; 006 007 008import java.io.IOException; 009import java.io.Reader; 010import java.io.StringReader; 011import java.math.BigInteger; 012import java.util.Arrays; 013import java.util.Collections; 014import java.util.List; 015 016import junit.framework.Test; 017import junit.framework.TestCase; 018import junit.framework.TestSuite; 019 020import edu.jas.arith.BigRational; 021import edu.jas.arith.ModInteger; 022import edu.jas.arith.ModIntegerRing; 023import edu.jas.gb.GroebnerBase; 024import edu.jas.poly.ExpVector; 025import edu.jas.poly.GenPolynomial; 026import edu.jas.poly.GenPolynomialTokenizer; 027import edu.jas.poly.Monomial; 028import edu.jas.poly.OrderedPolynomialList; 029import edu.jas.poly.PolyUtil; 030import edu.jas.poly.PolynomialList; 031 032 033/** 034 * Groebner base FGLM examples with JUnit. 035 * @author Jan Suess. 036 */ 037 038public class GroebnerBaseFGLMExamples extends TestCase { 039 040 041 /** 042 * main 043 */ 044 public static void main(String[] args) { 045 //BasicConfigurator.configure(); 046 junit.textui.TestRunner.run(suite()); 047 } 048 049 050 /** 051 * Constructs a <CODE>GroebnerBaseFGLMExamples</CODE> object. 052 * @param name String. 053 */ 054 public GroebnerBaseFGLMExamples(String name) { 055 super(name); 056 } 057 058 059 /** 060 * suite. 061 */ 062 public static Test suite() { 063 TestSuite suite = new TestSuite(GroebnerBaseFGLMExamples.class); 064 return suite; 065 } 066 067 068 //field Q 069 String all = "Zahlbereich | Ordnung | Elements G | Elements L | bitHeight G | bitHeight L | Deg G | Deg L | Time G | Time FGLM | Time L"; 070 071 072 String grad = "Zahlbereich | Ordnung | Elements G | bitHeight G | Deg G | Time G | vDim"; 073 074 075 String lex = "Zahlbereich | Ordnung | Elements L | bitHeight L | Deg L | Time L"; 076 077 078 String fglm = "Zahlbereich | Ordnung | Elements G | Elements L | bitHeight G | bitHeight L | Deg G | Deg L | Time G | Time FGLM"; 079 080 081 //MOD 1831 082 String modAll = "Zahlbereich | Ordnung | Elements G | Elements L | Deg G | Deg L | Time G | Time FGLM | Time L"; 083 084 085 String modGrad = "Zahlbereich | Ordnung | Elements G | Deg G | Time G"; 086 087 088 String modfglm = "Zahlbereich | Ordnung | Elements G | Elements L | Deg G | Deg L | Time G | Time FGLM"; 089 090 091 @Override 092 protected void setUp() { 093 System.out.println("Setup"); 094 } 095 096 097 @Override 098 protected void tearDown() { 099 System.out.println("Tear Down"); 100 } 101 102 103 //Test with five variables and different variable orders 104 public void xtestFiveVarsOrder() { 105 String polynomials = "( " 106 + " (v^8*x*y*z), ( w^3*x - 2*v), ( 4*x*y - 2 + y), ( 3*y^5 - 3 + z ), ( 8*y^2*z^2 + x * y^6 )" 107 + ") "; 108 String[] order = new String[] { "v", "w", "x", "y", "z" }; 109 110 //String order1 = shuffle(order); 111 String order2 = shuffle(order); 112 //String order3 = shuffle(order); 113 //String order4 = shuffle(order); 114 //String order5 = shuffle(order); 115 //String order6 = "(z,w,v,y,x)"; //langsam 116 //String order7 = "(v,z,w,y,x)"; //langsam 117 //String order8 = "(w,z,v,x,y)"; //langsam 118 119 /* 120 String erg1 = testGeneral(order1, polynomials); 121 String erg2 = testGeneral(order2, polynomials); 122 String erg3 = testGeneral(order3, polynomials); 123 String erg4 = testGeneral(order4, polynomials); 124 String erg5 = testGeneral(order5, polynomials); 125 */ 126 String ergM13 = modAll(order2, polynomials, 13); 127 String ergM7 = modAll(order2, polynomials, 7); 128 129 /* 130 String ergOnlyL_1 = testOnlyLex(order1, polynomials); 131 String ergOnlyL_2 = testOnlyLex(order2, polynomials); 132 String ergOnlyL_3 = testOnlyLex(order3, polynomials); 133 String ergOnlyL_4 = testOnlyLex(order4, polynomials); 134 String ergOnlyL_5 = testOnlyLex(order5, polynomials); 135 String erg6 = testGeneral(order6, polynomials); 136 String erg7 = testGeneral(order7, polynomials); 137 String erg8 = testGeneral(order8, polynomials); 138 */ 139 //langsam: (z,w,v,y,x), (v,z,w,y,x) 140 /* 141 System.out.println(categoryLex); 142 System.out.println(ergOnlyL_1); 143 System.out.println(ergOnlyL_2); 144 System.out.println(ergOnlyL_3); 145 System.out.println(ergOnlyL_4); 146 System.out.println(ergOnlyL_5); 147 148 System.out.println(category); 149 System.out.println(erg6); 150 System.out.println(erg7); 151 System.out.println(erg8); 152 153 154 System.out.println(erg1); 155 System.out.println(erg2); 156 System.out.println(erg3); 157 System.out.println(erg4); 158 System.out.println(erg5); 159 */ 160 System.out.println(all); 161 System.out.println("Mod 13"); 162 System.out.println(ergM13); 163 System.out.println("Mod 7"); 164 System.out.println(ergM7); 165 } 166 167 168 //=================================================================== 169 //Examples taken from "Efficient Computation of Zero-Dimensional Gröbner Bases by Change of Ordering", 170 // 1994, Faugere, Gianni, Lazard, Mora (FGLM) 171 //=================================================================== 172 public void xtestCAP() { 173 String polynomials = "( " + " (y^2*z + 2*x*y*t - 2*x - z)," 174 + "(-x^3*z + 4*x*y^2*z + 4*x^2*y*t + 2*y^3*t + 4*x^2 - 10*y^2 + 4*x*z - 10*y*t + 2)," 175 + "(2*y*z*t + x*t^2 - x - 2*z)," 176 + "(-x*z^3 + 4*y*z^2*t + 4*x*z*t^2 + 2*y*t^3 + 4*x*z + 4*z^2 - 10*y*t -10*t^2 + 2)" 177 + ") "; 178 179 String orderINV = "(x,y,z,t)"; 180 String orderL = "(t,z,y,x)"; 181 182 //Tests 183 String erg_deg = grad(orderINV, polynomials); 184 System.out.println(grad); 185 System.out.println(erg_deg); 186 187 String erg1 = all(orderINV, polynomials); 188 String erg2 = all(orderL, polynomials); 189 String ergMod1 = modAll(orderINV, polynomials, 1831); 190 String ergMod2 = modAll(orderL, polynomials, 1831); 191 System.out.println(all); 192 System.out.println(erg1); 193 System.out.println(erg2); 194 System.out.println("\n"); 195 System.out.println(modAll); 196 System.out.println(ergMod1); 197 System.out.println(ergMod2); 198 } 199 200 201 public void xtestAUX() { 202 String polynomials = "( " + " (a^2*b*c + a*b^2*c + a*b*c^2 + a*b*c + a*b + a*c + b*c)," 203 + "(a^2*b^2*c + a*b^2*c^2 + a^2*b*c + a*b*c + b*c + a + c )," 204 + "(a^2*b^2*c^2 + a^2*b^2*c + a*b^2*c + a*b*c + a*c + c + 1)" + ") "; 205 206 String orderINV = "(a,b,c)"; 207 String orderL = "(c,b,a)"; 208 209 //Tests 210 String erg_deg = grad(orderINV, polynomials); 211 System.out.println(grad); 212 System.out.println(erg_deg); 213 214 String erg1 = all(orderINV, polynomials); 215 String erg2 = all(orderL, polynomials); 216 String ergMod1 = modAll(orderINV, polynomials, 1831); 217 String ergMod2 = modAll(orderL, polynomials, 1831); 218 System.out.println(all); 219 System.out.println(erg1); 220 System.out.println(erg2); 221 System.out.println("\n"); 222 System.out.println(modAll); 223 System.out.println(ergMod1); 224 System.out.println(ergMod2); 225 } 226 227 228 public void testC5() { 229 String polynomials = "( " + " (a + b + c + d + e)," + "(a*b + b*c + c*d + a*e + d*e)," 230 + "(a*b*c + b*c*d + a*b*e + a*d*e + c*d*e)," 231 + "(a*b*c*d + a*b*c*e + a*b*d*e + a*c*d*e + b*c*d*e)," + "(a*b*c*d*e -1)" + ") "; 232 233 String orderINV = "(a,b,c,d,e)"; 234 String orderL = "(e,d,c,b,a)"; 235 236 //Tests 237 String erg_deg = grad(orderINV, polynomials); 238 //System.out.println(grad); 239 //System.out.println(erg_deg); 240 241 String erg1 = all(orderINV, polynomials); 242 String erg2 = all(orderL, polynomials); 243 String ergMod1 = modAll(orderINV, polynomials, 1831); 244 String ergMod2 = modAll(orderL, polynomials, 1831); 245 246 System.out.println(grad); 247 System.out.println(erg_deg); 248 System.out.println(""); 249 System.out.println(all); 250 System.out.println(erg1); 251 System.out.println(erg2); 252 System.out.println("\n"); 253 System.out.println(modAll); 254 System.out.println(ergMod1); 255 System.out.println(ergMod2); 256 } 257 258 259 public void xtestModC5() { 260 String polynomials = "( " + " (a + b + c + d + e)," + "(a*b + b*c + c*d + a*e + d*e)," 261 + "(a*b*c + b*c*d + a*b*e + a*d*e + c*d*e)," 262 + "(b*c*d + a*b*c*e + a*b*d*e + a*c*d*e + b*c*d*e)," + "(a*b*c*d*e -1)" + ") "; 263 264 String orderINV = "(a,b,c,d,e)"; 265 String orderL = "(e,d,c,b,a)"; 266 267 //Tests 268 String erg_deg = grad(orderL, polynomials); 269 System.out.println(grad); 270 System.out.println(erg_deg); 271 272 /* 273 String ergOnlyFGLM_1 = fglm(orderINV, polynomials); 274 System.out.println(fglm); 275 System.out.println(ergOnlyFGLM_1); 276 277 //Tests MODULO 278 279 String ergOnlyG_1 = modGrad(orderINV, polynomials, 1831); 280 System.out.println(modGrad); 281 System.out.println(ergOnlyG_1); 282 283 String erg1 = modfglm(orderINV, polynomials, 1831); 284 System.out.println(modfglm); 285 System.out.println(erg1); 286 */ 287 } 288 289 290 public void xtestC6() { 291 String polynomials = "( " + " (a + b + c + d + e + f)," + "(a*b + b*c + c*d + d*e + e*f + a*f)," 292 + "(a*b*c + b*c*d + c*d*e + d*e*f + a*e*f + a*b*f)," 293 + "(a*b*c*d + b*c*d*e + c*d*e*f + a*d*e*f + a*b*e*f + a*b*c*f)," 294 + "(a*b*c*d*e + b*c*d*e*f + a*c*d*e*f + a*b*d*e*f + a*b*c*e*f + a*b*c*d*f)," 295 + "(a*b*c*d*e*f - 1)" + ") "; 296 297 String orderINV = "(a,b,c,d,e,f)"; 298 String orderL = "(f,e,d,c,b,a)"; 299 300 //Tests 301 /* 302 String erg2 = modAll(orderINV, polynomials, 1831); 303 System.out.println(modAll); 304 System.out.println(erg2); 305 306 String ergOnlyG_1 = modGrad(orderINV, polynomials, 1831); 307 System.out.println(modGrad); 308 System.out.println(ergOnlyG_1); 309 310 String erg1 = modfglm(orderINV, polynomials, 1831); 311 System.out.println(modfglm); 312 System.out.println(erg1); 313 */ 314 } 315 316 317 //=================================================================== 318 //Examples taken from "Der FGLM-Algorithmus: verallgemeinert und implementiert in SINGULAR", 1997, Wichmann 319 //=================================================================== 320 public void xtestIsaac() { 321 String polynomials = "( " 322 + " (8*w^2 + 5*w*x - 4*w*y + 2*w*z + 3*w + 5*x^2 + 2*x*y - 7*x*z - 7*x + 7*y^2 -8*y*z - 7*y + 7*z^2 - 8*z + 8)," 323 + "(3*w^2 - 5*w*x - 3*w*y - 6*w*z + 9*w + 4*x^2 + 2*x*y - 2*x*z + 7*x + 9*y^2 + 6*y*z + 5*y + 7*z^2 + 7*z + 5)," 324 + "(-2*w^2 + 9*w*x + 9*w*y - 7*w*z - 4*w + 8*x^2 + 9*x*y - 3*x*z + 8*x + 6*y^2 - 7*y*z + 4*y - 6*z^2 + 8*z + 2)," 325 + "(7*w^2 + 5*w*x + 3*w*y - 5*w*z - 5*w + 2*x^2 + 9*x*y - 7*x*z + 4*x -4*y^2 - 5*y*z + 6*y - 4*z^2 - 9*z + 2)" 326 + ") "; 327 328 String orderINV = "(w,x,y,z)"; 329 String orderL = "(z,y,x,w)"; 330 331 //Tests 332 String erg_deg = grad(orderL, polynomials); 333 System.out.println(grad); 334 System.out.println(erg_deg); 335 /* 336 String erg3 = all(orderINV, polynomials); 337 System.out.println(all); 338 System.out.println(erg3); 339 340 String ergOnlyLex_1 = lex(orderINV, polynomials); 341 String ergOnlyLex_2 = lex(orderL, polynomials); 342 System.out.println(lex); 343 System.out.println(ergOnlyLex_1); 344 System.out.println(ergOnlyLex_2); 345 346 String ergOnlyFGLM_1 = fglm(orderINV, polynomials); 347 String ergOnlyFGLM_2 = fglm(orderL, polynomials); 348 System.out.println(fglm); 349 System.out.println(ergOnlyFGLM_1); 350 System.out.println(ergOnlyFGLM_2); 351 352 String ergm1 = modAll(orderINV, polynomials, 2147464751); 353 String ergm2 = modAll(orderL, polynomials, 2147464751); 354 System.out.println(modAll); 355 System.out.println(ergm1); 356 System.out.println(ergm2); 357 */ 358 } 359 360 361 public void xtestNiermann() { 362 String polynomials = "( " + " (x^2 + x*y^2*z - 2*x*y + y^4 + y^2 + z^2)," 363 + "(-x^3*y^2 + x*y^2*z + x*y*z^3 - 2*x*y + y^4)," + "(-2*x^2*y + x*y^4 + y*z^4 - 3)" 364 + ") "; 365 366 String orderINV = "(x,y,z)"; 367 String orderL = "(z,y,x)"; 368 369 //Tests 370 String erg_deg = grad(orderINV, polynomials); 371 System.out.println(grad); 372 System.out.println(erg_deg); 373 /* 374 String erg1 = fglm(orderINV, polynomials); 375 String erg2 = fglm(orderL, polynomials); 376 System.out.println(fglm); 377 System.out.println(erg1); 378 System.out.println(erg2); 379 */ 380 String ergm1 = modfglm(orderINV, polynomials, 1831); 381 String ergm2 = modfglm(orderL, polynomials, 2147464751); 382 System.out.println(modfglm); 383 System.out.println(ergm1); 384 System.out.println(ergm2); 385 } 386 387 388 public void ytestWalkS7() { 389 String polynomials = "( " + " (2*g*b + 2*f*c + 2*e*d + a^2 + a)," 390 + "(2*g*c + 2*f*d + e^2 + 2*b*a + b)," + "(2*g*d + 2*f*e + 2*c*a + c + b^2)," 391 + "(2*g*e + f^2 + 2*d*a + d + 2*c*b)," + "(2*g*f + 2*e*a + e + 2*d*b + c^2)," 392 + "(g^2 + 2*f*a + f + 2*e*b + 2*d*c)," + "(2*g*a + g + 2*f*b + 2*e*c + d^2)" + ") "; 393 394 String orderINV = "(a,b,c,d,e,f,g)"; 395 String orderL = "(g,f,e,d,c,b,a)"; 396 397 //Tests 398 //String ergm1 = modAll(orderINV, polynomials, 2147464751); 399 //String ergm2 = modfglm(orderL, polynomials, 1831); 400 //System.out.println(modfglm); 401 //System.out.println(ergm1); 402 //System.out.println(ergm2); 403 404 String erg2 = fglm(orderL, polynomials); 405 System.out.println(fglm); 406 System.out.println(erg2); 407 } 408 409 410 public void ytestCassouMod1() { 411 String polynomials = "( " 412 + " (15*a^4*b*c^2 + 6*a^4*b^3 + 21*a^4*b^2*c - 144*a^2*b - 8*a^2*b^2*d - 28*a^2*b*c*d - 648*a^2*c + 36*c^2*d + 9*a^4*c^3 - 120)," 413 + "(30*b^3*a^4*c - 32*c*d^2*b - 720*c*a^2*b - 24*b^3*a^2*d - 432*b^2*a^2 + 576*d*b - 576*c*d + 16*b*a^2*c^2*d + 16*c^2*d^2 + 16*d^2*b^2 + 9*b^4*a^4 + 5184 + 39*c^2*a^4*b^2 + 18*c^3*a^4*b - 432*c^2*a^2 + 24*c^3*a^2*d - 16*b^2*a^2*c*d - 240*b)," 414 + "(216*c*a^2*b - 162*c^2*a^2 - 81*b^2*a^2 + 5184 + 1008*d*b - 1008*c*d + 15*b^2*a^2*c*d - 15*b^3*a^2*d - 80*c*d^2*b + 40*c^2*d^2 + 40*d^2*b^2)," 415 + "(261 + 4*c*a^2*b - 3*c^2*a^2 - 4*b^2*a^2 + 22*d*b - 22*c*d)" + ") "; 416 417 String orderINV = "(a,b,c,d)"; 418 String orderL = "(d,c,b,a)"; 419 420 //Tests 421 String ergm1 = modfglm(orderL, polynomials, 1831); 422 String ergm2 = modfglm(orderINV, polynomials, 1831); 423 System.out.println(modfglm); 424 System.out.println(ergm1); 425 System.out.println(ergm2); 426 } 427 428 429 public void ytestOmdi1() { 430 String polynomials = "( " + " (a + c + v + 2*x - 1)," + "(a*b + c*u + 2*v*w + 2*x*y + 2*x*z -2/3)," 431 + "(a*b^2 + c*u^2 + 2*v*w^2 + 2*x*y^2 + 2*x*z^2 - 2/5)," 432 + "(a*b^3 + c*u^3 + 2*v*w^3 + 2*x*y^3 + 2*x*z^3 - 2/7)," 433 + "(a*b^4 + c*u^4 + 2*v*w^4 + 2*x*y^4 + 2*x*z^4 - 2/9)," + "(v*w^2 + 2*x*y*z - 1/9)," 434 + "(v*w^4 + 2*x*y^2*z^2 - 1/25)," + "(v*w^3 + 2*x*y*z^2 + x*y^2*z - 1/15)," 435 + "(v*w^4 + x*y*z^3 + x*y^3*z -1/21)" + ") "; 436 437 String orderINV = "(a,b,c,u,v,w,x,y,z)"; 438 String orderL = "(z,y,x,w,v,u,c,b,a)"; 439 440 //Tests 441 String erg_deg = grad(orderL, polynomials); 442 System.out.println(grad); 443 System.out.println(erg_deg); 444 /* 445 String ergm1 = modfglm(orderL, polynomials, 1831); 446 String ergm2 = modfglm(orderINV, polynomials, 1831); 447 System.out.println(modfglm); 448 System.out.println(ergm1); 449 System.out.println(ergm2); 450 */ 451 } 452 453 454 public void ytestLamm1() { 455 String polynomials = "( " 456 + " (45*x^8 + 3*x^7 + 39*x^6 + 30*x^5 + 13*x^4 + 41*x^3 + 5*x^2 + 46*x + 7)," 457 + "(49*x^7*y + 35*x*y^7 + 37*x*y^6 + 9*y^7 + 4*x^6 + 6*y^6 + 27*x^3*y^2 + 20*x*y^4 + 31*x^4 + 33*x^2*y + 24*x^2 + 49*y + 43)" 458 + ") "; 459 460 String orderINV = "(x,y)"; 461 String orderL = "(y,x)"; 462 463 //Tests 464 String erg_deg = grad(orderINV, polynomials); 465 System.out.println(grad); 466 System.out.println(erg_deg); 467 468 String erg1 = all(orderINV, polynomials); 469 String erg2 = all(orderL, polynomials); 470 String ergMod1 = modAll(orderINV, polynomials, 1831); 471 String ergMod2 = modAll(orderL, polynomials, 1831); 472 System.out.println(all); 473 System.out.println(erg1); 474 System.out.println(erg2); 475 System.out.println("\n"); 476 System.out.println(modAll); 477 System.out.println(ergMod1); 478 System.out.println(ergMod2); 479 } 480 481 482 //=================================================================== 483 //Examples taken from "Some Examples for Solving Systems of Algebraic Equations by Calculating Gröbner Bases", 1984, Boege, Gebauer, Kredel 484 //=================================================================== 485 public void xtestEquilibrium() { 486 String polynomials = "( " 487 + " (y^4 - 20/7*z^2)," 488 + "(z^2*x^4 + 7/10*z*x^4 + 7/48*x^4 - 50/27*z^2 - 35/27*z - 49/216)," 489 + "(x^5*y^3 + 7/5*z^4*y^3 + 609/1000 *z^3*y^3 + 49/1250*z^2*y^3 - 27391/800000*z*y^3 - 1029/160000*y^3 + 3/7*z^5*x*y^2 +" 490 + "3/5*z^6*x*y^2 + 63/200*z^3*x*y^2 + 147/2000*z^2*x*y^2 + 4137/800000*z*x*y^2 - 7/20*z^4*x^2*y - 77/125*z^3*x^2*y" 491 + "- 23863/60000*z^2*x^2*y - 1078/9375*z*x^2*y - 24353/1920000*x^2*y - 3/20*z^4*x^3 - 21/100*z^3*x^3" 492 + "- 91/800*z^2*x^3 - 5887/200000*z*x^3 - 343/128000*x^3)" + ") "; 493 494 String order = "(x,y,z)"; 495 496 //Tests 497 String ergOnlyG_1 = grad(order, polynomials); 498 System.out.println(grad); 499 System.out.println(ergOnlyG_1); 500 } 501 502 503 public void xtestTrinks2() { 504 String polynomials = "( " + " (45*p + 35*s - 165*b - 36)," + "(35*p + 40*z + 25*t - 27*s)," 505 + "(15*w + 25*p*s + 30*z - 18*t - 165*b^2)," + "(-9*w + 15*p*t + 20*z*s)," 506 + "(w*p + 2*z*t - 11*b^3)," + "(99*w - 11*s*b + 3*b^2)," 507 + "(b^2 + 33/50*b + 2673/10000)" + ") "; 508 509 String order1 = "(b,s,t,z,p,w)"; 510 String order2 = "(s,b,t,z,p,w)"; 511 String order3 = "(s,t,b,z,p,w)"; 512 String order4 = "(s,t,z,p,b,w)"; 513 String order5 = "(s,t,z,p,w,b)"; 514 String order6 = "(s,z,p,w,b,t)"; 515 String order7 = "(p,w,b,t,s,z)"; 516 String order8 = "(z,w,b,s,t,p)"; 517 String order9 = "(t,z,p,w,b,s)"; 518 String order10 = "(z,p,w,b,s,t)"; 519 String order11 = "(p,w,b,s,t,z)"; 520 String order12 = "(w,b,s,t,z,p)"; 521 522 //Tests 523 String erg_1 = all(order1, polynomials); 524 String erg_2 = all(order2, polynomials); 525 String erg_3 = all(order3, polynomials); 526 String erg_4 = all(order4, polynomials); 527 String erg_5 = all(order5, polynomials); 528 String erg_6 = all(order6, polynomials); 529 String erg_7 = all(order7, polynomials); 530 String erg_8 = all(order8, polynomials); 531 String erg_9 = all(order9, polynomials); 532 String erg_10 = all(order10, polynomials); 533 String erg_11 = all(order11, polynomials); 534 String erg_12 = all(order12, polynomials); 535 System.out.println(all); 536 System.out.println(erg_1); 537 System.out.println(erg_2); 538 System.out.println(erg_3); 539 System.out.println(erg_4); 540 System.out.println(erg_5); 541 System.out.println(erg_6); 542 System.out.println(erg_7); 543 System.out.println(erg_8); 544 System.out.println(erg_9); 545 System.out.println(erg_10); 546 System.out.println(erg_11); 547 System.out.println(erg_12); 548 } 549 550 551 public void xtestHairerRungeKutta_1() { 552 String polynomials = "( " + " (a-f),(b-h-g),(e+d+c-1),(d*a+c*b-1/2),(d*a^2+c*b^2-1/3),(c*g*a-1/6)" 553 + ") "; 554 555 String[] order = new String[] { "a", "b", "c", "d", "e", "f", "g", "h" }; 556 557 String order1 = shuffle(order); 558 String order2 = shuffle(order); 559 String order3 = shuffle(order); 560 String order4 = shuffle(order); 561 String order5 = shuffle(order); 562 563 // langsam (e,d,h,c,g,a,f,b), (h,d,b,e,c,g,a,f) um die 120 564 565 // sehr langsam (e,h,d,c,g,b,a,f) um die 1000 566 567 // sehr schnell (g,b,f,h,c,d,a,e), (h,c,a,g,d,f,e,b) 1 millisec 568 569 String ergOnlyG_1 = grad(order1, polynomials); 570 System.out.println(grad); 571 System.out.println(ergOnlyG_1); 572 573 String ergOnlyL_1 = lex(order1, polynomials); 574 String ergOnlyL_2 = lex(order2, polynomials); 575 String ergOnlyL_3 = lex(order3, polynomials); 576 String ergOnlyL_4 = lex(order4, polynomials); 577 String ergOnlyL_5 = lex(order5, polynomials); 578 579 System.out.println(lex); 580 System.out.println(ergOnlyL_1); 581 System.out.println(ergOnlyL_2); 582 System.out.println(ergOnlyL_3); 583 System.out.println(ergOnlyL_4); 584 System.out.println(ergOnlyL_5); 585 586 //String ergGeneral = all(order, polynomials); 587 //System.out.println(all); 588 //System.out.println(ergGeneral); 589 } 590 591 592 //================================================================================================= 593 //Internal methods 594 //================================================================================================= 595 @SuppressWarnings("cast") 596 public String all(String order, String polynomials) { 597 GroebnerBaseFGLM<BigRational> IdealObjectFGLM; 598 BigRational coeff = new BigRational(); 599 GroebnerBase<BigRational> gb = GBFactory.getImplementation(coeff); 600 601 String polynomials_Grad = order + " G " + polynomials; 602 String polynomials_Lex = order + " L " + polynomials; 603 604 Reader sourceG = new StringReader(polynomials_Grad); 605 GenPolynomialTokenizer parserG = new GenPolynomialTokenizer(sourceG); 606 PolynomialList<BigRational> G = null; 607 Reader sourceL = new StringReader(polynomials_Lex); 608 GenPolynomialTokenizer parserL = new GenPolynomialTokenizer(sourceL); 609 PolynomialList<BigRational> L = null; 610 611 try { 612 G = (PolynomialList) parserG.nextPolynomialSet(); 613 L = (PolynomialList) parserL.nextPolynomialSet(); 614 } catch (IOException e) { 615 e.printStackTrace(); 616 return "fail"; 617 } 618 System.out.println("Input " + G); 619 System.out.println("Input " + L); 620 621 //Computation of the Groebnerbase with Buchberger w.r.t INVLEX 622 long buchberger_Lex = System.currentTimeMillis(); 623 List<GenPolynomial<BigRational>> GL = gb.GB(L.list); 624 buchberger_Lex = System.currentTimeMillis() - buchberger_Lex; 625 626 //Computation of the Groebnerbase with Buchberger w.r.t GRADLEX (Total degree + INVLEX) 627 long buchberger_Grad = System.currentTimeMillis(); 628 List<GenPolynomial<BigRational>> GG = gb.GB(G.list); 629 buchberger_Grad = System.currentTimeMillis() - buchberger_Grad; 630 631 //PolynomialList<BigRational> GGG = new PolynomialList<BigRational>(G.ring, GG); 632 //PolynomialList<BigRational> GLL = new PolynomialList<BigRational>(L.ring, GL); 633 634 IdealObjectFGLM = new GroebnerBaseFGLM<BigRational>(); //GGG); 635 //IdealObjectLex = new GroebnerBaseSeq<BigRational>(GLL); 636 637 long tconv = System.currentTimeMillis(); 638 List<GenPolynomial<BigRational>> resultFGLM = IdealObjectFGLM.convGroebnerToLex(GG); 639 tconv = System.currentTimeMillis() - tconv; 640 641 OrderedPolynomialList<BigRational> o1 = new OrderedPolynomialList<BigRational>(GG.get(0).ring, GG); 642 OrderedPolynomialList<BigRational> o2 = new OrderedPolynomialList<BigRational>( 643 resultFGLM.get(0).ring, resultFGLM); 644 //List<GenPolynomial<BigRational>> resultBuchberger = GL; 645 OrderedPolynomialList<BigRational> o3 = new OrderedPolynomialList<BigRational>(GL.get(0).ring, GL); 646 647 int grad_numberOfElements = GG.size(); 648 int lex_numberOfElements = resultFGLM.size(); 649 long grad_maxPolyGrad = PolyUtil.<BigRational> totalDegreeLeadingTerm(GG); // IdealObjectFGLM.maxDegreeOfGB(); 650 long lex_maxPolyGrad = PolyUtil.<BigRational> totalDegreeLeadingTerm(GL); // IdealObjectLex.maxDegreeOfGB(); 651 652 int grad_height = bitHeight(GG); 653 int lex_height = bitHeight(resultFGLM); 654 655 System.out.println("Order of Variables: " + order); 656 System.out.println("Groebnerbases: "); 657 System.out.println("Groebnerbase Buchberger (IGRLEX) " + o1); 658 System.out.println("Groebnerbase FGML (INVLEX) computed from Buchberger (IGRLEX) " + o2); 659 System.out.println("Groebnerbase Buchberger (INVLEX) " + o3); 660 661 String erg = "BigRational |" + order + " |" + grad_numberOfElements + " |" 662 + lex_numberOfElements + " |" + grad_height + " |" + lex_height 663 + " |" + grad_maxPolyGrad + " |" + lex_maxPolyGrad + " |" 664 + buchberger_Grad + " |" + tconv + " |" + buchberger_Lex; 665 666 assertEquals(o2, o3); 667 return erg; 668 } 669 670 671 @SuppressWarnings("cast") 672 public String fglm(String order, String polynomials) { 673 GroebnerBaseFGLM<BigRational> IdealObjectGrad; 674 //GroebnerBaseAbstract<BigRational> IdealObjectLex; 675 676 BigRational coeff = new BigRational(); 677 GroebnerBase<BigRational> gb = GBFactory.getImplementation(coeff); 678 679 String polynomials_Grad = order + " G " + polynomials; 680 681 Reader sourceG = new StringReader(polynomials_Grad); 682 GenPolynomialTokenizer parserG = new GenPolynomialTokenizer(sourceG); 683 PolynomialList<BigRational> G = null; 684 685 try { 686 G = (PolynomialList) parserG.nextPolynomialSet(); 687 } catch (IOException e) { 688 e.printStackTrace(); 689 return "fail"; 690 } 691 System.out.println("Input " + G); 692 693 //Computation of the Groebnerbase with Buchberger w.r.t GRADLEX (Total degree + INVLEX) 694 long buchberger_Grad = System.currentTimeMillis(); 695 List<GenPolynomial<BigRational>> GG = gb.GB(G.list); 696 buchberger_Grad = System.currentTimeMillis() - buchberger_Grad; 697 698 //PolynomialList<BigRational> GGG = new PolynomialList<BigRational>(G.ring, GG); 699 700 IdealObjectGrad = new GroebnerBaseFGLM<BigRational>(); //GGG); 701 702 long tconv = System.currentTimeMillis(); 703 List<GenPolynomial<BigRational>> resultFGLM = IdealObjectGrad.convGroebnerToLex(GG); 704 tconv = System.currentTimeMillis() - tconv; 705 706 //PolynomialList<BigRational> LLL = new PolynomialList<BigRational>(G.ring, resultFGLM); 707 //IdealObjectLex = new GroebnerBaseSeq<BigRational>(); //LLL); 708 709 OrderedPolynomialList<BigRational> o1 = new OrderedPolynomialList<BigRational>(GG.get(0).ring, GG); 710 OrderedPolynomialList<BigRational> o2 = new OrderedPolynomialList<BigRational>( 711 resultFGLM.get(0).ring, resultFGLM); 712 713 int grad_numberOfElements = GG.size(); 714 int lex_numberOfElements = resultFGLM.size(); 715 long grad_maxPolyGrad = PolyUtil.<BigRational> totalDegreeLeadingTerm(GG); //IdealObjectGrad.maxDegreeOfGB(); 716 long lex_maxPolyGrad = PolyUtil.<BigRational> totalDegreeLeadingTerm(resultFGLM); //IdealObjectLex.maxDegreeOfGB(); 717 718 int grad_height = bitHeight(GG); 719 int lex_height = bitHeight(resultFGLM); 720 721 System.out.println("Order of Variables: " + order); 722 System.out.println("Groebnerbases: "); 723 System.out.println("Groebnerbase Buchberger (IGRLEX) " + o1); 724 System.out.println("Groebnerbase FGML (INVLEX) computed from Buchberger (IGRLEX) " + o2); 725 726 String erg = "BigRational |" + order + " |" + grad_numberOfElements + " |" 727 + lex_numberOfElements + " |" + grad_height + " |" + lex_height + " |" 728 + grad_maxPolyGrad + " |" + lex_maxPolyGrad + " |" + buchberger_Grad 729 + " |" + tconv; 730 return erg; 731 } 732 733 734 @SuppressWarnings("cast") 735 public String grad(String order, String polynomials) { 736 BigRational coeff = new BigRational(); 737 GroebnerBase<BigRational> gb = GBFactory.getImplementation(coeff); 738 739 String polynomials_Grad = order + " G " + polynomials; 740 741 Reader sourceG = new StringReader(polynomials_Grad); 742 GenPolynomialTokenizer parserG = new GenPolynomialTokenizer(sourceG); 743 PolynomialList<BigRational> G = null; 744 745 try { 746 G = (PolynomialList) parserG.nextPolynomialSet(); 747 } catch (IOException e) { 748 e.printStackTrace(); 749 return "fail"; 750 } 751 System.out.println("Input " + G); 752 753 //Computation of the Groebnerbase with Buchberger w.r.t GRADLEX (Total degree + INVLEX) 754 long buchberger_Grad = System.currentTimeMillis(); 755 List<GenPolynomial<BigRational>> GG = gb.GB(G.list); 756 buchberger_Grad = System.currentTimeMillis() - buchberger_Grad; 757 758 //PolynomialList<BigRational> GGG = new PolynomialList<BigRational>(G.ring, GG); 759 OrderedPolynomialList<BigRational> o1 = new OrderedPolynomialList<BigRational>(GG.get(0).ring, GG); 760 761 GroebnerBaseFGLM<BigRational> IdealObjectGrad; 762 IdealObjectGrad = new GroebnerBaseFGLM<BigRational>(); //GGG); 763 long grad_maxPolyGrad = PolyUtil.<BigRational> totalDegreeLeadingTerm(GG); //IdealObjectGrad.maxDegreeOfGB(); 764 List<GenPolynomial<BigRational>> reducedTerms = IdealObjectGrad.redTerms(GG); 765 OrderedPolynomialList<BigRational> o4 = new OrderedPolynomialList<BigRational>( 766 reducedTerms.get(0).ring, reducedTerms); 767 int grad_numberOfReducedElements = reducedTerms.size(); 768 int grad_numberOfElements = GG.size(); 769 int grad_height = bitHeight(GG); 770 771 System.out.println("Order of Variables: " + order); 772 System.out.println("Groebnerbases: "); 773 System.out.println("Groebnerbase Buchberger (IGRLEX) " + o1); 774 System.out.println("Reduced Terms" + o4); 775 776 String erg = "BigRational |" + order + " |" + grad_numberOfElements + " |" + grad_height + " |" 777 + grad_maxPolyGrad + " |" + buchberger_Grad + " |" 778 + grad_numberOfReducedElements; 779 return erg; 780 } 781 782 783 @SuppressWarnings("cast") 784 public String lex(String order, String polynomials) { 785 //GroebnerBaseAbstract<BigRational> IdealObjectLex; 786 BigRational coeff = new BigRational(); 787 GroebnerBase<BigRational> gb = GBFactory.getImplementation(coeff); 788 789 String polynomials_Lex = order + " L " + polynomials; 790 791 Reader sourceL = new StringReader(polynomials_Lex); 792 GenPolynomialTokenizer parserL = new GenPolynomialTokenizer(sourceL); 793 PolynomialList<BigRational> L = null; 794 795 try { 796 L = (PolynomialList) parserL.nextPolynomialSet(); 797 } catch (IOException e) { 798 e.printStackTrace(); 799 return "fail"; 800 } 801 System.out.println("Input " + L); 802 803 //Computation of the Groebnerbase with Buchberger w.r.t INVLEX 804 long buchberger_Lex = System.currentTimeMillis(); 805 List<GenPolynomial<BigRational>> GL = gb.GB(L.list); 806 buchberger_Lex = System.currentTimeMillis() - buchberger_Lex; 807 808 //PolynomialList<BigRational> GLL = new PolynomialList<BigRational>(L.ring, GL); 809 //IdealObjectLex = new GroebnerBaseAbstract<BigRational>(GLL); 810 811 OrderedPolynomialList<BigRational> o3 = new OrderedPolynomialList<BigRational>(GL.get(0).ring, GL); 812 813 int lex_numberOfElements = GL.size(); 814 long lex_maxPolyGrad = PolyUtil.<BigRational> totalDegreeLeadingTerm(GL); //IdealObjectLex.maxDegreeOfGB(); 815 int lexHeigth = bitHeight(GL); 816 817 System.out.println("Order of Variables: " + order); 818 System.out.println("Groebnerbase Buchberger (INVLEX) " + o3); 819 820 String erg = "BigRational" + order + "|" + lex_numberOfElements + " |" + lexHeigth + " |" 821 + lex_maxPolyGrad + " |" + buchberger_Lex; 822 return erg; 823 } 824 825 826 @SuppressWarnings("cast") 827 public String modAll(String order, String polynomials, Integer m) { 828 GroebnerBaseFGLM<ModInteger> IdealObjectFGLM; 829 //GroebnerBaseAbstract<ModInteger> IdealObjectLex; 830 ModIntegerRing ring = new ModIntegerRing(m); 831 GroebnerBase<ModInteger> gb = GBFactory.getImplementation(ring); 832 833 String polynomials_Grad = "Mod " + ring.modul + " " + order + " G " + polynomials; 834 String polynomials_Lex = "Mod " + ring.modul + " " + order + " L " + polynomials; 835 836 Reader sourceG = new StringReader(polynomials_Grad); 837 GenPolynomialTokenizer parserG = new GenPolynomialTokenizer(sourceG); 838 PolynomialList<ModInteger> G = null; 839 Reader sourceL = new StringReader(polynomials_Lex); 840 GenPolynomialTokenizer parserL = new GenPolynomialTokenizer(sourceL); 841 PolynomialList<ModInteger> L = null; 842 843 try { 844 G = (PolynomialList) parserG.nextPolynomialSet(); 845 L = (PolynomialList) parserL.nextPolynomialSet(); 846 } catch (IOException e) { 847 e.printStackTrace(); 848 return "fail"; 849 } 850 System.out.println("G= " + G); 851 System.out.println("L= " + L); 852 853 //Computation of the Groebnerbase with Buchberger w.r.t INVLEX 854 long buchberger_Lex = System.currentTimeMillis(); 855 List<GenPolynomial<ModInteger>> GL = gb.GB(L.list); 856 buchberger_Lex = System.currentTimeMillis() - buchberger_Lex; 857 858 //Computation of the Groebnerbase with Buchberger w.r.t GRADLEX (Total degree + INVLEX) 859 long buchberger_Grad = System.currentTimeMillis(); 860 List<GenPolynomial<ModInteger>> GG = gb.GB(G.list); 861 buchberger_Grad = System.currentTimeMillis() - buchberger_Grad; 862 863 //PolynomialList<ModInteger> GGG = new PolynomialList<ModInteger>(G.ring, GG); 864 //PolynomialList<ModInteger> GLL = new PolynomialList<ModInteger>(L.ring, GL); 865 866 IdealObjectFGLM = new GroebnerBaseFGLM<ModInteger>(); //GGG); 867 //IdealObjectLex = new GroebnerBaseAbstract<ModInteger>(GLL); 868 869 long tconv = System.currentTimeMillis(); 870 List<GenPolynomial<ModInteger>> resultFGLM = IdealObjectFGLM.convGroebnerToLex(GG); 871 tconv = System.currentTimeMillis() - tconv; 872 873 OrderedPolynomialList<ModInteger> o1 = new OrderedPolynomialList<ModInteger>(GG.get(0).ring, GG); 874 OrderedPolynomialList<ModInteger> o2 = new OrderedPolynomialList<ModInteger>(resultFGLM.get(0).ring, 875 resultFGLM); 876 List<GenPolynomial<ModInteger>> resultBuchberger = GL; 877 OrderedPolynomialList<ModInteger> o3 = new OrderedPolynomialList<ModInteger>( 878 resultBuchberger.get(0).ring, resultBuchberger); 879 880 int grad_numberOfElements = GG.size(); 881 int lex_numberOfElements = resultFGLM.size(); 882 long grad_maxPolyGrad = PolyUtil.<ModInteger> totalDegreeLeadingTerm(GG); //IdealObjectFGLM.maxDegreeOfGB(); 883 long lex_maxPolyGrad = PolyUtil.<ModInteger> totalDegreeLeadingTerm(GL); //IdealObjectLex.maxDegreeOfGB(); 884 885 System.out.println("Order of Variables: " + order); 886 System.out.println("Groebnerbases: "); 887 System.out.println("Groebnerbase Buchberger (IGRLEX) " + o1); 888 System.out.println("Groebnerbase FGML (INVLEX) computed from Buchberger (IGRLEX) " + o2); 889 System.out.println("Groebnerbase Buchberger (INVLEX) " + o3); 890 891 String erg = "Mod " + m + " |" + order + " |" + grad_numberOfElements + " |" 892 + lex_numberOfElements + " |" + grad_maxPolyGrad + " |" + lex_maxPolyGrad 893 + " |" + buchberger_Grad + " |" + tconv + " |" + buchberger_Lex; 894 895 assertEquals(o2, o3); 896 return erg; 897 } 898 899 900 @SuppressWarnings("cast") 901 public String modGrad(String order, String polynomials, Integer m) { 902 //GroebnerBaseFGLM<ModInteger> IdealObjectFGLM; 903 ModIntegerRing ring = new ModIntegerRing(m); 904 GroebnerBase<ModInteger> gb = GBFactory.getImplementation(ring); 905 906 String polynomials_Grad = "Mod " + ring.modul + " " + order + " G " + polynomials; 907 908 Reader sourceG = new StringReader(polynomials_Grad); 909 GenPolynomialTokenizer parserG = new GenPolynomialTokenizer(sourceG); 910 PolynomialList<ModInteger> G = null; 911 912 try { 913 G = (PolynomialList) parserG.nextPolynomialSet(); 914 } catch (IOException e) { 915 e.printStackTrace(); 916 return "fail"; 917 } 918 System.out.println("G= " + G); 919 920 //Computation of the Groebnerbase with Buchberger w.r.t GRADLEX (Total degree + INVLEX) 921 long buchberger_Grad = System.currentTimeMillis(); 922 List<GenPolynomial<ModInteger>> GG = gb.GB(G.list); 923 buchberger_Grad = System.currentTimeMillis() - buchberger_Grad; 924 925 //PolynomialList<ModInteger> GGG = new PolynomialList<ModInteger>(G.ring, GG); 926 //IdealObjectFGLM = new GroebnerBaseFGLM<ModInteger>(); //GGG); 927 928 OrderedPolynomialList<ModInteger> o1 = new OrderedPolynomialList<ModInteger>(GG.get(0).ring, GG); 929 930 int grad_numberOfElements = GG.size(); 931 long grad_maxPolyGrad = PolyUtil.<ModInteger> totalDegreeLeadingTerm(GG); //IdealObjectFGLM.maxDegreeOfGB(); 932 933 System.out.println("Order of Variables: " + order); 934 System.out.println("Groebnerbases: "); 935 System.out.println("Groebnerbase Buchberger (IGRLEX) " + o1); 936 937 String erg = "Mod " + m + " |" + order + " |" + grad_numberOfElements + " |" 938 + grad_maxPolyGrad + " |" + buchberger_Grad; 939 return erg; 940 } 941 942 943 @SuppressWarnings("cast") 944 public String modfglm(String order, String polynomials, Integer m) { 945 GroebnerBaseFGLM<ModInteger> IdealObjectFGLM; 946 //GroebnerBaseAbstract<ModInteger> IdealObjectLex; 947 ModIntegerRing ring = new ModIntegerRing(m); 948 GroebnerBase<ModInteger> gb = GBFactory.getImplementation(ring); 949 950 String polynomials_Grad = "Mod " + ring.modul + " " + order + " G " + polynomials; 951 952 Reader sourceG = new StringReader(polynomials_Grad); 953 GenPolynomialTokenizer parserG = new GenPolynomialTokenizer(sourceG); 954 PolynomialList<ModInteger> G = null; 955 956 try { 957 G = (PolynomialList) parserG.nextPolynomialSet(); 958 } catch (IOException e) { 959 e.printStackTrace(); 960 return "fail"; 961 } 962 System.out.println("G= " + G); 963 964 //Computation of the Groebnerbase with Buchberger w.r.t GRADLEX (Total degree + INVLEX) 965 long buchberger_Grad = System.currentTimeMillis(); 966 List<GenPolynomial<ModInteger>> GG = gb.GB(G.list); 967 buchberger_Grad = System.currentTimeMillis() - buchberger_Grad; 968 969 //PolynomialList<ModInteger> GGG = new PolynomialList<ModInteger>(G.ring, GG); 970 IdealObjectFGLM = new GroebnerBaseFGLM<ModInteger>(); //GGG); 971 972 long tconv = System.currentTimeMillis(); 973 List<GenPolynomial<ModInteger>> resultFGLM = IdealObjectFGLM.convGroebnerToLex(GG); 974 tconv = System.currentTimeMillis() - tconv; 975 976 //PolynomialList<ModInteger> LLL = new PolynomialList<ModInteger>(G.ring, resultFGLM); 977 //IdealObjectLex = new GroebnerBaseAbstract<ModInteger>(LLL); 978 979 OrderedPolynomialList<ModInteger> o1 = new OrderedPolynomialList<ModInteger>(GG.get(0).ring, GG); 980 OrderedPolynomialList<ModInteger> o2 = new OrderedPolynomialList<ModInteger>(resultFGLM.get(0).ring, 981 resultFGLM); 982 983 int grad_numberOfElements = GG.size(); 984 int lex_numberOfElements = resultFGLM.size(); 985 long grad_maxPolyGrad = PolyUtil.<ModInteger> totalDegreeLeadingTerm(GG); //IdealObjectFGLM.maxDegreeOfGB(); 986 long lex_maxPolyGrad = PolyUtil.<ModInteger> totalDegreeLeadingTerm(resultFGLM); //IdealObjectLex.maxDegreeOfGB(); 987 988 System.out.println("Order of Variables: " + order); 989 System.out.println("Groebnerbases: "); 990 System.out.println("Groebnerbase Buchberger (IGRLEX) " + o1); 991 System.out.println("Groebnerbase FGML (INVLEX) computed from Buchberger (IGRLEX) " + o2); 992 993 String erg = "Mod " + m + " |" + order + " |" + grad_numberOfElements + " |" 994 + lex_numberOfElements + " |" + grad_maxPolyGrad + " |" 995 + lex_maxPolyGrad + " |" + buchberger_Grad + " |" + tconv; 996 return erg; 997 } 998 999 1000 //Method shuffle returns a random permutation of a string of variables 1001 public String shuffle(String[] tempOrder) { 1002 Collections.shuffle(Arrays.asList(tempOrder)); 1003 StringBuffer ret = new StringBuffer("("); 1004 ret.append(ExpVector.varsToString(tempOrder)); 1005 ret.append(")"); 1006 return ret.toString(); 1007 } 1008 1009 1010 //Method bitHeight returns the bitlength of the greatest number occurring during the computation of a groebnerbase 1011 public int bitHeight(List<GenPolynomial<BigRational>> list) { 1012 BigInteger denom = BigInteger.ONE; 1013 BigInteger num = BigInteger.ONE; 1014 for (GenPolynomial<BigRational> g : list) { 1015 for (Monomial<BigRational> m : g) { 1016 BigRational bi = m.coefficient(); 1017 BigInteger i = bi.denominator().abs(); 1018 BigInteger j = bi.numerator().abs(); 1019 if (i.compareTo(denom) > 0) 1020 denom = i; 1021 if (j.compareTo(num) > 0) 1022 num = j; 1023 } 1024 } 1025 int erg; 1026 if (denom.compareTo(num) > 0) { 1027 erg = denom.bitLength(); 1028 } else { 1029 erg = num.bitLength(); 1030 } 1031 return erg; 1032 } 1033 1034}