/**
* Coefficient squarefree factorization.
*
* @param coeff coefficient.
* @return [p_1 -> e_1, ..., p_k -> e_k] with P = prod_{i=1,...,k} p_i^{e_i} and p_i
* squarefree.
*/
@Override
public SortedMap<C, Long> squarefreeFactors(C coeff) {
if (coeff == null) {
return null;
}
SortedMap<C, Long> factors = new TreeMap<C, Long>();
RingFactory<C> cfac = (RingFactory<C>) coeff.factory();
if (aCoFac != null) {
AlgebraicNumber<C> an = (AlgebraicNumber<C>) (Object) coeff;
if (cfac.isFinite()) {
SquarefreeFiniteFieldCharP<C> reng =
(SquarefreeFiniteFieldCharP) SquarefreeFactory.getImplementation(cfac);
SortedMap<C, Long> rfactors = reng.rootCharacteristic(coeff); // ??
logger.info("rfactors,finite = " + rfactors);
factors.putAll(rfactors);
// return factors;
} else {
SquarefreeInfiniteAlgebraicFieldCharP<C> reng =
(SquarefreeInfiniteAlgebraicFieldCharP) SquarefreeFactory.getImplementation(cfac);
SortedMap<AlgebraicNumber<C>, Long> rfactors = reng.squarefreeFactors(an);
logger.info("rfactors,infinite,algeb = " + rfactors);
for (Map.Entry<AlgebraicNumber<C>, Long> me : rfactors.entrySet()) {
AlgebraicNumber<C> c = me.getKey();
if (!c.isONE()) {
C cr = (C) (Object) c;
Long rk = me.getValue(); // rfactors.get(c);
factors.put(cr, rk);
}
}
}
} else if (qCoFac != null) {
Quotient<C> q = (Quotient<C>) (Object) coeff;
SquarefreeInfiniteFieldCharP<C> reng =
(SquarefreeInfiniteFieldCharP) SquarefreeFactory.getImplementation(cfac);
SortedMap<Quotient<C>, Long> rfactors = reng.squarefreeFactors(q);
logger.info("rfactors,infinite = " + rfactors);
for (Map.Entry<Quotient<C>, Long> me : rfactors.entrySet()) {
Quotient<C> c = me.getKey();
if (!c.isONE()) {
C cr = (C) (Object) c;
Long rk = me.getValue(); // rfactors.get(c);
factors.put(cr, rk);
}
}
} else if (cfac.isFinite()) {
SquarefreeFiniteFieldCharP<C> reng =
(SquarefreeFiniteFieldCharP) SquarefreeFactory.getImplementation(cfac);
SortedMap<C, Long> rfactors = reng.rootCharacteristic(coeff); // ??
logger.info("rfactors,finite = " + rfactors);
factors.putAll(rfactors);
// return factors;
} else {
logger.warn("case " + cfac + " not implemented");
}
return factors;
}
/**
* GenPolynomial absolute factorization of a irreducible polynomial.
*
* @param P irreducible! GenPolynomial.
* @return factors container: [p_1,...,p_k] with P = prod_{i=1, ..., k} p_i in K(alpha)[x] for
* suitable alpha and p_i irreducible over L[x], where K \subset K(alpha) \subset L is an
* algebraically closed field over K. <b>Note:</b> K(alpha) not yet minimal.
*/
public Factors<C> factorsAbsoluteIrreducible(GenPolynomial<C> P) {
if (P == null) {
throw new RuntimeException(this.getClass().getName() + " P == null");
}
if (P.isZERO()) {
return new Factors<C>(P);
}
GenPolynomialRing<C> pfac = P.ring; // K[x]
if (pfac.nvar <= 1) {
return baseFactorsAbsoluteIrreducible(P);
}
if (!pfac.coFac.isField()) {
throw new RuntimeException("only for field coefficients");
}
List<GenPolynomial<C>> factors = new ArrayList<GenPolynomial<C>>();
if (P.degree() <= 1) {
return new Factors<C>(P);
}
// find field extension K(alpha)
GenPolynomial<C> up = P;
RingFactory<C> cf = pfac.coFac;
long cr = cf.characteristic().longValue(); // char might be larger
if (cr == 0L) {
cr = Long.MAX_VALUE;
}
long rp = 0L;
for (int i = 0; i < (pfac.nvar - 1); i++) {
rp = 0L;
GenPolynomialRing<C> nfac = pfac.contract(1);
String[] vn = new String[] {pfac.getVars()[pfac.nvar - 1]};
GenPolynomialRing<GenPolynomial<C>> rfac =
new GenPolynomialRing<GenPolynomial<C>>(nfac, 1, pfac.tord, vn);
GenPolynomial<GenPolynomial<C>> upr = PolyUtil.<C>recursive(rfac, up);
// System.out.println("upr = " + upr);
GenPolynomial<C> ep;
do {
if (rp >= cr) {
throw new RuntimeException("elements of prime field exhausted: " + cr);
}
C r = cf.fromInteger(rp); // cf.random(rp);
// System.out.println("r = " + r);
ep = PolyUtil.<C>evaluateMain(nfac, upr, r);
// System.out.println("ep = " + ep);
rp++;
} while (!isSquarefree(ep) /*todo: || ep.degree() <= 1*/); // max deg
up = ep;
pfac = nfac;
}
up = up.monic();
if (debug) {
logger.info("P(" + rp + ") = " + up);
// System.out.println("up = " + up);
}
if (debug && !isSquarefree(up)) {
throw new RuntimeException("not irreducible up = " + up);
}
if (up.degree(0) <= 1) {
return new Factors<C>(P);
}
// find irreducible factor of up
List<GenPolynomial<C>> UF = baseFactorsSquarefree(up);
// System.out.println("UF = " + UF);
FactorsList<C> aUF = baseFactorsAbsoluteSquarefree(up);
// System.out.println("aUF = " + aUF);
AlgebraicNumberRing<C> arfac = aUF.findExtensionField();
// System.out.println("arfac = " + arfac);
long e = up.degree(0);
// search factor polynomial with smallest degree
for (int i = 0; i < UF.size(); i++) {
GenPolynomial<C> upi = UF.get(i);
long d = upi.degree(0);
if (1 <= d && d <= e) {
up = upi;
e = up.degree(0);
}
}
if (up.degree(0) <= 1) {
return new Factors<C>(P);
}
if (debug) {
logger.info("field extension by " + up);
}
List<GenPolynomial<AlgebraicNumber<C>>> afactors =
new ArrayList<GenPolynomial<AlgebraicNumber<C>>>();
// setup field extension K(alpha)
// String[] vars = new String[] { "z_" + Math.abs(up.hashCode() % 1000) };
String[] vars = pfac.newVars("z_");
pfac = pfac.clone();
String[] ovars = pfac.setVars(vars); // side effects!
GenPolynomial<C> aup = pfac.copy(up); // hack to exchange the variables
// AlgebraicNumberRing<C> afac = new AlgebraicNumberRing<C>(aup,true); // since irreducible
AlgebraicNumberRing<C> afac = arfac;
int depth = afac.depth();
// System.out.println("afac = " + afac);
GenPolynomialRing<AlgebraicNumber<C>> pafac =
new GenPolynomialRing<AlgebraicNumber<C>>(afac, P.ring.nvar, P.ring.tord, P.ring.getVars());
// System.out.println("pafac = " + pafac);
// convert to K(alpha)
GenPolynomial<AlgebraicNumber<C>> Pa =
PolyUtil.<C>convertToRecAlgebraicCoefficients(depth, pafac, P);
// System.out.println("Pa = " + Pa);
// factor over K(alpha)
FactorAbstract<AlgebraicNumber<C>> engine = FactorFactory.<C>getImplementation(afac);
afactors = engine.factorsSquarefree(Pa);
if (debug) {
logger.info("K(alpha) factors multi = " + afactors);
// System.out.println("K(alpha) factors = " + afactors);
}
if (afactors.size() <= 1) {
return new Factors<C>(P);
}
// normalize first factor to monic
GenPolynomial<AlgebraicNumber<C>> p1 = afactors.get(0);
AlgebraicNumber<C> p1c = p1.leadingBaseCoefficient();
if (!p1c.isONE()) {
GenPolynomial<AlgebraicNumber<C>> p2 = afactors.get(1);
afactors.remove(p1);
afactors.remove(p2);
p1 = p1.divide(p1c);
p2 = p2.multiply(p1c);
afactors.add(p1);
afactors.add(p2);
}
// recursion for splitting field
// find minimal field extension K(beta) \subset K(alpha)
return new Factors<C>(P, afac, Pa, afactors);
}
/**
* Univariate GenPolynomial algebraic partial fraction decomposition, Rothstein-Trager algorithm.
*
* @param A univariate GenPolynomial, deg(A) < deg(P).
* @param P univariate squarefree GenPolynomial, gcd(A,P) == 1.
* @return partial fraction container.
*/
@Deprecated
public PartialFraction<C> baseAlgebraicPartialFractionIrreducible(
GenPolynomial<C> A, GenPolynomial<C> P) {
if (P == null || P.isZERO()) {
throw new RuntimeException(" P == null or P == 0");
}
// System.out.println("\nP_base_algeb_part = " + P);
GenPolynomialRing<C> pfac = P.ring; // K[x]
if (pfac.nvar > 1) {
// System.out.println("facs_base_irred: univ");
throw new RuntimeException("only for univariate polynomials");
}
if (!pfac.coFac.isField()) {
// System.out.println("facs_base_irred: field");
throw new RuntimeException("only for field coefficients");
}
List<C> cfactors = new ArrayList<C>();
List<GenPolynomial<C>> cdenom = new ArrayList<GenPolynomial<C>>();
List<AlgebraicNumber<C>> afactors = new ArrayList<AlgebraicNumber<C>>();
List<GenPolynomial<AlgebraicNumber<C>>> adenom =
new ArrayList<GenPolynomial<AlgebraicNumber<C>>>();
// P linear
if (P.degree(0) <= 1) {
cfactors.add(A.leadingBaseCoefficient());
cdenom.add(P);
return new PartialFraction<C>(A, P, cfactors, cdenom, afactors, adenom);
}
// deriviative
GenPolynomial<C> Pp = PolyUtil.<C>baseDeriviative(P);
// no: Pp = Pp.monic();
// System.out.println("\nP = " + P);
// System.out.println("Pp = " + Pp);
// Q[t]
String[] vars = new String[] {"t"};
GenPolynomialRing<C> cfac = new GenPolynomialRing<C>(pfac.coFac, 1, pfac.tord, vars);
GenPolynomial<C> t = cfac.univariate(0);
// System.out.println("t = " + t);
// Q[x][t]
GenPolynomialRing<GenPolynomial<C>> rfac =
new GenPolynomialRing<GenPolynomial<C>>(pfac, cfac); // sic
// System.out.println("rfac = " + rfac.toScript());
// transform polynomials to bi-variate polynomial
GenPolynomial<GenPolynomial<C>> Ac = PolyUfdUtil.<C>introduceLowerVariable(rfac, A);
// System.out.println("Ac = " + Ac);
GenPolynomial<GenPolynomial<C>> Pc = PolyUfdUtil.<C>introduceLowerVariable(rfac, P);
// System.out.println("Pc = " + Pc);
GenPolynomial<GenPolynomial<C>> Pcp = PolyUfdUtil.<C>introduceLowerVariable(rfac, Pp);
// System.out.println("Pcp = " + Pcp);
// Q[t][x]
GenPolynomialRing<GenPolynomial<C>> rfac1 = Pc.ring;
// System.out.println("rfac1 = " + rfac1.toScript());
// A - t P'
GenPolynomial<GenPolynomial<C>> tc = rfac1.getONE().multiply(t);
// System.out.println("tc = " + tc);
GenPolynomial<GenPolynomial<C>> At = Ac.subtract(tc.multiply(Pcp));
// System.out.println("At = " + At);
GreatestCommonDivisorSubres<C> engine = new GreatestCommonDivisorSubres<C>();
// = GCDFactory.<C>getImplementation( cfac.coFac );
GreatestCommonDivisorAbstract<AlgebraicNumber<C>> aengine = null;
GenPolynomial<GenPolynomial<C>> Rc = engine.recursiveResultant(Pc, At);
// System.out.println("Rc = " + Rc);
GenPolynomial<C> res = Rc.leadingBaseCoefficient();
// no: res = res.monic();
// System.out.println("\nres = " + res);
SortedMap<GenPolynomial<C>, Long> resfac = baseFactors(res);
// System.out.println("resfac = " + resfac + "\n");
for (GenPolynomial<C> r : resfac.keySet()) {
// System.out.println("\nr(t) = " + r);
if (r.isConstant()) {
continue;
}
// if ( r.degree(0) <= 1L ) {
// System.out.println("warning linear factor in resultant ignored");
// continue;
// //throw new RuntimeException("input not irreducible");
// }
// vars = new String[] { "z_" + Math.abs(r.hashCode() % 1000) };
vars = pfac.newVars("z_");
pfac = pfac.clone();
vars = pfac.setVars(vars);
r = pfac.copy(r); // hack to exchange the variables
// System.out.println("r(z_) = " + r);
AlgebraicNumberRing<C> afac = new AlgebraicNumberRing<C>(r, true); // since irreducible
logger.debug("afac = " + afac.toScript());
AlgebraicNumber<C> a = afac.getGenerator();
// no: a = a.negate();
// System.out.println("a = " + a);
// K(alpha)[x]
GenPolynomialRing<AlgebraicNumber<C>> pafac =
new GenPolynomialRing<AlgebraicNumber<C>>(afac, Pc.ring);
// System.out.println("pafac = " + pafac.toScript());
// convert to K(alpha)[x]
GenPolynomial<AlgebraicNumber<C>> Pa = PolyUtil.<C>convertToAlgebraicCoefficients(pafac, P);
// System.out.println("Pa = " + Pa);
GenPolynomial<AlgebraicNumber<C>> Pap = PolyUtil.<C>convertToAlgebraicCoefficients(pafac, Pp);
// System.out.println("Pap = " + Pap);
GenPolynomial<AlgebraicNumber<C>> Aa = PolyUtil.<C>convertToAlgebraicCoefficients(pafac, A);
// System.out.println("Aa = " + Aa);
// A - a P'
GenPolynomial<AlgebraicNumber<C>> Ap = Aa.subtract(Pap.multiply(a));
// System.out.println("Ap = " + Ap);
if (aengine == null) {
aengine = GCDFactory.<AlgebraicNumber<C>>getImplementation(afac);
// System.out.println("aengine = " + aengine);
}
GenPolynomial<AlgebraicNumber<C>> Ga = aengine.baseGcd(Pa, Ap);
// System.out.println("Ga = " + Ga);
if (Ga.isConstant()) {
// System.out.println("warning constant gcd ignored");
continue;
}
afactors.add(a);
adenom.add(Ga);
// quadratic case
if (P.degree(0) == 2 && Ga.degree(0) == 1) {
GenPolynomial<AlgebraicNumber<C>>[] qra =
PolyUtil.<AlgebraicNumber<C>>basePseudoQuotientRemainder(Pa, Ga);
GenPolynomial<AlgebraicNumber<C>> Qa = qra[0];
if (!qra[1].isZERO()) {
throw new RuntimeException("remainder not zero");
}
// System.out.println("Qa = " + Qa);
afactors.add(a.negate());
adenom.add(Qa);
}
if (false && P.degree(0) == 3 && Ga.degree(0) == 1) {
GenPolynomial<AlgebraicNumber<C>>[] qra =
PolyUtil.<AlgebraicNumber<C>>basePseudoQuotientRemainder(Pa, Ga);
GenPolynomial<AlgebraicNumber<C>> Qa = qra[0];
if (!qra[1].isZERO()) {
throw new RuntimeException("remainder not zero");
}
System.out.println("Qa3 = " + Qa);
// afactors.add( a.negate() );
// adenom.add( Qa );
}
}
return new PartialFraction<C>(A, P, cfactors, cdenom, afactors, adenom);
}