/** * Univariate GenPolynomial algebraic partial fraction decomposition, Absolute factorization or * Rothstein-Trager algorithm. * * @param A univariate GenPolynomial, deg(A) < deg(P). * @param P univariate squarefree GenPolynomial, gcd(A,P) == 1. * @return partial fraction container. */ public PartialFraction<C> baseAlgebraicPartialFraction(GenPolynomial<C> A, GenPolynomial<C> P) { if (P == null || P.isZERO()) { throw new RuntimeException(" P == null or P == 0"); } if (A == null || A.isZERO()) { throw new RuntimeException(" A == null or A == 0"); // PartialFraction(A,P,al,pl,empty,empty) } // 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); } List<GenPolynomial<C>> Pfac = baseFactorsSquarefree(P); // System.out.println("\nPfac = " + Pfac); List<GenPolynomial<C>> Afac = engine.basePartialFraction(A, Pfac); GenPolynomial<C> A0 = Afac.remove(0); if (!A0.isZERO()) { throw new RuntimeException(" A0 != 0: deg(A)>= deg(P)"); } // algebraic and linear factors int i = 0; for (GenPolynomial<C> pi : Pfac) { GenPolynomial<C> ai = Afac.get(i++); if (pi.degree(0) <= 1) { cfactors.add(ai.leadingBaseCoefficient()); cdenom.add(pi); continue; } PartialFraction<C> pf = baseAlgebraicPartialFractionIrreducibleAbsolute(ai, pi); // PartialFraction<C> pf = baseAlgebraicPartialFractionIrreducible(ai,pi); cfactors.addAll(pf.cfactors); cdenom.addAll(pf.cdenom); afactors.addAll(pf.afactors); adenom.addAll(pf.adenom); } return new PartialFraction<C>(A, P, cfactors, cdenom, afactors, adenom); }
// @Override public FactorsList<C> baseFactorsAbsoluteSquarefree(GenPolynomial<C> P) { if (P == null) { throw new RuntimeException(this.getClass().getName() + " P == null"); } List<GenPolynomial<C>> factors = new ArrayList<GenPolynomial<C>>(); if (P.isZERO()) { return new FactorsList<C>(P, factors); } // System.out.println("\nP_base_sqf = " + P); GenPolynomialRing<C> pfac = P.ring; // K[x] if (pfac.nvar > 1) { // System.out.println("facs_base_sqf: univ"); throw new RuntimeException("only for univariate polynomials"); } if (!pfac.coFac.isField()) { // System.out.println("facs_base_sqf: field"); throw new RuntimeException("only for field coefficients"); } if (P.degree(0) <= 1) { factors.add(P); return new FactorsList<C>(P, factors); } // factor over K (=C) List<GenPolynomial<C>> facs = baseFactorsSquarefree(P); // System.out.println("facs_base_irred = " + facs); if (debug && !isFactorization(P, facs)) { throw new RuntimeException("isFactorization = false"); } if (logger.isInfoEnabled()) { logger.info("all K factors = " + facs); // Q[X] // System.out.println("\nall K factors = " + facs); // Q[X] } // factor over K(alpha) List<Factors<C>> afactors = new ArrayList<Factors<C>>(); for (GenPolynomial<C> p : facs) { // System.out.println("facs_base_sqf_p = " + p); if (p.degree(0) <= 1) { factors.add(p); } else { Factors<C> afacs = baseFactorsAbsoluteIrreducible(p); // System.out.println("afacs_base_sqf = " + afacs); if (logger.isInfoEnabled()) { logger.info("K(alpha) factors = " + afacs); // K(alpha)[X] } afactors.add(afacs); } } // System.out.println("K(alpha) factors = " + factors); return new FactorsList<C>(P, factors, afactors); }
/** * GenPolynomial absolute factorization of a polynomial. * * @param P GenPolynomial. * @return factors map container: [p_1 -> e_1, ..., p_k -> e_k] with P = prod_{i=1,...,k} * p_i**e_i. <b>Note:</b> K(alpha) not yet minimal. */ public FactorsMap<C> factorsAbsolute(GenPolynomial<C> P) { if (P == null) { throw new RuntimeException(this.getClass().getName() + " P == null"); } SortedMap<GenPolynomial<C>, Long> factors = new TreeMap<GenPolynomial<C>, Long>(); if (P.isZERO()) { return new FactorsMap<C>(P, factors); } // System.out.println("\nP_mult = " + P); GenPolynomialRing<C> pfac = P.ring; // K[x] if (pfac.nvar <= 1) { return baseFactorsAbsolute(P); } if (!pfac.coFac.isField()) { throw new RuntimeException("only for field coefficients"); } if (P.degree() <= 1) { factors.put(P, 1L); return new FactorsMap<C>(P, factors); } // factor over K (=C) SortedMap<GenPolynomial<C>, Long> facs = factors(P); if (debug && !isFactorization(P, facs)) { throw new RuntimeException("isFactorization = false"); } if (logger.isInfoEnabled()) { logger.info("all K factors = " + facs); // Q[X] // System.out.println("\nall K factors = " + facs); // Q[X] } SortedMap<Factors<C>, Long> afactors = new TreeMap<Factors<C>, Long>(); // factor over K(alpha) for (GenPolynomial<C> p : facs.keySet()) { Long e = facs.get(p); if (p.degree() <= 1) { factors.put(p, e); } else { Factors<C> afacs = factorsAbsoluteIrreducible(p); if (afacs.afac == null) { // absolute irreducible factors.put(p, e); } else { afactors.put(afacs, e); } } } // System.out.println("K(alpha) factors multi = " + factors); return new FactorsMap<C>(P, factors, afactors); }
/** * 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, via absolute factorization * to linear factors. * * @param A univariate GenPolynomial, deg(A) < deg(P). * @param P univariate squarefree GenPolynomial, gcd(A,P) == 1. * @return partial fraction container. */ public PartialFraction<C> baseAlgebraicPartialFractionIrreducibleAbsolute( 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); } // non linear case Factors<C> afacs = factorsAbsoluteIrreducible(P); // System.out.println("linear algebraic factors = " + afacs); // System.out.println("afactors = " + afacs.afactors); // System.out.println("arfactors = " + afacs.arfactors); // System.out.println("arfactors pol = " + afacs.arfactors.get(0).poly); // System.out.println("arfactors2 = " + afacs.arfactors.get(0).afactors); List<GenPolynomial<AlgebraicNumber<C>>> fact = afacs.getFactors(); // System.out.println("factors = " + fact); GenPolynomial<AlgebraicNumber<C>> Pa = afacs.apoly; GenPolynomial<AlgebraicNumber<C>> Aa = PolyUtil.<C>convertToRecAlgebraicCoefficients(1, Pa.ring, A); GreatestCommonDivisorAbstract<AlgebraicNumber<C>> aengine = GCDFactory.getProxy(afacs.afac); // System.out.println("denom = " + Pa); // System.out.println("numer = " + Aa); List<GenPolynomial<AlgebraicNumber<C>>> numers = aengine.basePartialFraction(Aa, fact); // System.out.println("part frac = " + numers); GenPolynomial<AlgebraicNumber<C>> A0 = numers.remove(0); if (!A0.isZERO()) { throw new RuntimeException(" A0 != 0: deg(A)>= deg(P)"); } int i = 0; for (GenPolynomial<AlgebraicNumber<C>> fa : fact) { GenPolynomial<AlgebraicNumber<C>> an = numers.get(i++); if (fa.degree(0) <= 1) { afactors.add(an.leadingBaseCoefficient()); adenom.add(fa); continue; } System.out.println("fa = " + fa); Factors<AlgebraicNumber<C>> faf = afacs.getFactor(fa); System.out.println("faf = " + faf); List<GenPolynomial<AlgebraicNumber<AlgebraicNumber<C>>>> fafact = faf.getFactors(); GenPolynomial<AlgebraicNumber<AlgebraicNumber<C>>> Aaa = PolyUtil.<AlgebraicNumber<C>>convertToRecAlgebraicCoefficients(1, faf.apoly.ring, an); GreatestCommonDivisorAbstract<AlgebraicNumber<AlgebraicNumber<C>>> aaengine = GCDFactory.getImplementation(faf.afac); List<GenPolynomial<AlgebraicNumber<AlgebraicNumber<C>>>> anumers = aaengine.basePartialFraction(Aaa, fafact); System.out.println("algeb part frac = " + anumers); GenPolynomial<AlgebraicNumber<AlgebraicNumber<C>>> A0a = anumers.remove(0); if (!A0a.isZERO()) { throw new RuntimeException(" A0 != 0: deg(A)>= deg(P)"); } int k = 0; for (GenPolynomial<AlgebraicNumber<AlgebraicNumber<C>>> faa : fafact) { GenPolynomial<AlgebraicNumber<AlgebraicNumber<C>>> ana = anumers.get(k++); System.out.println("faa = " + faa); System.out.println("ana = " + ana); if (faa.degree(0) > 1) { throw new RuntimeException(" faa not linear"); } GenPolynomial<AlgebraicNumber<C>> ana1 = (GenPolynomial<AlgebraicNumber<C>>) (GenPolynomial) ana; GenPolynomial<AlgebraicNumber<C>> faa1 = (GenPolynomial<AlgebraicNumber<C>>) (GenPolynomial) faa; afactors.add(ana1.leadingBaseCoefficient()); adenom.add(faa1); } } return new PartialFraction<C>(A, P, cfactors, cdenom, afactors, adenom); }
/** * 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); }
/** * GenPolynomial base absolute factorization of a irreducible polynomial. * * @param P irreducible! univariate 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> baseFactorsAbsoluteIrreducible(GenPolynomial<C> P) { if (P == null) { throw new RuntimeException(this.getClass().getName() + " P == null"); } if (P.isZERO()) { return new Factors<C>(P); } // System.out.println("\nP_base_irred = " + 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"); } if (P.degree(0) <= 1) { return new Factors<C>(P); } // setup field extension K(alpha) where alpha = z_xx // String[] vars = new String[] { "z_" + Math.abs(P.hashCode() % 1000) }; String[] vars = pfac.newVars("z_"); pfac = pfac.clone(); vars = pfac.setVars(vars); GenPolynomial<C> aP = pfac.copy(P); // hack to exchange the variables AlgebraicNumberRing<C> afac = new AlgebraicNumberRing<C>(aP, true); // since irreducible if (logger.isInfoEnabled()) { logger.info("K(alpha) = " + afac); logger.info("K(alpha) = " + afac.toScript()); // System.out.println("K(alpha) = " + afac); } GenPolynomialRing<AlgebraicNumber<C>> pafac = new GenPolynomialRing<AlgebraicNumber<C>>(afac, aP.ring.nvar, aP.ring.tord, /*old*/ vars); // convert to K(alpha) GenPolynomial<AlgebraicNumber<C>> Pa = PolyUtil.<C>convertToAlgebraicCoefficients(pafac, P); if (logger.isInfoEnabled()) { logger.info("P over K(alpha) = " + Pa); // logger.info("P over K(alpha) = " + Pa.toScript()); // System.out.println("P in K(alpha) = " + Pa); } // factor over K(alpha) FactorAbstract<AlgebraicNumber<C>> engine = FactorFactory.<C>getImplementation(afac); // System.out.println("K(alpha) engine = " + engine); List<GenPolynomial<AlgebraicNumber<C>>> factors = engine.baseFactorsSquarefree(Pa); // System.out.println("factors = " + factors); if (logger.isInfoEnabled()) { logger.info("factors over K(alpha) = " + factors); // System.out.println("factors over K(alpha) = " + factors); } List<GenPolynomial<AlgebraicNumber<C>>> faca = new ArrayList<GenPolynomial<AlgebraicNumber<C>>>(factors.size()); ; List<Factors<AlgebraicNumber<C>>> facar = new ArrayList<Factors<AlgebraicNumber<C>>>(); for (GenPolynomial<AlgebraicNumber<C>> fi : factors) { if (fi.degree(0) <= 1) { faca.add(fi); } else { // System.out.println("fi.deg > 1 = " + fi); FactorAbsolute<AlgebraicNumber<C>> aengine = (FactorAbsolute<AlgebraicNumber<C>>) FactorFactory.<C>getImplementation(afac); Factors<AlgebraicNumber<C>> fif = aengine.baseFactorsAbsoluteIrreducible(fi); // System.out.println("fif = " + fif); facar.add(fif); } } if (facar.size() == 0) { facar = null; } // find minimal field extension K(beta) \subset K(alpha) return new Factors<C>(P, afac, Pa, faca, facar); }
/** * GenPolynomial polynomial squarefree factorization. * * @param A GenPolynomial. * @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<GenPolynomial<C>, Long> baseSquarefreeFactors(GenPolynomial<C> A) { SortedMap<GenPolynomial<C>, Long> sfactors = new TreeMap<GenPolynomial<C>, Long>(); if (A == null || A.isZERO()) { return sfactors; } GenPolynomialRing<C> pfac = A.ring; if (A.isConstant()) { C coeff = A.leadingBaseCoefficient(); // System.out.println("coeff = " + coeff + " @ " + coeff.factory()); SortedMap<C, Long> rfactors = squarefreeFactors(coeff); // System.out.println("rfactors,const = " + rfactors); if (rfactors != null && rfactors.size() > 0) { for (Map.Entry<C, Long> me : rfactors.entrySet()) { C c = me.getKey(); if (!c.isONE()) { GenPolynomial<C> cr = pfac.getONE().multiply(c); Long rk = me.getValue(); // rfactors.get(c); sfactors.put(cr, rk); } } } else { sfactors.put(A, 1L); } return sfactors; } if (pfac.nvar > 1) { throw new IllegalArgumentException( this.getClass().getName() + " only for univariate polynomials"); } C ldbcf = A.leadingBaseCoefficient(); if (!ldbcf.isONE()) { A = A.divide(ldbcf); SortedMap<C, Long> rfactors = squarefreeFactors(ldbcf); // System.out.println("rfactors,ldbcf = " + rfactors); if (rfactors != null && rfactors.size() > 0) { for (Map.Entry<C, Long> me : rfactors.entrySet()) { C c = me.getKey(); if (!c.isONE()) { GenPolynomial<C> cr = pfac.getONE().multiply(c); Long rk = me.getValue(); // rfactors.get(c); sfactors.put(cr, rk); } } } else { GenPolynomial<C> f1 = pfac.getONE().multiply(ldbcf); // System.out.println("gcda sqf f1 = " + f1); sfactors.put(f1, 1L); } ldbcf = pfac.coFac.getONE(); } GenPolynomial<C> T0 = A; long e = 1L; GenPolynomial<C> Tp; GenPolynomial<C> T = null; GenPolynomial<C> V = null; long k = 0L; long mp = 0L; boolean init = true; while (true) { // System.out.println("T0 = " + T0); if (init) { if (T0.isConstant() || T0.isZERO()) { break; } Tp = PolyUtil.<C>baseDeriviative(T0); T = engine.baseGcd(T0, Tp); T = T.monic(); V = PolyUtil.<C>basePseudoDivide(T0, T); // System.out.println("iT0 = " + T0); // System.out.println("iTp = " + Tp); // System.out.println("iT = " + T); // System.out.println("iV = " + V); // System.out.println("const(iV) = " + V.isConstant()); k = 0L; mp = 0L; init = false; } if (V.isConstant()) { mp = pfac.characteristic().longValue(); // assert != 0 // T0 = PolyUtil.<C> baseModRoot(T,mp); T0 = baseRootCharacteristic(T); logger.info("char root: T0 = " + T0 + ", T = " + T); if (T0 == null) { // break; T0 = pfac.getZERO(); } e = e * mp; init = true; continue; } k++; if (mp != 0L && k % mp == 0L) { T = PolyUtil.<C>basePseudoDivide(T, V); System.out.println("k = " + k); // System.out.println("T = " + T); k++; } GenPolynomial<C> W = engine.baseGcd(T, V); W = W.monic(); GenPolynomial<C> z = PolyUtil.<C>basePseudoDivide(V, W); // System.out.println("W = " + W); // System.out.println("z = " + z); V = W; T = PolyUtil.<C>basePseudoDivide(T, V); // System.out.println("V = " + V); // System.out.println("T = " + T); if (z.degree(0) > 0) { if (ldbcf.isONE() && !z.leadingBaseCoefficient().isONE()) { z = z.monic(); logger.info("z,monic = " + z); } sfactors.put(z, (e * k)); } } // look, a stupid error: // if ( !ldbcf.isONE() ) { // GenPolynomial<C> f1 = sfactors.firstKey(); // long e1 = sfactors.remove(f1); // System.out.println("gcda sqf c = " + c); // f1 = f1.multiply(c); // //System.out.println("gcda sqf f1e = " + f1); // sfactors.put(f1,e1); // } logger.info("exit char root: T0 = " + T0 + ", T = " + T); return sfactors; }