/** * Solve linear ODE. * * @param p * coefficient of degree 1 * @param q * coefficient of degree 0 * @param xVar * variable * @param engine * the evaluation engine * @return <code>F.NIL</code> if the evaluation was not possible */ private IExpr linearODE(IExpr p, IExpr q, IExpr xVar, IExpr C_1, EvalEngine engine) { // integrate p IExpr pInt = engine.evaluate(F.Exp(F.Integrate(p, xVar))); if (q.isZero()) { return engine.evaluate(F.Divide(C_1, pInt)); } else { IExpr qInt = engine.evaluate(F.Plus(C_1, F.Expand(F.Integrate(F.Times(F.CN1, q, pInt), xVar)))); return engine.evaluate(F.Expand(F.Divide(qInt, pInt))); } }
/** * Evaluate <code>Expand()</code> for the given expression. returns the given argument. * * @param a * the expression which should be evaluated * @return the evaluated expression * @see EvalEngine#evaluate(IExpr) */ public static IExpr evalExpand(IExpr a) { IExpr result = EvalEngine.get().evaluate(a); if (result.isAST()) { IAST ast = (IAST) result; if (ast.isPlus()) { for (int i = 1; i < ast.size(); i++) { IExpr temp = ast.get(i); if (temp.isTimes() || temp.isPower() || temp.isPlus()) { return EvalEngine.get().evaluate(Expand(result)); } } return ast; } if (ast.isTimes() || ast.isPower()) { return EvalEngine.get().evaluate(Expand(result)); } } return result; }
/** * Rewrite <code>num*base^exponent</code> at position <code>i</code> in <code>plusAST</code> if the * <code>exponent</code> is a fraction. * * @param plusAST * @param i * @param num * @param base * @param exponent * @return */ private IExpr rewritePowerFractions(IAST plusAST, int i, INumber num, IExpr base, IExpr exponent) { if (exponent.isFraction() || (exponent.isReal() && !exponent.isNumIntValue())) { ISignedNumber arg2 = (ISignedNumber) exponent; if (arg2.isPositive()) { IExpr plus = plusAST.removeAtCopy(i).getOneIdentity(F.C0); if (plus.isPositiveResult()) { // no solution possible return NO_EQUATION_SOLUTION; } fOriginalExpr = plusAST; if (num.isOne()) { return fEngine.evaluate(F.Subtract(F.Expand(F.Power(F.Negate(plus), arg2.inverse())), base)); } return fEngine.evaluate(F.Subtract(base, F.Expand(F.Power(F.Times(num.inverse(), F.Negate(plus)), arg2.inverse())))); } } return F.NIL; }
IInteger n = (IInteger) a.negate(); return F.Divide(F.Expand(F.Pochhammer(F.Subtract(c, b), n)), F.Pochhammer(c, n));
return ast.map(Functors.replace1st(Expand(F.Null)));
return F.Expand(F.LinearSolve(F.ConjugateTranspose(F.Dot(matrixTransposed, matrix)), F.Dot(matrixTransposed, vector))); } catch (final ClassCastException e) {
/** * Check for an applicable inverse function at the given <code>position</code> in the * <code>Plus(..., ,...)</code> expression. * * @param ast * @param arg1 * @return */ private IExpr rewriteInverseFunction(IAST ast, IExpr arg1) { if (ast.isAbs()) { return fEngine.evaluate( F.Expand(F.Times(F.Subtract(ast.arg1(), F.Times(F.CN1, arg1)), F.Subtract(ast.arg1(), arg1)))); } else if (ast.isAST1()) { IASTAppendable inverseFunction = InverseFunction.getUnaryInverseFunction(ast); if (inverseFunction.isPresent()) { fEngine.printMessage("Solve: using of inverse functions may omit some solutions."); // rewrite fNumer inverseFunction.append(arg1); return fEngine.evaluate(F.Subtract(ast.arg1(), inverseFunction)); } } else if (ast.isPower() && ast.base().isSymbol() && ast.exponent().isNumber()) { int position = fListOfVariables.indexOf(ast.base()); if (position > 0) { fEngine.printMessage("Solve: using of inverse functions may omit some solutions."); IAST inverseFunction = F.Power(arg1, ast.exponent().inverse()); return fEngine.evaluate(F.Subtract(ast.base(), inverseFunction)); } } return F.NIL; }
return F.NIL; return engine.evaluate(F.Times(gcd1, F.Expand(F.Times(gcd1.inverse(), plus))));