org.dmg.pmml.Constant Java Examples

@Test
public void translateCaseWhenExpression(){
	String string = "CASE WHEN x1 < 0 THEN x1 WHEN x2 > 0 THEN x2 ELSE 0 END";

	FieldRef first = new FieldRef(FieldName.create("x1"));
	FieldRef second = new FieldRef(FieldName.create("x2"));

	Constant zero = PMMLUtil.createConstant(0, DataType.DOUBLE);

	Apply expected = PMMLUtil.createApply(PMMLFunctions.IF)
		.addExpressions(PMMLUtil.createApply(PMMLFunctions.LESSTHAN)
			.addExpressions(first, zero)
		)
		.addExpressions(first)
		.addExpressions(PMMLUtil.createApply(PMMLFunctions.IF)
			.addExpressions(PMMLUtil.createApply(PMMLFunctions.GREATERTHAN)
				.addExpressions(second, zero)
			)
			.addExpressions(second)
			.addExpressions(zero)
		);

	checkExpression(expected, string);
}
 

static
private Map<String, String> parseRevalue(FunctionExpression.Argument replaceArgument){
	Map<String, String> result = new LinkedHashMap<>();

	FunctionExpression vectorExpression = toVectorExpression(replaceArgument);

	List<FunctionExpression.Argument> objectArguments = vectorExpression.getArguments();
	for(FunctionExpression.Argument objectArgument : objectArguments){
		String from = objectArgument.getTag();
		if(from == null){
			throw new IllegalArgumentException();
		}

		Constant constant = (Constant)objectArgument.getExpression();

		String to = (String)constant.getValue();
		if(to == null){
			throw new IllegalArgumentException();
		}

		result.put(from, to);
	}

	return result;
}
 

static
private List<String> parseVector(FunctionExpression.Argument argument){
	List<String> result = new ArrayList<>();

	FunctionExpression vectorExpression = toVectorExpression(argument);

	List<FunctionExpression.Argument> objectArguments = vectorExpression.getArguments();
	for(FunctionExpression.Argument objectArgument : objectArguments){
		Constant constant = (Constant)objectArgument.getExpression();

		String string = ValueUtil.asString(constant.getValue());

		result.add(string);
	}

	return result;
}
 

@Override
public VisitorAction visit(Constant constant){
	boolean missing = constant.isMissing();

	if(!missing){
		Object value = constant.getValue();

		if(!ExpressionUtil.isEmptyContent(value)){
			DataType dataType = constant.getDataType();
			if(dataType == null){
				dataType = TypeUtil.getConstantDataType(value);
			}

			value = parseOrCast(dataType, value);

			constant.setValue(value);
		}
	}

	return super.visit(constant);
}
 

public Apply createApply(){
	DefineFunction defineFunction = getDefineFunction();
	Feature feature = getFeature();
	String value = getValue();

	Constant constant = PMMLUtil.createConstant(value, DataType.STRING);

	return PMMLUtil.createApply(defineFunction.getName(), feature.ref(), constant);
}
 

public void addField(Field<?> field){
	RExpEncoder encoder = getEncoder();

	Feature feature = new ContinuousFeature(encoder, field);

	if(field instanceof DerivedField){
		DerivedField derivedField = (DerivedField)field;

		Expression expression = derivedField.getExpression();
		if(expression instanceof Apply){
			Apply apply = (Apply)expression;

			if(checkApply(apply, PMMLFunctions.POW, FieldRef.class, Constant.class)){
				List<Expression> expressions = apply.getExpressions();

				FieldRef fieldRef = (FieldRef)expressions.get(0);
				Constant constant = (Constant)expressions.get(1);

				try {
					String string = ValueUtil.asString(constant.getValue());

					int power = Integer.parseInt(string);

					feature = new PowerFeature(encoder, fieldRef.getField(), DataType.DOUBLE, power);
				} catch(NumberFormatException nfe){
					// Ignored
				}
			}
		}
	}

	putFeature(field.getName(), feature);

	this.fields.add(field);
}
 

@Test
public void translateParenthesizedExpression(){
	String string = "TRUE | TRUE & FALSE";

	Constant trueConstant = PMMLUtil.createConstant("true", DataType.BOOLEAN);
	Constant falseConstant = PMMLUtil.createConstant("false", DataType.BOOLEAN);

	Expression expected = PMMLUtil.createApply(PMMLFunctions.OR)
		.addExpressions(trueConstant)
		.addExpressions(PMMLUtil.createApply(PMMLFunctions.AND)
			.addExpressions(trueConstant, falseConstant)
		);

	Expression actual = ExpressionTranslator.translateExpression(string);

	assertTrue(ReflectionUtil.equals(expected, actual));

	string = "(TRUE | TRUE) & FALSE";

	expected = PMMLUtil.createApply(PMMLFunctions.AND)
		.addExpressions(PMMLUtil.createApply(PMMLFunctions.OR)
			.addExpressions(trueConstant, trueConstant)
		)
		.addExpressions(falseConstant);

	actual = ExpressionTranslator.translateExpression(string);

	assertTrue(ReflectionUtil.equals(expected, actual));
}
 

