public Generic derivative(int n) { return new Inverse(parameters[0]).selfExpand(); }
public Generic selfExpand() { try { Generic parameter = parameter(); /*try { if (JsclInteger.ZERO.equals(parameter.integerValue())) { throw new ArithmeticException("Division by 0!"); } } catch (NotIntegerException e) { // ok }*/ return JsclInteger.ONE.divide(parameter); } catch (NotDivisibleException e) { } return expressionValue(); }
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(parameters[0].multiply(new Ln(JsclInteger.valueOf(10L)).expressionValue())).expressionValue(); }
@Nonnull public Variable newInstance() { return new Inverse(null); } }
public Root rootValue() throws NotRootException { try { Variable v = parameters[1].variableValue(); if (v instanceof Inverse) { Generic g = ((Inverse) v).parameter(); try { int d = g.integerValue().intValue(); if (d > 0 && d < MAX_ARRAY_SIZE) { Generic a[] = new Generic[d + 1]; a[0] = parameters[0].negate(); for (int i = 1; i < d; i++) { a[i] = ZERO; } a[d] = ONE; return new Root(a, 0); } } catch (NotIntegerException e) { } } } catch (NotVariableException e) { } throw new NotRootException(); }
public Generic parse(@Nonnull Parameters p, Generic previousSumElement) throws ParseException { Generic result = JsclInteger.valueOf(1); Generic s = (Generic) UnsignedFactor.parser.parse(p, previousSumElement); while (true) { try { Generic b = MultiplyOrDivideFactor.multiply.parse(p, null); result = result.multiply(s); s = b; } catch (ParseException e) { try { Generic b = MultiplyOrDivideFactor.divide.parse(p, null); if (s.compareTo(JsclInteger.valueOf(1)) == 0) s = new Inverse(GenericVariable.content(b, true)).expressionValue(); else s = new Fraction(GenericVariable.content(s, true), GenericVariable.content(b, true)).expressionValue(); } catch (ParseException e2) { break; } } } result = result.multiply(s); return result; } }
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 derivative(int n) { if (n == 0) { return new Inverse(parameters[1]).selfExpand(); } else { return parameters[0].multiply(new Inverse(parameters[1]).selfExpand().pow(2).negate()); } }
return new Pow(new Inverse(parameters[0]).selfSimplify(), parameters[1].negate()).selfSimplify(); n[2] ).selfSimplify(), new Inverse( n[1] ).selfSimplify() ).selfSimplify(), n[0]
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 Constants.Generic.HALF.multiply(new Inverse(selfExpand()).selfExpand()); }
public Generic selfSimplify() { return new Inverse(new Exp(parameters[0].negate()).selfSimplify()).selfSimplify(); } else if (parameters[0].signum() == 0) { return JsclInteger.valueOf(1);
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).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 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 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(); }