001/* 002 * $Id$ 003 */ 004 005package edu.jas.fd; 006 007 008import edu.jas.arith.BigComplex; 009import edu.jas.arith.BigInteger; 010import edu.jas.arith.BigRational; 011import edu.jas.arith.ModInteger; 012import edu.jas.arith.ModIntegerRing; 013import edu.jas.kern.ComputerThreads; 014import edu.jas.poly.AlgebraicNumber; 015import edu.jas.poly.AlgebraicNumberRing; 016import edu.jas.poly.GenPolynomial; 017import edu.jas.poly.GenPolynomialRing; 018import edu.jas.poly.GenSolvablePolynomial; 019import edu.jas.poly.GenSolvablePolynomialRing; 020import edu.jas.poly.RecSolvablePolynomial; 021import edu.jas.poly.RecSolvablePolynomialRing; 022import edu.jas.poly.PolyUtil; 023import edu.jas.poly.TermOrder; 024 025import junit.framework.Test; 026import junit.framework.TestCase; 027import junit.framework.TestSuite; 028 029 030/** 031 * Solvable GreatestCommonDivisor parallel proxy tests with JUnit. 032 * @author Heinz Kredel 033 */ 034 035public class SGCDParallelProxyTest extends TestCase { 036 037 038 /** 039 * main. 040 */ 041 public static void main(String[] args) { 042 junit.textui.TestRunner.run(suite()); 043 ComputerThreads.terminate(); 044 //System.out.println("System.exit(0)"); 045 } 046 047 048 /** 049 * Constructs a <CODE>SGCDParallelProxyTest</CODE> object. 050 * @param name String. 051 */ 052 public SGCDParallelProxyTest(String name) { 053 super(name); 054 } 055 056 057 /** 058 */ 059 public static Test suite() { 060 TestSuite suite = new TestSuite(SGCDParallelProxyTest.class); 061 return suite; 062 } 063 064 065 TermOrder to = new TermOrder(TermOrder.INVLEX); 066 067 068 GenSolvablePolynomialRing<BigRational> dfac; 069 070 071 //GenSolvablePolynomialRing<BigRational> cfac; 072 073 074 RecSolvablePolynomialRing<BigRational> rfac; 075 //GenSolvablePolynomialRing<GenPolynomial<BigRational>> rfac; 076 077 078 BigRational ai, bi, ci, di, ei; 079 080 081 GenSolvablePolynomial<BigRational> a, b, c, d, e; 082 083 084 GenSolvablePolynomial<GenPolynomial<BigRational>> ar, br, cr, dr, er; 085 086 087 int rl = 5; 088 089 090 int kl = 5; 091 092 093 int ll = 7; 094 095 096 int el = 3; 097 098 099 float q = 0.3f; 100 101 102 @Override 103 protected void setUp() { 104 a = b = c = d = e = null; 105 ai = bi = ci = di = ei = null; 106 ar = br = cr = dr = er = null; 107 //String[] vars = new String[] { "a1", "a2", "a3", "a4", "a5" }; // #=rl 108 String[] vars = new String[] { "a1", "a2", "a3", "a4" }; // #=rl 109 dfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, vars); 110 //cfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), rl - 1, to); 111 //rfac = new GenSolvablePolynomialRing<GenPolynomial<BigRational>>(cfac, 1, to); 112 rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(1); 113 } 114 115 116 @Override 117 protected void tearDown() { 118 a = b = c = d = e = null; 119 ai = bi = ci = di = ei = null; 120 ar = br = cr = dr = er = null; 121 dfac = null; 122 //cfac = null; 123 rfac = null; 124 //ComputerThreads.terminate(); 125 } 126 127 128 /** 129 * Test get BigRational parallel implementation. 130 */ 131 public void testBigRational() { 132 long t; 133 BigRational bi = new BigRational(); 134 135 GreatestCommonDivisor<BigRational> fd_par; 136 GreatestCommonDivisorAbstract<BigRational> fd; 137 138 fd_par = SGCDFactory.<BigRational> getProxy(bi); 139 //System.out.println("fd_par = " + fd_par); 140 assertTrue("fd_par != null " + fd_par, fd_par != null); 141 142 fd = new GreatestCommonDivisorFake<BigRational>(bi); 143 144 //System.out.println("fd = " + fd); 145 assertTrue("fd != null " + fd, fd != null); 146 147 dfac = new GenSolvablePolynomialRing<BigRational>(bi, 4, to); 148 149 for (int i = 0; i < 1; i++) { // 10-50 150 a = dfac.random(kl + i * 10, ll + i, el, q); 151 b = dfac.random(kl + i * 10, ll + i, el, q); 152 c = dfac.random(kl + 2, ll, el, q); 153 //c = dfac.getONE(); 154 //c = c.multiply( dfac.univariate(0) ); 155 c = (GenSolvablePolynomial<BigRational>) fd.leftPrimitivePart(c).abs(); 156 //System.out.println("a = " + a); 157 //System.out.println("b = " + b); 158 //System.out.println("c = " + c); 159 160 if (a.isZERO() || b.isZERO() || c.isZERO()) { 161 // skip for this turn 162 continue; 163 } 164 assertTrue("length( c" + i + " ) <> 0", c.length() > 0); 165 //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() ); 166 //assertTrue(" not isONE( c"+i+" )", !c.isONE() ); 167 168 a = a.multiply(c); 169 b = b.multiply(c); 170 //System.out.println("a = " + a); 171 //System.out.println("b = " + b); 172 173 t = System.currentTimeMillis(); 174 d = (GenSolvablePolynomial<BigRational>) fd_par.leftGcd(a, b); 175 t = System.currentTimeMillis() - t; 176 assertTrue("time >= 0: " + t, t >= 0); 177 //System.out.println("i proxy time = " + t); 178 //System.out.println("c = " + c); 179 //System.out.println("d = " + d); 180 //System.out.println("e = " + e); 181 182 e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(d, c); 183 //System.out.println("e = " + e); 184 assertTrue("c | gcd(ac,bc) " + e, e.isZERO()); 185 186 // now with right variants: 187 c = (GenSolvablePolynomial<BigRational>) fd.rightPrimitivePart(c).abs(); 188 a = c.multiply(a); 189 b = c.multiply(b); 190 //System.out.println("a = " + a); 191 //System.out.println("b = " + b); 192 //System.out.println("c = " + c); 193 194 t = System.currentTimeMillis(); 195 d = (GenSolvablePolynomial<BigRational>) fd_par.rightGcd(a, b); 196 t = System.currentTimeMillis() - t; 197 assertTrue("time >= 0: " + t, t >= 0); 198 199 e = FDUtil.<BigRational> rightBaseSparsePseudoRemainder(d, c); 200 //System.out.println("e = " + e); 201 assertTrue("c | gcd(ac,bc) " + e, e.isZERO()); 202 } 203 } 204 205 206 /** 207 * Test get ModInteger parallel implementation. 208 */ 209 public void testModInteger() { 210 long t; 211 ModIntegerRing mi = new ModIntegerRing(19, true); 212 //ModIntegerRing mi = new ModIntegerRing(536870909, true); 213 214 GenSolvablePolynomial<ModInteger> a, b, c, d, e; 215 216 GreatestCommonDivisor<ModInteger> fd_par; 217 GreatestCommonDivisorAbstract<ModInteger> fd; 218 219 fd_par = SGCDFactory.<ModInteger> getProxy(mi); 220 //System.out.println("fd_par = " + fd_par); 221 assertTrue("fd_par != null " + fd_par, fd_par != null); 222 223 fd = new GreatestCommonDivisorFake<ModInteger>(mi); 224 225 //System.out.println("fd = " + fd); 226 assertTrue("fd != null " + fd, fd != null); 227 228 GenSolvablePolynomialRing<ModInteger> dfac; 229 dfac = new GenSolvablePolynomialRing<ModInteger>(mi, 4, to); 230 231 for (int i = 0; i < 1; i++) { 232 a = dfac.random(kl + i * 2, ll + i, el, q); 233 b = dfac.random(kl + i * 2, ll + i, el, q); 234 c = dfac.random(kl, ll, el, q); 235 //a = dfac.random(kl,ll+i,el,q); 236 //b = dfac.random(kl,ll+i,el,q); 237 //c = dfac.random(kl,ll,el,q); 238 //c = dfac.getONE(); 239 //c = c.multiply( dfac.univariate(0) ); 240 c = (GenSolvablePolynomial<ModInteger>) fd.leftPrimitivePart(c).abs(); 241 //System.out.println("a = " + a); 242 //System.out.println("b = " + b); 243 //System.out.println("c = " + c); 244 245 if (a.isZERO() || b.isZERO() || c.isZERO()) { 246 // skip for this turn 247 continue; 248 } 249 assertTrue("length( c" + i + " ) <> 0", c.length() > 0); 250 //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() ); 251 //assertTrue(" not isONE( c"+i+" )", !c.isONE() ); 252 253 a = a.multiply(c); 254 b = b.multiply(c); 255 //System.out.println("a = " + a); 256 //System.out.println("b = " + b); 257 258 t = System.currentTimeMillis(); 259 d = (GenSolvablePolynomial<ModInteger>) fd_par.leftGcd(a, b); 260 t = System.currentTimeMillis() - t; 261 assertTrue("time >= 0: " + t, t >= 0); 262 //System.out.println("m proxy time = " + t); 263 //System.out.println("c = " + c); 264 //System.out.println("d = " + d); 265 //System.out.println("e = " + e); 266 267 e = FDUtil.<ModInteger> leftBaseSparsePseudoRemainder(d, c); 268 //System.out.println("e = " + e); 269 assertTrue("c | gcd(ac,bc) " + e + ", " + d + ", " + c, e.isZERO()); 270 271 // now with right variants: 272 c = (GenSolvablePolynomial<ModInteger>) fd.rightPrimitivePart(c).abs(); 273 a = c.multiply(a); 274 b = c.multiply(b); 275 //System.out.println("a = " + a); 276 //System.out.println("b = " + b); 277 //System.out.println("c = " + c); 278 279 t = System.currentTimeMillis(); 280 d = (GenSolvablePolynomial<ModInteger>) fd_par.rightGcd(a, b); 281 t = System.currentTimeMillis() - t; 282 assertTrue("time >= 0: " + t, t >= 0); 283 284 e = FDUtil.<ModInteger> rightBaseSparsePseudoRemainder(d, c); 285 //System.out.println("e = " + e); 286 assertTrue("c | gcd(ac,bc) " + e, e.isZERO()); 287 } 288 } 289 290 291 /** 292 * Test get BigInteger implementation. 293 */ 294 public void testBigInteger() { 295 BigInteger b = new BigInteger(); 296 GreatestCommonDivisor<BigInteger> fd; 297 298 fd = SGCDFactory.<BigInteger> getImplementation(b); 299 //System.out.println("fd = " + fd); 300 assertTrue("fd = Primitive " + fd, fd instanceof GreatestCommonDivisorPrimitive); 301 } 302 303 304 /** 305 * Test get BigComplex implementation. 306 */ 307 public void testBigComplex() { 308 BigComplex b = new BigComplex(); 309 GreatestCommonDivisor<BigComplex> fd; 310 311 fd = SGCDFactory.<BigComplex> getImplementation(b); 312 //System.out.println("fd = " + fd); 313 assertTrue("fd != Simple " + fd, fd instanceof GreatestCommonDivisorSimple); 314 } 315 316 317 /** 318 * Test get BigRational base parallel implementation. 319 */ 320 public void testBigRationalBase() { 321 long t; 322 BigRational bi = new BigRational(); 323 324 GreatestCommonDivisorAbstract<BigRational> fd_par; 325 GreatestCommonDivisorAbstract<BigRational> fd; 326 327 fd_par = SGCDFactory.<BigRational> getProxy(bi); 328 //System.out.println("fd_par = " + fd_par); 329 assertTrue("fd_par != null " + fd_par, fd_par != null); 330 331 fd = new GreatestCommonDivisorFake<BigRational>(bi); 332 333 //System.out.println("fd = " + fd); 334 assertTrue("fd != null " + fd, fd != null); 335 336 int rl = 1; 337 dfac = new GenSolvablePolynomialRing<BigRational>(bi, 1, to); 338 339 for (int i = 0; i < 1; i++) { // 10-50 340 a = dfac.random(kl + i * 10, ll + i, el, q); 341 b = dfac.random(kl + i * 10, ll + i, el, q); 342 c = dfac.random(kl + 2, ll, el, q); 343 //c = dfac.getONE(); 344 //c = c.multiply( dfac.univariate(0) ); 345 c = (GenSolvablePolynomial<BigRational>) fd.leftPrimitivePart(c).abs(); 346 //System.out.println("a = " + a); 347 //System.out.println("b = " + b); 348 //System.out.println("c = " + c); 349 350 if (a.isZERO() || b.isZERO() || c.isZERO()) { 351 // skip for this turn 352 continue; 353 } 354 assertTrue("length( c" + i + " ) <> 0", c.length() > 0); 355 //assertTrue(" not isZERO( c"+i+" )", !c.isZERO() ); 356 //assertTrue(" not isONE( c"+i+" )", !c.isONE() ); 357 358 a = a.multiply(c); 359 b = b.multiply(c); 360 //System.out.println("a = " + a); 361 //System.out.println("b = " + b); 362 363 t = System.currentTimeMillis(); 364 d = (GenSolvablePolynomial<BigRational>) fd_par.leftBaseGcd(a, b); 365 t = System.currentTimeMillis() - t; 366 assertTrue("time >= 0: " + t, t >= 0); 367 //System.out.println("i proxy time = " + t); 368 //System.out.println("c = " + c); 369 //System.out.println("d = " + d); 370 //System.out.println("e = " + e); 371 372 e = FDUtil.<BigRational> leftBaseSparsePseudoRemainder(d, c); 373 //System.out.println("e = " + e); 374 assertTrue("c | gcd(ac,bc) " + e, e.isZERO()); 375 376 // now with right variants: 377 c = (GenSolvablePolynomial<BigRational>) fd.rightPrimitivePart(c).abs(); 378 a = c.multiply(a); 379 b = c.multiply(b); 380 //System.out.println("a = " + a); 381 //System.out.println("b = " + b); 382 //System.out.println("c = " + c); 383 384 t = System.currentTimeMillis(); 385 d = (GenSolvablePolynomial<BigRational>) fd_par.rightBaseGcd(a, b); 386 t = System.currentTimeMillis() - t; 387 assertTrue("time >= 0: " + t, t >= 0); 388 389 e = FDUtil.<BigRational> rightBaseSparsePseudoRemainder(d, c); 390 //System.out.println("e = " + e); 391 assertTrue("c | gcd(ac,bc) " + e, e.isZERO()); 392 } 393 } 394 395 396 /** 397 * Test get BigRational left recursive univariate parallel implementation. 398 */ 399 public void testBigRationalLeftRecursiveUniv() { 400 long t; 401 BigRational bi = new BigRational(); 402 403 GreatestCommonDivisorAbstract<BigRational> fd_par; 404 GreatestCommonDivisorAbstract<BigRational> fd; 405 406 fd_par = SGCDFactory.<BigRational> getProxy(bi); 407 //System.out.println("fd_par = " + fd_par); 408 assertTrue("fd_par != null " + fd_par, fd_par != null); 409 410 fd = new GreatestCommonDivisorFake<BigRational>(bi); 411 412 //System.out.println("fd = " + fd); 413 assertTrue("fd != null " + fd, fd != null); 414 415 for (int i = 0; i < 1; i++) { // 10-50 416 ar = rfac.random(kl + i, ll, el, q); 417 br = rfac.random(kl + i, ll, el, q); 418 cr = rfac.random(kl, ll, el, q); 419 //cr = rfac.getONE(); 420 //cr = c.multiply( rfac.univariate(0) ); 421 cr = (GenSolvablePolynomial<GenPolynomial<BigRational>>) fd.leftRecursivePrimitivePart(cr).abs(); 422 //System.out.println("ar = " + ar); 423 //System.out.println("br = " + br); 424 //System.out.println("cr = " + cr); 425 426 if (ar.isZERO() || br.isZERO() || cr.isZERO()) { 427 // skip for this turn 428 continue; 429 } 430 assertTrue("length( cr" + i + " ) <> 0", cr.length() > 0); 431 //assertTrue(" not isZERO( c"+i+" )", !cr.isZERO() ); 432 //assertTrue(" not isONE( c"+i+" )", !cr.isONE() ); 433 434 ar = ar.multiply(cr); 435 br = br.multiply(cr); 436 //System.out.println("ar = " + ar); 437 //System.out.println("br = " + br); 438 439 t = System.currentTimeMillis(); 440 // left 441 dr = (GenSolvablePolynomial<GenPolynomial<BigRational>>) fd_par.leftRecursiveUnivariateGcd(ar, br); 442 t = System.currentTimeMillis() - t; 443 assertTrue("time >= 0: " + t, t >= 0); 444 //System.out.println("i proxy time = " + t); 445 //System.out.println("cr = " + cr); 446 //System.out.println("dr = " + dr); 447 448 //recursiveLeftSparsePseudoRemainder 449 er = FDUtil.<BigRational> recursiveSparsePseudoRemainder(dr, cr); 450 //System.out.println("er = " + er); 451 assertTrue("c | gcd(ac,bc) " + cr + " ~| " + dr, er.isZERO()||dr.isONE()); 452 } 453 } 454 455 456 /** 457 * Test get BigRational right recursive univariate parallel implementation. 458 */ 459 public void testBigRationalRightRecursiveUniv() { 460 long t; 461 BigRational bi = new BigRational(); 462 463 GreatestCommonDivisorAbstract<BigRational> fd_par; 464 GreatestCommonDivisorAbstract<BigRational> fd; 465 466 fd_par = SGCDFactory.<BigRational> getProxy(bi); 467 //System.out.println("fd_par = " + fd_par); 468 assertTrue("fd_par != null " + fd_par, fd_par != null); 469 470 fd = new GreatestCommonDivisorFake<BigRational>(bi); 471 472 //System.out.println("fd = " + fd); 473 assertTrue("fd != null " + fd, fd != null); 474 475 for (int i = 0; i < 1; i++) { // 10-50 476 ar = rfac.random(kl + i, ll, el, q); 477 br = rfac.random(kl + i, ll, el, q); 478 cr = rfac.random(kl, ll, el, q); 479 //cr = rfac.getONE(); 480 //cr = c.multiply( rfac.univariate(0) ); 481 //System.out.println("ar = " + ar); 482 //System.out.println("br = " + br); 483 //System.out.println("cr = " + cr); 484 485 if (ar.isZERO() || br.isZERO() || cr.isZERO()) { 486 // skip for this turn 487 continue; 488 } 489 assertTrue("length( cr" + i + " ) <> 0", cr.length() > 0); 490 //assertTrue(" not isZERO( c"+i+" )", !cr.isZERO() ); 491 //assertTrue(" not isONE( c"+i+" )", !cr.isONE() ); 492 493 // now with right variants: right! 494 cr = (GenSolvablePolynomial<GenPolynomial<BigRational>>) fd.rightRecursivePrimitivePart(cr).abs(); 495 ar = cr.multiply(ar); 496 br = cr.multiply(br); 497 //System.out.println("ar = " + ar); 498 //System.out.println("br = " + br); 499 //System.out.println("cr = " + cr); 500 501 t = System.currentTimeMillis(); 502 dr = (GenSolvablePolynomial<GenPolynomial<BigRational>>) fd_par.rightRecursiveUnivariateGcd(ar, br); 503 t = System.currentTimeMillis() - t; 504 assertTrue("time >= 0: " + t, t >= 0); 505 //System.out.println("cr = " + cr); 506 //System.out.println("dr = " + dr); 507 508 //recursiveRightSparsePseudoRemainder 509 er = FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(dr, cr); 510 //System.out.println("er = " + er); 511 assertTrue("c | gcd(ca,cb) " + cr + " ~| " + dr, er.isZERO()||dr.isONE()); 512 } 513 } 514 515 516 /** 517 * Test get BigRational left recursive parallel implementation. 518 */ 519 public void testBigRationalLeftRecursive() { 520 long t; 521 BigRational bi = new BigRational(); 522 rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(2); 523 //System.out.println("rfac.gens = " + rfac.generators()); 524 525 GreatestCommonDivisorAbstract<BigRational> fd_par; 526 GreatestCommonDivisorAbstract<BigRational> fd; 527 528 fd_par = SGCDFactory.<BigRational> getProxy(bi); 529 //System.out.println("fd_par = " + fd_par); 530 assertTrue("fd_par != null " + fd_par, fd_par != null); 531 532 fd = new GreatestCommonDivisorFake<BigRational>(bi); 533 534 //System.out.println("fd = " + fd); 535 assertTrue("fd != null " + fd, fd != null); 536 537 for (int i = 0; i < 1; i++) { // 10-50 538 ar = rfac.random(kl + i, ll, el, q); 539 br = rfac.random(kl + i, ll, el, q); 540 cr = rfac.random(kl, ll, el, q); 541 //cr = rfac.getONE(); 542 //cr = c.multiply( rfac.univariate(0) ); 543 cr = (GenSolvablePolynomial<GenPolynomial<BigRational>>) fd.leftRecursivePrimitivePart(cr).abs(); 544 //System.out.println("ar = " + ar); 545 //System.out.println("br = " + br); 546 //System.out.println("cr = " + cr); 547 548 if (ar.isZERO() || br.isZERO() || cr.isZERO()) { 549 // skip for this turn 550 continue; 551 } 552 assertTrue("length( cr" + i + " ) <> 0", cr.length() > 0); 553 //assertTrue(" not isZERO( c"+i+" )", !cr.isZERO() ); 554 //assertTrue(" not isONE( c"+i+" )", !cr.isONE() ); 555 556 ar = ar.multiply(cr); 557 br = br.multiply(cr); 558 //System.out.println("ar = " + ar); 559 //System.out.println("br = " + br); 560 561 t = System.currentTimeMillis(); 562 dr = (GenSolvablePolynomial<GenPolynomial<BigRational>>) fd_par.leftRecursiveGcd(ar, br); 563 t = System.currentTimeMillis() - t; 564 assertTrue("time >= 0: " + t, t >= 0); 565 //System.out.println("i proxy time = " + t); 566 //System.out.println("cr = " + cr); 567 //System.out.println("dr = " + dr); 568 569 //recursiveLeftSparsePseudoRemainder 570 er = FDUtil.<BigRational> recursiveSparsePseudoRemainder(dr, cr); 571 //System.out.println("er = " + er); 572 assertTrue("c | gcd(ac,bc) " + cr + " ~| " + dr, er.isZERO()||dr.isONE()); 573 } 574 } 575 576 577 /** 578 * Test get BigRational right recursive parallel implementation. 579 */ 580 public void testBigRationalRightRecursive() { 581 long t; 582 BigRational bi = new BigRational(); 583 rfac = (RecSolvablePolynomialRing<BigRational>) dfac.recursive(2); 584 //System.out.println("rfac.gens = " + rfac.generators()); 585 586 GreatestCommonDivisorAbstract<BigRational> fd_par; 587 GreatestCommonDivisorAbstract<BigRational> fd; 588 589 fd_par = SGCDFactory.<BigRational> getProxy(bi); 590 //System.out.println("fd_par = " + fd_par); 591 assertTrue("fd_par != null " + fd_par, fd_par != null); 592 593 fd = new GreatestCommonDivisorFake<BigRational>(bi); 594 595 //System.out.println("fd = " + fd); 596 assertTrue("fd != null " + fd, fd != null); 597 598 for (int i = 0; i < 1; i++) { // 10-50 599 ar = rfac.random(kl + i, ll, el, q); 600 br = rfac.random(kl + i, ll, el, q); 601 cr = rfac.random(kl, ll, el, q); 602 //cr = rfac.getONE(); 603 //cr = c.multiply( rfac.univariate(0) ); 604 cr = (GenSolvablePolynomial<GenPolynomial<BigRational>>) fd.rightRecursivePrimitivePart(cr).abs(); 605 //System.out.println("ar = " + ar); 606 //System.out.println("br = " + br); 607 //System.out.println("cr = " + cr); 608 609 if (ar.isZERO() || br.isZERO() || cr.isZERO()) { 610 // skip for this turn 611 continue; 612 } 613 assertTrue("length( cr" + i + " ) <> 0", cr.length() > 0); 614 //assertTrue(" not isZERO( c"+i+" )", !cr.isZERO() ); 615 //assertTrue(" not isONE( c"+i+" )", !cr.isONE() ); 616 617 ar = cr.multiply(ar); 618 br = cr.multiply(br); 619 //System.out.println("ar = " + ar); 620 //System.out.println("br = " + br); 621 622 t = System.currentTimeMillis(); 623 dr = (GenSolvablePolynomial<GenPolynomial<BigRational>>) fd_par.rightRecursiveGcd(ar, br); 624 t = System.currentTimeMillis() - t; 625 assertTrue("time >= 0: " + t, t >= 0); 626 //System.out.println("i proxy time = " + t); 627 //System.out.println("cr = " + cr); 628 //System.out.println("dr = " + dr); 629 630 //recursiveRightSparsePseudoRemainder 631 er = FDUtil.<BigRational> recursiveRightSparsePseudoRemainder(dr, cr); 632 //System.out.println("er = " + er); 633 assertTrue("c | gcd(ca,cb) " + cr + " ~| " + dr, er.isZERO()||dr.isONE()); 634 } 635 } 636 637}