import com.udojava.evalex.Expression; //导入依赖的package包/类
private String generateEasterEgg(Expression expression, BigDecimal result, String query, String stringifiedResult) {
    if (result.intValueExact() == 69) {
        return stringifiedResult + "\t( ͡° ͜ʖ ͡°)";
    }

    query = query.replaceAll(" ", "");

    if (query.startsWith("2+2-1") && ((expression.isBoolean() && result.intValueExact() == 1) || result.intValueExact() == 3)) {
        return stringifiedResult + "\t-\tQuick maths!";
    }

    if (query.equals("10") && stringifiedResult.equals("10")) {
        return "There are only 10 types of people in the world, those who understand binary and those who don't.";
    }

    return stringifiedResult;
}
 

import com.udojava.evalex.Expression; //导入依赖的package包/类
@Override
    public void doGet(final HttpServletRequest pRequest, final HttpServletResponse pResponse)
            throws IOException {
        pResponse.setContentType("application/json");

        final Result result = new Result();
        try {
            final String input = pRequest.getParameter("input");
            BigDecimal value = new Expression(input).eval();
            result.setSum(value.toString());
        } catch (final Exception e) {
            result.setError(e.toString());
        }

        //TODO what is faster?

        //1
        new Gson().toJson(result, pResponse.getWriter());

        //2
//        final String resultAsString = new Gson().toJson(result);
//        pResponse.getWriter().print(resultAsString);
    }
 

import com.udojava.evalex.Expression; //导入依赖的package包/类
@Override
public boolean onCommand(Message message, String[] args) {
    if (args.length == 0) {
        return sendErrorMessage(message, "Missing argument, the `equation` argument is required!");
    }

    String string = String.join(" ", args).trim();

    try {
        Expression expression = createExpression(string);
        BigDecimal result = expression.eval();

        if (expression.isBoolean()) {
            MessageFactory.makeInfo(message,
                generateEasterEgg(expression, result, string, result.intValueExact() == 1 ? "True" : "False")
            ).queue();
            return true;
        }

        MessageFactory.makeInfo(message, generateEasterEgg(expression, result, string, result.toPlainString())).queue();
    } catch (Exception ex) {
        return sendErrorMessage(message, ex.getMessage().replaceAll("'", "`"));
    }
    return true;
}
 

import com.udojava.evalex.Expression; //导入依赖的package包/类
private Expression createExpression(String string) {
    int where = string.toLowerCase().indexOf("where");

    if (where == -1) {
        return new Expression(string)
            .setVariable("tau", new BigDecimal(Math.PI * 2));
    }

    Expression expression = new Expression(string.substring(0, where).trim())
        .setVariable("tau", new BigDecimal(Math.PI * 2));

    for (String var : string.substring(where + 5, string.length()).trim().split(" and ")) {
        String[] varArgs = var.split("=");
        if (varArgs.length != 2) {
            varArgs = var.split("is");
            if (varArgs.length != 2) {
                continue;
            }
        }

        expression.setVariable(varArgs[0].trim(), new BigDecimal(varArgs[1].trim()));
    }

    return expression;
}
 

import com.udojava.evalex.Expression; //导入依赖的package包/类
@Then("^(?:I should see |)the \"(.*?)\" field value is calculated using the following formula:$")
public void fieldValueIsCalculatedByFormula(
        String field, String formula) throws Throwable {
    final double precision = 0.0099;
    double pageVal = Double.parseDouble(Page.getCurrent().onPage(field)
            .getText());
    for (String key : Context.variables()) {
        formula = formula.replaceAll(key, Context.get(key).toString());
    }
    Expression expression = new Expression(formula);
    double calcVal = expression
        .setRoundingMode(RoundingMode.HALF_EVEN).setPrecision(6).eval().doubleValue();

    Assert.assertEquals("Wrong " + field + "! on page (" + pageVal
            + ") vs calulated (" + calcVal + ")", pageVal, calcVal, precision);
}
 

import com.udojava.evalex.Expression; //导入依赖的package包/类
public ConditionEvaluator(String eval) {
    super();

    this.eval = eval;
    this.queryVars = new HashMap<>();

    this.expression = new Expression(replaceQueriesWithVariables(eval));

    log.debugf("eval [%s] produced [%s] with variables %s", eval, expression.getOriginalExpression(), queryVars);

    // Do a test evaluation to validate the expression
    try {
        for (String var : queryVars.keySet()) {
            this.expression.setVariable(var, "1");
        }
        this.expression.eval();
    } catch (Exception e) {
        throw new IllegalArgumentException("Invalid eval expression [" + eval + "]: " + e.getMessage());
    }
}
 

