use of org.knime.base.node.mine.decisiontree2.PMMLTruePredicate in project knime-core by knime.
the class RuleSetToTable method convertToStringPrecedence.
/**
* @param condition A {@link PMMLPredicate}.
* @param usePrecedence Should we simplify the condition?
* @param parentOperator The parent operator's (logical connective) type, used for precedence, can be {@code null}.
* @param types The type of input columns.
* @return Converted {@code condition} with precedence.
*/
private static String convertToStringPrecedence(final PMMLPredicate condition, final boolean usePrecedence, final PMMLBooleanOperator parentOperator, final Map<String, DataType> types) {
if (condition instanceof PMMLTruePredicate) {
return "TRUE";
}
if (condition instanceof PMMLFalsePredicate) {
return "FALSE";
}
if (condition instanceof PMMLSimplePredicate) {
PMMLSimplePredicate sp = (PMMLSimplePredicate) condition;
DataType dataType = types.get(sp.getSplitAttribute());
switch(sp.getOperator()) {
// intentional fall-through
case EQUAL:
// intentional fall-through
case GREATER_OR_EQUAL:
// intentional fall-through
case GREATER_THAN:
// intentional fall-through
case LESS_OR_EQUAL:
case LESS_THAN:
return dollars(sp.getSplitAttribute()) + " " + sp.getOperator().getSymbol() + " " + asComparisonValue(sp.getThreshold(), dataType);
case NOT_EQUAL:
return "NOT " + dollars(sp.getSplitAttribute()) + " = " + asComparisonValue(sp.getThreshold(), dataType);
case IS_MISSING:
return "MISSING " + dollars(sp.getSplitAttribute());
case IS_NOT_MISSING:
return "NOT MISSING " + dollars(sp.getSplitAttribute());
default:
throw new UnsupportedOperationException("Unknown operator: " + sp.getOperator());
}
}
if (condition instanceof PMMLSimpleSetPredicate) {
PMMLSimpleSetPredicate ssp = (PMMLSimpleSetPredicate) condition;
DataType dataType = types.get(ssp.getSplitAttribute());
switch(ssp.getSetOperator()) {
case IS_IN:
return dollars(ssp.getSplitAttribute()) + " IN (" + asComparisonValues(ssp.getValues(), dataType) + ")";
case IS_NOT_IN:
return "NOT " + dollars(ssp.getSplitAttribute()) + " IN (" + asComparisonValues(ssp.getValues(), dataType) + ")";
default:
throw new UnsupportedOperationException("Unknown operator: " + ssp.getOperator());
}
}
if (condition instanceof PMMLCompoundPredicate) {
PMMLCompoundPredicate cp = (PMMLCompoundPredicate) condition;
List<PMMLPredicate> predicates = cp.getPredicates();
switch(cp.getBooleanOperator()) {
case AND:
// never parentheses, parent XOR, OR, AND, nothing: all fine, SURROGATE is not supported
return parentheses(!usePrecedence, join(PMMLBooleanOperator.AND, cp, types, usePrecedence));
case OR:
// if not nothing or OR, we have to use parentheses
return parentheses(!usePrecedence || (predicates.size() > 1 && parentOperator != null && parentOperator != PMMLBooleanOperator.OR), join(PMMLBooleanOperator.OR, cp, types, usePrecedence));
case XOR:
// if not nothing or XOR or OR, we have to use parentheses, so when it is an AND
return parentheses(!usePrecedence || (predicates.size() > 1 && parentOperator == PMMLBooleanOperator.AND), join(PMMLBooleanOperator.XOR, cp, types, usePrecedence));
case SURROGATE:
{
CheckUtils.checkState(predicates.size() > 1, "At least two arguments are required for SURROGATE, but got only: " + predicates.size() + "\nValues: " + predicates);
return handleSurrogate(cp, predicates, usePrecedence, parentOperator, types);
}
default:
throw new UnsupportedOperationException("Unknown operator: " + cp.getOperator());
}
}
throw new IllegalArgumentException("Unknown predicate type: " + condition + " (" + condition.getClass());
}
Aggregations