How to use

selfExpand

method

in

jscl.math.function.Inverse

public Generic derivative(int n) {
  return new Inverse(parameters[0]).selfExpand();
}

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());
  }
}

public Generic derivative(int n) {
  return Constants.Generic.HALF.multiply(new Inverse(selfExpand()).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 new Inverse(
      JsclInteger.valueOf(1).add(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();
}

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(
          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();
}

public Generic antiDerivative(@Nonnull Variable variable) throws NotIntegrableException {
  if (JsclMathEngine.getInstance().getAngleUnits() != AngleUnit.rad) {
    throw new NotIntegrableException(Messages.msg_20, getName());
  }
  final Generic parameter = parameters[0];
  if (parameter.isPolynomial(variable)) {
    final Polynomial polynomial = Polynomial.factory(variable).valueOf(parameter);
    if (polynomial.degree() == 1) {
      final Generic elements[] = polynomial.elements();
      return new Inverse(elements[1]).selfExpand().multiply(antiDerivative(0));
    } else {
      throw new NotIntegrableException(this);
    }
  } else {
    throw new NotIntegrableException(this);
  }
}

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();
}

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();
  }
}