static Generic linear(Generic parameter[]) { Generic a = new Fraction(parameter[0], parameter[1]).selfSimplify(); return a.negate(); }
void bodyToMathML(MathML element, boolean fenced) { if (fenced) { MathML e1 = element.element("mfenced"); bodyToMathML(e1); element.appendChild(e1); } else { bodyToMathML(element); } }
static int value(Variable v) { int n; if (v instanceof TechnicalVariable) n = 0; else if (v instanceof IntegerVariable) n = 1; else if (v instanceof DoubleVariable) n = 2; else if (v instanceof Fraction && ((Fraction) v).integer()) n = 3; else if (v instanceof Sqrt && ((Sqrt) v).imaginary()) n = 4; else if (v instanceof Constant) n = 5; else if (v instanceof Root) n = 6; else if (v instanceof Algebraic) n = 7; else if (v instanceof ImplicitFunction) n = 8; else if (v instanceof Function) n = 9; else if (v instanceof Factorial) n = 10; else if (v instanceof Operator) n = 11; else if (v instanceof ExpressionVariable) n = 12; else if (v instanceof VectorVariable) n = 13; else if (v instanceof MatrixVariable) n = 14; else throw new ArithmeticException("Forget to add compare object of type: " + v.getClass()); return n; } }
public Generic selfSimplify() { if (parameters[0].signum() < 0) { return new Fraction(parameters[0].negate(), parameters[1]).selfSimplify().negate(); } if (parameters[1].signum() < 0) { return new Fraction(parameters[0].negate(), parameters[1].negate()).selfSimplify(); } return selfExpand(); }
public Generic selfElementary() { return new Fraction(parameters[0], new Abs(parameters[0]).selfElementary()).selfElementary(); }
@Nullable private Generic simplifyFractions() { final Generic n[] = Fraction.separateCoefficient(parameters[0]); if (n[0].compareTo(JsclInteger.valueOf(1)) != 0 || n[1].compareTo(JsclInteger.valueOf(1)) != 0) { // n final Generic numerator = new Sqrt(n[0]).selfSimplify(); // d final Generic denominator = new Sqrt(n[1]).selfSimplify(); // fraction = n / d final Generic fraction = new Fraction(numerator, denominator).selfSimplify(); return new Sqrt(n[2]).selfSimplify().multiply(fraction); } return null; }
Generic n[] = separateCoefficient(generic.negate()); return new Generic[]{n[0], n[1], n[2].negate()}; final Variable v = generic.variableValue(); if (v instanceof Fraction) { final Generic parameters[] = ((Fraction) v).getParameters(); return new Generic[]{na[0], nd[0], new Fraction(na[1], nd[1]).selfExpand()};
@Nonnull public Generic divide(@Nonnull Generic that) throws NotDivisibleException { if (that instanceof JsclVector) { throw new ArithmeticException("Unable to divide vector by vector!"); } else if (that instanceof Matrix) { return multiply(that.inverse()); } else { final JsclVector result = (JsclVector) newInstance(); for (int i = 0; i < rows; i++) { try { result.elements[i] = elements[i].divide(that); } catch (NotDivisibleException e) { result.elements[i] = new Fraction(elements[i], that).selfExpand(); } } return result; } }
public Generic antiDerivative(int n) throws NotIntegrableException { // tmp = ln(x) - 1 final Generic tmp = new Ln(parameters[0]).expressionValue().subtract(ONE); // ln10 = ln (10) final Generic ln10 = new Ln(JsclInteger.valueOf(10L)).expressionValue(); return new Fraction(parameters[0].multiply(tmp), ln10).expressionValue(); }
public Generic valueOf(Generic generic) { if (generic instanceof Rational) { Rational r = (Rational) generic; return new Rational(r.numerator, r.denominator); } else if (generic instanceof Expression) { boolean sign = generic.signum() < 0; Generic g[] = ((Fraction) (sign ? generic.negate() : generic).variableValue()).getParameters(); JsclInteger numerator = (JsclInteger) (sign ? g[0].negate() : g[0]); JsclInteger denominator = (JsclInteger) g[1]; return new Rational(numerator.content(), denominator.content()); } else { JsclInteger en = (JsclInteger) generic; return new Rational(en.content(), BigInteger.valueOf(1)); } }
public Generic selfSimplify() { Generic coefficents[] = Fraction.separateCoefficient(parameters[0]); final Generic a = coefficents[0]; final Generic b = coefficents[1]; final Generic c = coefficents[2]; final boolean aOne = a.compareTo(ONE) == 0; final boolean bOne = b.compareTo(ONE) == 0; final boolean cOne = c.compareTo(ONE) == 0; if (aOne && bOne && cOne) { return ZERO; } else { if (aOne && bOne) { return expressionValue(); } else if (bOne && cOne) { return expressionValue(); } else { // lg ( a * c / b ) = lg ( c ) + lg( a ) - lg (b) final Generic lga = lg(a, aOne); final Generic lgb = lg(b, bOne); final Generic lgc = lg(c, cOne); return lgc.add(lga).subtract(lgb); } } }
@Nonnull public Variable newInstance() { return new Fraction(null, null); } }
public Generic selfElementary() { return selfExpand(); }
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(); }
Generic n[] = Fraction.separateCoefficient(parameters[0]); if (n[0].compareTo(JsclInteger.valueOf(1)) == 0 && n[1].compareTo(JsclInteger.valueOf(1)) == 0) ; else return new Pow( new Exp(n[2]).selfSimplify(), new Fraction(n[0], n[1]).selfSimplify() ).selfSimplify(); return expressionValue();
public Generic selfElementary() { return new Fraction( new Sinh(parameters[0]).selfElementary(), new Cosh(parameters[0]).selfElementary() ).selfElementary(); }
@Nonnull public Generic divide(@Nonnull Generic that) throws NotDivisibleException { if (that instanceof Matrix) { return multiply(that.inverse()); } else if (that instanceof JsclVector) { throw new ArithmeticException("Unable to divide matrix by vector: matrix could not be divided by vector!"); } else { Matrix m = (Matrix) newInstance(); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { try { m.elements[i][j] = elements[i][j].divide(that); } catch (NotDivisibleException e) { m.elements[i][j] = new Fraction(elements[i][j], that).selfExpand(); } } } return m; } }
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; } }
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(); }
Generic n[] = Fraction.separateCoefficient(parameters[0]); if (n[0].compareTo(JsclInteger.valueOf(1)) == 0 && n[1].compareTo(JsclInteger.valueOf(1)) == 0) ; else return new Ln(n[2]).selfSimplify().add(