Examples with PMMLFalsePredicate org.knime.base.node.mine.decisiontree2.PMMLFalsePredicate used on opensource projects

Example 11 with PMMLFalsePredicate

use of org.knime.base.node.mine.decisiontree2.PMMLFalsePredicate 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());
}