Java Expressions.ONE屬性代碼示例

private static Expression getQuantifiedExpression(QuantifiedExpression q) {
	Expression result;
	if (q instanceof IntensionalSet) {
		result = ((IntensionalSet)q).getHead();
	}
	else if (q instanceof CountingFormula) {
		result = Expressions.ONE;
	}
	else if (q instanceof QuantifiedExpressionWithABody) {
		result = ((QuantifiedExpressionWithABody)q).getBody();
	}
	else {
		throw new UnsupportedOperationException("Quantified expression currently not supported: "+q);
	}
	return result;
}
 

public static Expression simplify(Expression expression) {
	Expression base     = expression.get(0);
	Expression exponent = expression.get(1);

	Rational exponentValue = null;
	Rational baseValue     = null;
	
	if (Expressions.isNumber(exponent)) {
		exponentValue = exponent.rationalValue();
		if (exponentValue.isZero()) {
			return Expressions.ONE;
		}
		if (exponentValue.isOne()) {
			return base;
		}
	}
	
	if (Expressions.isNumber(base)) {
		baseValue = base.rationalValue();
		if (baseValue.isOne()) {
			return Expressions.ONE;
		}
		// we refrain from simplifying 0^x to 0, because x could be 0 itself.
	}
	
	if (baseValue != null && exponentValue != null) {
		Rational   pow    = baseValue.pow(exponentValue);
		Expression result = Expressions.makeSymbol(pow);
		return result;
	}

	return expression;
}
 

@Override
public SolverResult solve(String solveRequestId,
		ModelLanguage modelLanguage, String model, String evidenceQuery) throws Exception {

	if (modelLanguage != ModelLanguage.HOGMv1) {
		throw new UnsupportedOperationException(
				modelLanguage.name() + " is currently not supported by this solver.");
	}

	SGSolverCallResult prResult = prCallSGSolverCLI(model, evidenceQuery);

	Expression probabilityEvidence = null;	
	if (prResult.resultExpression != null) {
		Expression queryExpr = Expressions.parse(evidenceQuery);
		Expression resultExpr = Expressions.parse(prResult.resultExpression);
		// Simplify if possible
		if (IfThenElse.isIfThenElse(resultExpr)) {
			Expression condition = IfThenElse.condition(resultExpr);
			if (condition.equals(queryExpr)) {
				probabilityEvidence = IfThenElse.thenBranch(resultExpr);
			} else if (Not.isNegation(condition) && condition.get(0).equals(queryExpr)) {
				probabilityEvidence = IfThenElse.elseBranch(resultExpr);
			}
		} else if (resultExpr.equals(queryExpr)) {
			probabilityEvidence = Expressions.ONE;
		} else if (Not.isNegation(resultExpr)) {
			if (resultExpr.get(0).equals(queryExpr)) {
				probabilityEvidence = Expressions.ZERO;
			}
		}
		// If unable to simplify just return the result as computed (i.e. likely symbolic).
		if (probabilityEvidence == null) {
			probabilityEvidence = resultExpr;
		}
	}

	SolverResult result = new SolverResult(0,
			prResult.sgSolverProcessTookMS, probabilityEvidence);
	return result;
}
 

public static Expression make(Expression numerator, Expression denominator) {
	if (numerator.equals(denominator)) {
		return Expressions.ONE;
	}
	return Expressions.apply("/", numerator, denominator);
}