import com.udojava.evalex.Expression; //导入依赖的package包/类
/**
 * Applies {@code doubleExpression} compiled to an expression to the series referenced by
 * {@code seriesNames} row by row and returns the results as a new series. The series' values
 * are mapped to variables in {@code doubleExpression} by series names. Only series referenced
 * by {@code seriesNames} can be referenced by the expression.
 * The series are converted to {@code DoubleSeries} transparently and the results
 * are returned as DoubleSeries as well.
 *
 * <br/><b>NOTE:</b> doubleExpression is compiled to an {@code EvalEx} expression.
 *
 * @param doubleExpression expression to be compiled and applied using EvalEx
 * @throws IllegalArgumentException if the series does not exist
 * @return series with evaluation results
 */
public DoubleSeries map(String doubleExpression, final String... seriesNames) {
  // TODO support escaping of "}"
  final String[] vars = new String[seriesNames.length];
  for(int i=0; i<seriesNames.length; i++) {
    String pattern = String.format("${%s}", seriesNames[i]);
    String replace = String.format("__%d", i);
    vars[i] = replace;
    doubleExpression = doubleExpression.replace(pattern, replace);
  }

  final Expression e = new Expression(doubleExpression);

  return this.map(new Series.DoubleFunction() {
    @Override
    public double apply(double[] values) {
      for(int i=0; i<values.length; i++) {
        e.with(vars[i], new BigDecimal(values[i]));
      }
      return e.eval().doubleValue();
    }
  }, seriesNames);
}
 

import com.udojava.evalex.Expression; //导入依赖的package包/类
@Override
protected void execute(CommandEvent e) {

    if (!e.getArgs().isEmpty()) {
        String result;

        if (e.getArgs().equalsIgnoreCase("quick maths")) {
            result = "2 + 2 - 1 = that's 3 quick maths.";
            e.replySuccess("**Expression Evaluated!**\n**Result:**" + C.codeblock(result));
            return;
        }

        if (e.getArgs().replace(" ", "").equalsIgnoreCase("2+2-1")) {
            result = "that's 3 quick maths";
            e.replySuccess("**Expression Evaluated!**\n**Result:**" + C.codeblock(result));
            return;
        }

        try {
            result = new Expression(e.getArgs()).eval().toPlainString();
        } catch (Expression.ExpressionException | ArithmeticException e1) {
            e.replyError("Invalid Expression!");
            return;
        }

        if (result == null) {
            e.replyError("Invalid Expression!");
            return;
        }

        e.replySuccess("**Expression Evaluated!**\n**Result:**" + C.codeblock(result));
    } else {
        e.replyError("**Correct Usage:** ^" + name + " " + arguments);
    }



}
 

import com.udojava.evalex.Expression; //导入依赖的package包/类
protected void execute(Input input, Output output) {
  StringBuilder sb = new StringBuilder();
  for (String s : input.getArguments()) {
    sb.append(s.replaceAll(",", "").trim());
  }
  Expression expression = new Expression(sb.toString());
  BigDecimal result = expression.eval();
  DecimalFormat df = new DecimalFormat(
      "#,###.##################################################");
  output.sendMessage(createEmbed(this.settings.getEmbedColor(), "Result",
      "**```\n" + df.format(result).toString() + "\n```**"));
}
 

import com.udojava.evalex.Expression; //导入依赖的package包/类
@Override
public void onCalculateResult() {
    if (mCurrentStringExpression.isEmpty() || mCurrentStringExpression.contains(INFINITY)) {
        view.showInvalidExpressionMessage();
    } else {
        clearLastValueIfItIsAnOperator();

        mCurrentStringExpression = mCurrentStringExpression.replaceAll(PERCENTAGE, "/100");

        Expression expression = new Expression(mCurrentStringExpression);

        BigDecimal bigDecimalResult = expression.eval();

        double doubleResult = bigDecimalResult.doubleValue();

        String stringResult;

        if (isValueInteger(doubleResult) && !isScientificNotation(Double.toString(doubleResult))) {
            int roundedValue = (int) Math.round(doubleResult);
            stringResult = String.valueOf(roundedValue);
        } else {
            stringResult = Double.toString(doubleResult);
        }

        view.showResult(stringResult);
        mCurrentStringExpression = stringResult;
    }
}
 

import com.udojava.evalex.Expression; //导入依赖的package包/类
@Then("^(?:I should see |)the \"(.*)\" (?:table|list) has \"(.*)\" (?:items|rows)$")
public void verifyTableRowCount(String list, String countValue) throws Exception {
    TableView control = (TableView) verifyElementExists(list);
    BigDecimal actualCount = new BigDecimal(control.getItemsCount());
    String expectedCountValue = countValue;
    for (String key : Context.variables()) {
        expectedCountValue = expectedCountValue.replaceAll(key, Context.get(key).toString());
    }
    Expression expression = new Expression(expectedCountValue);
    BigDecimal expectedCount = expression.setPrecision(0).eval();
    Assert.assertEquals("Unexpected row count for the '" + list + "' table", expectedCount, actualCount);
}
 

import com.udojava.evalex.Expression; //导入依赖的package包/类
public Expression getExpression() {
    return expression;
}