public Generic selfElementary() { return new Ln( new Root( new Generic[]{ JsclInteger.valueOf(-1), JsclInteger.valueOf(2).multiply(parameters[0]), JsclInteger.valueOf(-1) }, 0 ).selfElementary() ).selfElementary(); }
public Generic selfSimplify() { if (isZero()) return JsclInteger.valueOf(0); try { int s = subscript.integerValue().intValue(); switch (degree()) { case 1: return linear(parameters); case 2: return quadratic(parameters, s); case 3: return cubic(parameters, s); case 4: return quartic(parameters, s); default: if (isNth() && s == 0) return nth(parameters); } } catch (NotIntegerException e) { } return expressionValue(); }
public Generic substitute(@Nonnull Variable variable, @Nonnull Generic generic) { Root v = (Root) newInstance(); for (int i = 0; i < parameters.length; i++) { v.parameters[i] = parameters[i].substitute(variable, generic); } v.subscript = subscript.substitute(variable, generic); if (v.isIdentity(variable)) return generic; else return v.selfExpand(); }
Sigma(Generic parameter[], int n) { root = new Generic[parameter.length - 1]; for (int i = 0; i < root.length; i++) root[i] = new Root(parameter, i).expressionValue(); place = new boolean[root.length]; this.n = n; }
public Generic factorize() { Root v = (Root) newInstance(); for (int i = 0; i < parameters.length; i++) { v.parameters[i] = parameters[i].factorize(); } v.subscript = subscript; return v.expressionValue(); }
int d = r.degree(); final Generic parameters[] = r.getParameters(); result = new Constraint(v, v.expressionValue().pow(d).subtract(parameters[0].negate()), d > 1); try { Root r = (Root) v; int d = r.degree(); int n = r.subscript().integerValue().intValue(); final Generic parameters[] = r.getParameters(); result = new Constraint(v, Root.sigma(parameters, d - n).multiply(JsclInteger.valueOf(-1).pow(d - n)).multiply(parameters[d]).subtract(parameters[n]), d > 1);
public Generic selfExpand() { if (isZero()) return JsclInteger.valueOf(0); try { int s = subscript.integerValue().intValue(); switch (degree()) { case 1: return new Fraction(parameters[0], parameters[1]).selfExpand().negate(); } } catch (NotIntegerException e) { } return expressionValue(); }
public static Generic compute(Root root, Variable variable) throws NotIntegrableException { int d = root.degree(); Generic a[] = root.getParameters(); boolean b = d > 0; b = b && a[0].negate().isIdentity(variable); for (int i = 1; i < d; i++) b = b && a[i].signum() == 0; b = b && a[d].compareTo(JsclInteger.valueOf(1)) == 0; if (b) { return new Pow( a[0].negate(), new Inverse(JsclInteger.valueOf(d)).selfExpand() ).antiDerivative(0); } else { throw new NotIntegrableException(); } }
@Nonnull public Generic derivative(@Nonnull Variable variable) { if (compareTo(variable) == 0) { return JsclInteger.valueOf(1); } else { Variable t = new TechnicalVariable("t"); Generic a[] = new Generic[parameters.length]; for (int i = 0; i < parameters.length; i++) a[i] = parameters[i].derivative(variable); UnivariatePolynomial fact = (UnivariatePolynomial) Polynomial.factory(this); UnivariatePolynomial p = fact.valueof(parameters); UnivariatePolynomial q = (UnivariatePolynomial) p.derivative().multiply(t.expressionValue()).add(fact.valueof(a)); UnivariatePolynomial r = (UnivariatePolynomial) Polynomial.factory(t).valueOf(p.resultant(q)); return new Root(r.elements(), subscript).selfExpand(); } }
public Generic selfExpand() { final Variable variable = parameters[1].variableValue(); int subscript = parameters[2].integerValue().intValue(); if (parameters[0].isPolynomial(variable)) { return new Root((UnivariatePolynomial) Polynomial.factory(variable).valueOf(parameters[0]), subscript).selfExpand(); } return expressionValue(); }
@Nonnull public Variable newInstance() { return new Root(new Generic[parameters.length], null); } }
void linear(Generic generic) { Variable t = new TechnicalVariable("t"); linear = true; constraints.clear(); process(new Constraint(t, t.expressionValue().subtract(generic), false)); UnivariatePolynomial p = polynomial(t); switch (p.degree()) { case 0: result = generic; break; default: result = new Root(p, 0).selfSimplify(); } }
public Generic antiDerivative(@Nonnull Variable variable) throws NotIntegrableException { Root r = rootValue(); Generic g[] = r.getParameters(); if (g[0].isPolynomial(variable)) { return AntiDerivative.compute(r, variable); } else { throw new NotIntegrableException(this); } }
public Generic selfExpand() { if (parameters[0].compareTo(JsclInteger.valueOf(1)) == 0) { return JsclInteger.valueOf(1); } if (parameters[1].signum() < 0) { return new Pow(new Inverse(parameters[0]).selfExpand(), parameters[1].negate()).selfExpand(); } try { int c = parameters[1].integerValue().intValue(); return parameters[0].pow(c); } catch (NotIntegerException e) { } try { Root r = rootValue(); int d = r.degree(); Generic g[] = r.getParameters(); Generic a = g[0].negate(); try { JsclInteger en = a.integerValue(); if (en.signum() < 0) ; else { Generic rt = en.nthrt(d); if (rt.pow(d).compareTo(en) == 0) return rt; } } catch (NotIntegerException e) { } } catch (NotRootException e) { } return expressionValue(); }
Generic trager(Generic a, Generic d) { Debug.println("trager(" + a + ", " + d + ")"); Variable t = new TechnicalVariable("t"); UnivariatePolynomial pd = (UnivariatePolynomial) factory.valueOf(d); UnivariatePolynomial pa = (UnivariatePolynomial) factory.valueOf(a).subtract(pd.derivative().multiply(t.expressionValue())); UnivariatePolynomial rs[] = pd.remainderSequence(pa); Polynomial fact = UnivariatePolynomial.factory(t); for (int i = 0; i < rs.length; i++) if (rs[i] != null) rs[i] = (UnivariatePolynomial) fact.valueOf((i > 0 ? rs[i].normalize() : rs[i]).genericValue()); UnivariatePolynomial q[] = rs[0].squarefreeDecomposition(); int m = q.length - 1; Generic s = JsclInteger.valueOf(0); for (int i = 1; i <= m; i++) { for (int j = 0; j < q[i].degree(); j++) { Generic a2 = new Root(q[i], j).selfExpand(); s = s.add(a2.multiply(new Ln(i == pd.degree() ? d : rs[i].substitute(a2)).selfExpand())); } } return s; }
public Root rootValue() { return new Root(new Generic[]{parameters[0].negate(), parameters[1]}, 0); }
int branch(Generic generic, UnivariatePolynomial polynomial) { int n = polynomial.degree(); Variable t = new TechnicalVariable("t"); linear = true; for (int i = 0; i < n; i++) { constraints.clear(); process(new Constraint(t, t.expressionValue().subtract(generic.subtract(new Root(polynomial, i).expressionValue())), false)); Generic a = polynomial(t).solve(); if (a != null && a.signum() == 0) { return i; } } return n; }
void computeValue(Generic generic) { Debug.println("simplification"); Debug.increment(); final Variable t = new TechnicalVariable("t"); linear = false; process(new Constraint(t, t.expressionValue().subtract(generic), false)); UnivariatePolynomial p = polynomial(t); switch (p.degree()) { case 0: result = generic; break; case 1: result = new Root(p, 0).selfSimplify(); break; // case 2: // int n=branch(generic,p); // if(n<p.degree()) linear(new Root(p,n).expressionValue()); // else linear(generic); // break; default: linear(generic); } Debug.decrement(); }
public Generic antiDerivative(@Nonnull Variable variable) throws NotIntegrableException { Root r = rootValue(); Generic g[] = r.getParameters(); if (g[0].isPolynomial(variable)) { return AntiDerivative.compute(r, variable); } else throw new NotIntegrableException(this); }