@Nonnull public Variable newInstance() { return new Inverse(null); } }
static Generic nth(Generic parameter[]) { int degree = parameter.length - 1; Generic a = new Fraction(parameter[0], parameter[degree]).selfSimplify(); return new Pow( a.negate(), new Inverse(JsclInteger.valueOf(degree)).selfSimplify() ).selfSimplify(); }
public Generic derivative(int n) { return new Inverse( JsclInteger.valueOf(1).add(parameters[0].pow(2)) ).selfExpand(); }
public Generic derivative(int n) { return new Inverse( JsclInteger.valueOf(1).subtract( parameters[0].pow(2) ) ).selfExpand(); }
public Generic derivative(int n) { return new Inverse( JsclInteger.valueOf(1).subtract( parameters[0].pow(2) ) ).selfExpand(); }
public Generic derivative(int n) { return Constants.Generic.THIRD.multiply( new Inverse( selfExpand().pow(2) ).selfExpand() ); }
public Generic derivative(int n) { return new Inverse( JsclInteger.valueOf(1).add(parameters[0].pow(2)) ).selfExpand().negate(); }
public Variable variableValue() throws NotVariableException { try { integerValue(); throw new NotVariableException(); } catch (NotIntegerException e) { if (numerator.compareTo(BigInteger.valueOf(1)) == 0) return new Inverse(new JsclInteger(denominator)); else return new Fraction(new JsclInteger(numerator), new JsclInteger(denominator)); } }
public Generic solve() { if (degree == 1) { return get(0).multiply(new Inverse(get(1)).selfExpand()).negate(); } else return null; }
public Generic selfExpand() { if (parameters[0].compareTo(JsclInteger.valueOf(1)) == 0) { return new Inverse(parameters[1]).selfExpand(); } try { return parameters[0].divide(parameters[1]); } catch (NotDivisibleException e) { } catch (ArithmeticException e) { } return expressionValue(); }
public UnivariatePolynomial antiderivative() { UnivariatePolynomial p = newinstance(); for (int i = degree; i >= 0; i--) { p.put(i + 1, get(i).multiply(new Inverse(JsclInteger.valueOf(i + 1)).selfExpand())); } return p; }
public Generic derivative(int n) { return new Inverse( new Sqrt( JsclInteger.valueOf(1).subtract(parameters[0].pow(2)) ).selfExpand() ).selfExpand(); }
public Generic derivative(int n) { return new Inverse( new Sqrt( JsclInteger.valueOf(1).add( parameters[0].pow(2) ) ).selfExpand() ).selfExpand(); }
public Generic derivative(int n) { return new Inverse( new Sqrt( parameters[0].pow(2).subtract( JsclInteger.valueOf(1) ) ).selfExpand() ).selfExpand(); }
public Generic antiDerivative(@Nonnull Variable variable) throws NotIntegrableException { Generic s = parameters[0]; if (s.isPolynomial(variable)) { Polynomial p = Polynomial.factory(variable).valueOf(s); if (p.degree() == 1) { Generic a[] = p.elements(); return new Inverse(a[1]).selfExpand().multiply(antiDerivative(0)); } else throw new NotIntegrableException(this); } else throw new NotIntegrableException(this); }
public Generic antiDerivative(int n) throws NotIntegrableException { if (n == 0) { return new Pow(parameters[0], parameters[1].add(JsclInteger.valueOf(1))).selfExpand().multiply(new Inverse(parameters[1].add(JsclInteger.valueOf(1))).selfExpand()); } else { return new Pow(parameters[0], parameters[1]).selfExpand().multiply(new Inverse(new Ln(parameters[0]).selfExpand()).selfExpand()); } }
public Generic derivative(int n) { return new Inverse(new Sqrt(JsclInteger.valueOf(1).subtract(parameters[0].pow(2))).selfExpand()).selfExpand().negate(); }
public Generic selfExpand() { if (parameters[0].signum() < 0) { return new Inverse(new Exp(parameters[0].negate()).selfExpand()).selfExpand(); } else if (parameters[0].signum() == 0) { return JsclInteger.valueOf(1); } return expressionValue(); }
void compute(Fraction fraction) { Debug.println("antiDerivative"); Debug.increment(); Generic g[] = fraction.getParameters(); Generic r[] = reduce(g[0], g[1]); r = divideAndRemainder(r[0], r[1]); Generic s = new Inverse(r[2]).selfExpand(); Generic p = r[0].multiply(s); Generic a = r[1].multiply(s); result = p.antiDerivative(factory.variable()).add(hermite(a, g[1])); Debug.decrement(); }