import de.congrace.exp4j.ExpressionBuilder; //导入依赖的package包/类
/**
 * Evaluates the expression provided.
 * 
 * @param value
 *            the value to evaluate
 * @param executionTime
 *            the execution time
 * @param simulationTime
 *            the simulationTime
 * @param rampTime
 *            the rampTime
 * @return the long value of evaluating the expression.
 * @throws IllegalArgumentException
 *             if there is an issue evaluating the expression.
 */
public static long evaluateExpression(String value, long executionTime, long simulationTime, long rampTime)
        throws IllegalArgumentException {
    if (StringUtils.isBlank(value)) {
        throw new IllegalArgumentException("Expression is either null or empty.");
    }
    String expression = normalizeExpression(value);
    try {
        Calculable calc = new ExpressionBuilder(expression)
                .withVariable(ESTIMATED_RUN_TIME, executionTime)
                .withVariable(SIMULATION_TIME, simulationTime)
                .withVariable(RAMP_TIME, rampTime)
                .build();
        long result = Math.round(calc.calculate());
        LOG.debug(value + " --> " + expression + " = " + Long.toString(result));
        return result;
    } catch (Exception e) {
        LOG.warn(value + " is not a valid expression.");
        throw new IllegalArgumentException(e);
    }
}
 

import de.congrace.exp4j.ExpressionBuilder; //导入依赖的package包/类
@Override
public int evalute(String expression, Map<String, Object> paramsMap){
	try {
		ExpressionBuilder builder = new ExpressionBuilder(expression);
		Set<Entry<String, Object>> entries = paramsMap.entrySet();
		for(Entry<String, Object> entry : entries){
			String key = entry.getKey();
			Object value = entry.getValue();
			if (value instanceof Number) {
				Number num = (Number)value;
				builder.withVariable(key, num.doubleValue());
			}
		}
		return (int)builder.build().calculate();
	}
	catch (Exception e) {
		throw new EvaluatorException(e);
	}
}
 

import de.congrace.exp4j.ExpressionBuilder; //导入依赖的package包/类
private double weight(Annotation node, String weightString, AnnotatedText t, AnnotatedText h, boolean isT) {
	Map<String, Double> valuesMap = new HashMap<String, Double>();
	for (NamedWeightCalculator c : calculators)
		valuesMap.put(c.name(), isT ? c.weightT(node, t, h) : c.weightH(node, t, h));
	ExpressionBuilder calc = new ExpressionBuilder(weightString).withVariables(valuesMap);
	try {
		double valuex = calc.build().calculate();
		return valuex;
	} catch (Exception e) {
		e.printStackTrace();
		System.exit(0);
		return 0;
	}
}
 

import de.congrace.exp4j.ExpressionBuilder; //导入依赖的package包/类
@Override
public DoubleMatrix extractFeatures(FormattedSegments formattedSegments) {
    DoubleMatrix result = new DoubleMatrix(formattedSegments.getNumberOfRows(), 1);
    ExpressionBuilder expressionBuilder = new ExpressionBuilder(expression);
    for (int i = 0; i < formattedSegments.getNumberOfRows(); i++) {
        Map<String, Double> variableMap = getVariableMap(formattedSegments, i);
        double featureValue = getFeatureValue(expressionBuilder, variableMap);
        result.put(i, 0, featureValue);
    }
    return result;
}
 

import de.congrace.exp4j.ExpressionBuilder; //导入依赖的package包/类
private double getFeatureValue(ExpressionBuilder expressionBuilder, Map<String, Double> variableMap) {
    expressionBuilder.withVariables(variableMap);
    Calculable calc = null;
    try {
        calc = expressionBuilder.build();
    } catch (UnknownFunctionException | UnparsableExpressionException e) {
        String message = "Expression for feature extractor (" + name + ") is not valid.";
        throw new InvalidExpressionException(message, e);
    }
    return calc.calculate();
}
 

import de.congrace.exp4j.ExpressionBuilder; //导入依赖的package包/类
private void evaluate() {
	if (!empty) {
		String textToEvaluate = output.getText().toString();
		textToEvaluate = textToEvaluate.replace(getString(R.string.multiply_operator).charAt(0), '*');
		textToEvaluate = textToEvaluate.replace(getString(R.string.divide_operator).charAt(0), '/');
		Log.d("math", "Evaluating expression: " + textToEvaluate);
		ExpressionBuilder builder = new ExpressionBuilder(textToEvaluate);
		try {
			lastValue = Math.round(builder.build().calculate());
			output.setText(Long.toString(lastValue));
			setNumberAllowed(false);
			setOperatorAllowed(true);
			output.setEllipsize(TruncateAt.END);
			stack.clear();
			if (listener != null) {
				listener.onNewResult(lastValue);
			}
		} catch (Exception ex) {
			if (colorTimer != null) {
				colorTimer.cancel();
			}
			colorTimer = new Timer();
			colorTimer.schedule(new TimerTask() {
				int redVal = 255;

				@Override
				public void run() {
					Keypad.this.getActivity().runOnUiThread(new ColorSetter(Color.argb(255, redVal, 0, 0), output));
					redVal -= 2;
					if (redVal < 0) {
						cancel();
					}
				}
			}, 1, 17);
		}
	}
}
 

import de.congrace.exp4j.ExpressionBuilder; //导入依赖的package包/类
public static int evaluateExpression( String expression )
    throws IllegalArgumentException
{
    try
    {
        return
                StringUtils.isBlank( expression )
                        ? 0
                        : (int) new ExpressionBuilder( expression ).build().calculate();
    }
    catch ( Exception e )
    {
        throw new IllegalArgumentException( "Unable to evaluate expression " + expression );
    }
}