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