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