/** * Evaluate an expression. If evaluation is not possible return the input * object. * * @param expr * the expression which should be evaluated * @return the evaluated object * @see EvalEngine#evalWithoutNumericReset(IExpr) */ public static final IExpr eval(final IExpr expr) { return (instance.get()).evaluate(expr); }
/** {@inheritDoc} */ @Override public IExpr of(EvalEngine engine, IExpr... args) { IAST ast = F.ast(args, this); return engine.evaluate(ast); }
/** {@inheritDoc} */ @Override public IExpr of(EvalEngine engine, IExpr... args) { IAST ast = F.ast(args, this); return engine.evaluate(ast); }
/** * Parse the given <code>expression String</code> into an IExpr and evaluate it. * * @param expression * an expression in math formula notation * @return * @throws org.matheclipse.parser.client.SyntaxError * if a parsing error occurs */ final public IExpr evaluate(String expression) { return evaluate(parse(expression)); }
public IExpr evaluate(final Object[] index) { final IAST ast = fHeadAST.clone(); for (int i = 0; i < index.length; i++) { ast.add((IExpr) index[i]); } return fEngine.evaluate(ast); } }
private void setUpRules(final String[] rules, final Parser parser, final EvalEngine engine) { for (int i = 0; i < rules.length; i++) { final ASTNode parsedAST = parser.parse(rules[i]); final IExpr obj = AST2Expr.CONST.convert(parsedAST); // engine.init(); engine.evaluate(obj); } }
@Override public IExpr evaluate(final IExpr[] index) { final IASTAppendable ast = fHeadAST.copyAppendable(); return fEngine.evaluate(ast.appendArgs(0, index.length, i -> index[i])); } }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { if (ast.size() > 1) { IExpr[] result = { F.Null }; ast.forEach(x -> result[0] = engine.evaluate(x)); return result[0]; } return F.Null; }
public IExpr evaluate(final IAST functionList) { final EvalEngine engine = EvalEngine.get(); if (functionList.size() > 1) { for (int i = 1; i < functionList.size() - 1; i++) { // as sideeffect evaluate the i-th argument engine.evaluate(functionList.get(i)); } return engine.evaluate(functionList.get(functionList.size() - 1)); } return F.Null; }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { if (ast.isAST1()) { return engine.evaluate(ast.arg1()).head(); } return F.Symbol; }
/** * Return the evaluation of an binary AST object by settings it's first * argument to <code>firstArg</code> and it's second argument to * <code>secondArg</code> * */ public IExpr apply(final IExpr firstArg, final IExpr secondArg) { final IAST ast = fAST.clone(); ast.add(firstArg); ast.add(secondArg); return fEngine.evaluate(ast); }
public IExpr evaluate(final IAST ast) { if (ast.size() == 2) { final long begin = System.currentTimeMillis(); final EvalEngine engine = EvalEngine.get(); final IExpr result = engine.evaluate(ast.get(1)); return List(Times(FractionSym.valueOf((System .currentTimeMillis() - begin), 1000L), F.Second), result); } return null; }
@Override public IExpr evaluate(IAST ast, EvalEngine engine) { if (ast.size() == 2) { IExpr arg1 = engine.evaluate(ast.arg1()); return arg1.isComplex() || arg1.isComplexNumeric() ? F.True : F.False; } return F.False; } });
@Override public IExpr evaluate(final IAST ast) { Validate.checkSize(ast, 2); EvalEngine engine = EvalEngine.get(); IAST reapList = engine.getReapList(); IExpr expr = engine.evaluate(ast.get(1)); if (reapList != null) { reapList.add(expr); } return expr; }
@Override default IExpr subtract(IExpr that) { if (that.isZero()) { return this; } EvalEngine engine = EvalEngine.get(); if (engine.isTogetherMode() && (this.isPlusTimesPower() || that.isPlusTimesPower())) { return engine.evaluate(F.Together(F.Plus(this, F.Times(F.CN1, that)))); } return engine.evaluate(F.Plus(this, F.Times(F.CN1, that))); }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 4); return nestWhile(ast.arg2(), engine.evaluate(ast.arg3()), x -> F.unaryAST1(ast.arg1(), x), engine); }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 2); final IExpr arg1 = engine.evaluate(ast.arg1()); if (!(arg1.isAST())) { return F.C1; } return F.integer(depth((IAST) ast.arg1(), 1)); }
private static IExpr termPartitionsQ2(EvalEngine engine, IInteger n, int k) { // DivisorSigma(1, k)*PartitionsQ(n - 2*k) IInteger k2 = F.ZZ(k); return engine.evaluate(Times(F.DivisorSigma(C1, k2), F.PartitionsQ(Plus(Times(F.CN2, k2), n)))); }