static
public FieldValue evaluateConstant(Constant constant){
	boolean missing = constant.isMissing();
	if(missing){
		return FieldValues.MISSING_VALUE;
	}

	Object value = constant.getValue();

	DataType dataType = constant.getDataType();
	if(dataType != null){

		if(isEmptyContent(value)){

			switch(dataType){
				// "If the data type is string, then the empty content will be interpreted as an empty string"
				case STRING:
					return FieldValueUtil.create(TypeInfos.CATEGORICAL_STRING, "");
				// "If the data type is something other than string, then the empty content will be interpreted as a missing value of the specified data type"
				default:
					return FieldValues.MISSING_VALUE;
			}
		}
	} else

	{
		if(isEmptyContent(value)){
			return FieldValues.MISSING_VALUE;
		}

		dataType = TypeUtil.getConstantDataType(value);

	}

	OpType opType = TypeUtil.getOpType(dataType);

	return FieldValueUtil.create(dataType, opType, value);
}
 

@Test
public void evaluateTextIndexNormalization(){
	FieldName name = FieldName.create("x");

	TextIndexNormalization stepOne = new TextIndexNormalization();

	List<List<String>> cells = Arrays.asList(
		Arrays.asList("interfaces?", "interface", "true"),
		Arrays.asList("is|are|seem(ed|s?)|were", "be", "true"),
		Arrays.asList("user friendl(y|iness)", "user_friendly", "true")
	);

	stepOne.setInlineTable(createInlineTable(cells, stepOne));

	TextIndexNormalization stepTwo = new TextIndexNormalization()
		.setInField("re")
		.setOutField("feature");

	cells = Arrays.asList(
		Arrays.asList("interface be (user_friendly|well designed|excellent)", "ui_good", "true")
	);

	stepTwo.setInlineTable(createInlineTable(cells, stepTwo));

	TextIndex textIndex = new TextIndex(name, new Constant("ui_good"))
		.setLocalTermWeights(TextIndex.LocalTermWeights.BINARY)
		.setCaseSensitive(false)
		.addTextIndexNormalizations(stepOne, stepTwo);

	assertEquals(1, evaluate(textIndex, name, "Testing the app for a few days convinced me the interfaces are excellent!"));
}
 

public Apply encodeApply(String function, Feature feature, int index, String term){
	Constant constant = PMMLUtil.createConstant(term, DataType.STRING);

	return PMMLUtil.createApply(function, feature.ref(), constant);
}
 

static
FieldValue evaluateExpression(Expression expression, EvaluationContext context){

	if(expression instanceof Constant){
		return evaluateConstant((Constant)expression);
	} else

	if(expression instanceof FieldRef){
		return evaluateFieldRef((FieldRef)expression, context);
	} else

	if(expression instanceof NormContinuous){
		return evaluateNormContinuous((NormContinuous)expression, context);
	} else

	if(expression instanceof NormDiscrete){
		return evaluateNormDiscrete((NormDiscrete)expression, context);
	} else

	if(expression instanceof Discretize){
		return evaluateDiscretize((Discretize)expression, context);
	} else

	if(expression instanceof MapValues){
		return evaluateMapValues((MapValues)expression, context);
	} else

	if(expression instanceof TextIndex){
		return evaluateTextIndex((TextIndex)expression, context);
	} else

	if(expression instanceof Apply){
		return evaluateApply((Apply)expression, context);
	} else

	if(expression instanceof Aggregate){
		return evaluateAggregate((Aggregate)expression, context);
	} // End if

	if(expression instanceof JavaExpression){
		return evaluateJavaExpression((JavaExpression)expression, context);
	}

	throw new UnsupportedElementException(expression);
}
 

@Test
public void evaluateConstantNaN(){
	Constant constant = new Constant("NaN");

	assertEquals(Double.NaN, evaluate(constant));

	constant.setDataType(DataType.FLOAT);

	assertEquals(Float.NaN, evaluate(constant));
}
 

@Test
public void evaluateConstant(){
	Constant emptyString = new Constant()
		.setDataType(DataType.STRING);

	assertEquals("", evaluate(emptyString));

	emptyString.setMissing(true);

	assertEquals(null, evaluate(emptyString));

	Constant stringThree = new Constant("3")
		.setDataType(DataType.STRING);

	assertEquals("3", evaluate(stringThree));

	stringThree.setMissing(true);

	assertEquals(null, evaluate(stringThree));

	Constant integerThree = new Constant("3")
		.setDataType(DataType.INTEGER);

	assertEquals(3, evaluate(integerThree));

	integerThree.setMissing(true);

	assertEquals(null, evaluate(integerThree));

	Constant floatThree = new Constant("3")
		.setDataType(DataType.FLOAT);

	assertEquals(3f, evaluate(floatThree));

	floatThree.setMissing(true);

	assertEquals(null, evaluate(floatThree));

	Constant doubleThree = new Constant("3")
		.setDataType(DataType.DOUBLE);

	assertEquals(3d, evaluate(doubleThree));

	doubleThree.setMissing(true);

	assertEquals(null, evaluate(doubleThree));
}