private IExpr tryExpandAllTransformation(IAST plusAST, IExpr test) { IExpr result = F.NIL; long minCounter = fComplexityFunction.apply(plusAST); IExpr temp; long count; try { temp = F.evalExpandAll(test); count = fComplexityFunction.apply(temp); if (count < minCounter) { result = temp; } } catch (WrongArgumentType wat) { // } return result; }
/** * Apply <code>ExpandAll()</code> to the given expression if it's an <code>IAST</code>. If expanding wasn't possible * this method returns the given argument. * * @param a * the expression which should be evaluated * @return the evaluated expression * @see EvalEngine#evaluate(IExpr) */ public static IExpr evalExpandAll(IExpr a) { return evalExpandAll(a, EvalEngine.get()); }
public static boolean possibleZeroQ(IExpr expr) { // TODO implement more tests if expr could be 0 if (expr.isAST()) { expr = F.evalExpandAll(expr); } return expr.isZero(); }
@Override public ExprFieldElement negate() { return new ExprFieldElement(F.evalExpandAll(val.times(F.CN1))); }
@Override public ExprFieldElement reciprocal() { return new ExprFieldElement(F.evalExpandAll(val.power(-1))); }
private IExpr tryTransformations(IAST plusAST, IExpr test) { IExpr result = null; int minCounter = LeafCount.leafCount(plusAST); IExpr temp; int count; try { temp = F.evalExpandAll(test); count = LeafCount.leafCount(temp); if (count < minCounter) { minCounter = count; result = temp; } } catch (WrongArgumentType wat) { // } return result; }
@Override public ExprFieldElement multiply(int a) { // if (val.isAtom()) { // return new ExprFieldElement(val.times(a.val)); // } return new ExprFieldElement(F.evalExpandAll(val.times(F.integer(a)))); }
public IExpr evaluate(final IAST ast) { Validate.checkSize(ast, 2); TrigReduceVisitor trigReduceVisitor = new TrigReduceVisitor(); IExpr temp = ast.get(1); IExpr result = temp; while (temp != null) { result = evalExpandAll(temp); temp = result.accept(trigReduceVisitor); if (temp != null) { result = temp; } } return result; }
/** {@inheritDoc} */ @Override public final boolean isPolynomial(IAST variables) { if (isPlus() || isTimes() || isPower()) { IExpr expr = F.evalExpandAll(this); ExprPolynomialRing ring = new ExprPolynomialRing(variables); return ring.isPolynomial(expr); } return false; }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 3); IExpr expr = F.evalExpandAll(ast.arg1(), engine).normal(); IAST list = Validate.checkSymbolOrSymbolList(ast, 2); return coefficientList(expr, list); }
public static boolean polynomialQ(final IExpr polnomialExpr, final IAST variables) { try { IExpr expr = F.evalExpandAll(polnomialExpr); ASTRange r = new ASTRange(variables, 1); JASConvert<IExpr> jas = new JASConvert<IExpr>(r.toList(), new ExprRingFactory()); return jas.expr2IExprJAS(expr) != null; } catch (JASConversionException e) { // exception will be thrown if the expression is not a JAS polynomial } return false; }
@Override public ExprFieldElement subtract(ExprFieldElement a) { if (val.isAtom() && a.val.isAtom()) { return new ExprFieldElement(val.minus(a.val)); } return new ExprFieldElement(F.evalExpandAll(val.minus(a.val))); }
@Override public ExprFieldElement add(ExprFieldElement a) { if (val.isAtom() && a.val.isAtom()) { return new ExprFieldElement(val.plus(a.val)); } return new ExprFieldElement(F.evalExpandAll(val.plus(a.val))); }
@Override public ExprFieldElement divide(ExprFieldElement a) throws ArithmeticException { if (val.isAtom() && a.val.isAtom()) { return new ExprFieldElement(val.div(a.val)); } return new ExprFieldElement(F.evalExpandAll(val.div(a.val))); }
@Override public ExprFieldElement multiply(ExprFieldElement a) { if (val.isAtom() && a.val.isAtom()) { return new ExprFieldElement(val.times(a.val)); } return new ExprFieldElement(F.evalExpandAll(val.times(a.val))); }
public final boolean isPolynomialOfMaxDegree(IAST variables, long maxDegree) { try { if (isPlus() || isTimes() || isPower()) { IExpr expr = F.evalExpandAll(this); ExprPolynomialRing ring = new ExprPolynomialRing(variables); ExprPolynomial poly = ring.create(expr); return poly.degree() <= maxDegree; } } catch (RuntimeException ex) { // } return false; }
protected static IAST roots(final IExpr arg1, boolean numericSolutions, IAST variables, EvalEngine engine) { IExpr expr = evalExpandAll(arg1, engine); IExpr denom = F.C1; if (expr.isAST()) { expr = Algebra.together((IAST) expr, engine); // split expr into numerator and denominator denom = F.Denominator.of(engine, expr); if (!denom.isOne()) { // search roots for the numerator expression expr = F.Numerator.of(engine, expr); } } return rootsOfVariable(expr, denom, variables, numericSolutions, engine); }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 4); // TODO allow multinomials IExpr arg3 = Validate.checkSymbolType(ast, 3); ISymbol x = (ISymbol) arg3; IExpr a = F.evalExpandAll(ast.arg1(), engine); IExpr b = F.evalExpandAll(ast.arg2(), engine); ExprPolynomialRing ring = new ExprPolynomialRing(F.List(x)); try { // check if a is a polynomial otherwise check ArithmeticException, ClassCastException ring.create(a); // check if b is a polynomial otherwise check ArithmeticException, ClassCastException ring.create(b); return F.Together(resultant(a, b, x, engine)); } catch (RuntimeException ex) { throw new WrongArgumentType(ast, b, 2, "Polynomial expected!"); } }
/** * Check if the given expression is an equation (i.e. <code>Equal(a,b)</code>) * * @param expr * the expression which should be an equation * @return */ public static IExpr checkEquation(IExpr expr) { if (expr.isEqual()) { IAST equal = (IAST) expr; return F.evalExpandAll(F.Subtract(equal.arg1(), equal.arg2())); } else if (expr.isTrue()) { return F.True; } else if (expr.isFalse()) { return F.False; } else { // not an equation throw new WrongArgumentType(expr, "Equal[] expression (a==b) expected"); } }
protected static IAST roots(final IAST ast, boolean numericSolutions) { ExprVariables eVar = new ExprVariables(ast.get(1)); if (!eVar.isSize(1)) { // factor only possible for univariate polynomials return null; } IExpr expr = evalExpandAll(ast.get(1)); IAST variables = eVar.getVarList(); IExpr denom = F.C1; if (expr.isAST()) { expr = Together.together((IAST) expr); // split expr into numerator and denominator denom = F.eval(F.Denominator(expr)); if (!denom.isOne()) { // search roots for the numerator expression expr = F.eval(F.Numerator(expr)); } } return rootsOfVariable(expr, denom, variables, numericSolutions); }