BigInteger an = r.maxNorm();
BigInteger bn = q.maxNorm();
BigInteger n = (an.compareTo(bn) < 0 ? bn : an);
n = n.multiply(cc).multiply(n.fromInteger(2));
// compute degree vectors
ExpVector rdegv = r.degreeVector();
ExpVector qdegv = q.degreeVector();
//compute factor coefficient bounds
BigInteger af = an.multiply(PolyUtil.factorBound(rdegv));
BigInteger bf = bn.multiply(PolyUtil.factorBound(qdegv));
BigInteger cf = (af.compareTo(bf) < 0 ? bf : af);
cf = cf.multiply(cc.multiply(cc.fromInteger(8)));
//initialize prime list and degree vector
PrimeList primes = new PrimeList();
int pn = 10; //primes.size();
ExpVector wdegv = rdegv.subst(0, rdegv.getVal(0) + 1);
// +1 seems to be a hack for the unlucky prime test
ModularRingFactory<MOD> cofac;
ModularRingFactory<MOD> cofacM = null;
GenPolynomial<MOD> qm;
GenPolynomial<MOD> rm;
GenPolynomialRing<MOD> mfac;
GenPolynomialRing<MOD> rfac = null;
int i = 0;
BigInteger M = null;
BigInteger cfe = null;
GenPolynomial<MOD> cp = null;
GenPolynomial<MOD> cm = null;
GenPolynomial<BigInteger> cpi = null;
if (debug) {
}
for (java.math.BigInteger p : primes) {
if (p.longValue() == 2L) { // skip 2
continue;
}
if (++i >= pn) {
return iufd.gcd(P, S);
//throw new ArithmeticException("prime list exhausted");
}
// initialize coefficient factory and map normalization factor
if (ModLongRing.MAX_LONG.compareTo(p) > 0) {
cofac = (ModularRingFactory) new ModLongRing(p, true);
} else {
cofac = (ModularRingFactory) new ModIntegerRing(p, true);
}
MOD nf = cofac.fromInteger(cc.getVal());
if (nf.isZERO()) {
continue;
}
// initialize polynomial factory and map polynomials
mfac = new GenPolynomialRing<>(cofac, fac.nvar, fac.tord, fac.getVars());
qm = PolyUtil.fromIntegerCoefficients(mfac, q);
if (qm.isZERO() || !qm.degreeVector().equals(qdegv)) {
continue;
}
rm = PolyUtil.fromIntegerCoefficients(mfac, r);
if (rm.isZERO() || !rm.degreeVector().equals(rdegv)) {
continue;
}
if (debug) {
}
// compute modular gcd
cm = mufd.gcd(rm, qm);
// test for constant g.c.d
if (cm.isConstant()) {
return fac.getONE().multiply(c);
//return cm.abs().multiply( c );
}
// test for unlucky prime
ExpVector mdegv = cm.degreeVector();
if (wdegv.equals(mdegv)) { // TL = 0
// prime ok, next round
if (M != null) {
if (M.compareTo(cfe) > 0) {
// continue; // why should this be required?
}
}
} else { // TL = 3
boolean ok = false;
if (wdegv.multipleOf(mdegv)) { // TL = 2 // EVMT(wdegv,mdegv)
M = null; // init chinese remainder
ok = true; // prime ok
}
if (mdegv.multipleOf(wdegv)) { // TL = 1 // EVMT(mdegv,wdegv)
continue; // skip this prime
}
if (!ok) {
M = null; // discard chinese remainder and previous work
continue; // prime not ok