org.jpmml.evaluator.Functions Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of pmml-evaluator Show documentation
Show all versions of pmml-evaluator Show documentation
JPMML class model evaluator
The newest version!
/*
* Copyright (c) 2015 Villu Ruusmann
*
* This file is part of JPMML-Evaluator
*
* JPMML-Evaluator is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* JPMML-Evaluator is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with JPMML-Evaluator. If not, see arguments){
checkVariableArityArguments(arguments, 2, 3);
Boolean flag = getRequiredArgument(arguments, 0).asBoolean();
if(flag){
return getOptionalArgument(arguments, 1);
} else
{
// "The ELSE part is optional. If the ELSE part is absent, then a missing value is returned"
if(arguments.size() > 2){
return getOptionalArgument(arguments, 2);
}
return FieldValues.MISSING_VALUE;
}
}
};
StringFunction UPPERCASE = new StringFunction(PMMLFunctions.UPPERCASE){
@Override
public String evaluate(String value){
return value.toUpperCase();
}
};
StringFunction LOWERCASE = new StringFunction(PMMLFunctions.LOWERCASE){
@Override
public String evaluate(String value){
return value.toLowerCase();
}
};
UnaryFunction STRING_LENGTH = new UnaryFunction(PMMLFunctions.STRINGLENGTH){
@Override
public FieldValue evaluate(FieldValue value){
String string = value.asString();
return FieldValueUtil.create(TypeInfos.CONTINUOUS_INTEGER, string.length());
}
};
TernaryFunction SUBSTRING = new TernaryFunction(PMMLFunctions.SUBSTRING, Arrays.asList("input", "startPos", "length")){
public String evaluate(String string, int position, int length){
if(position < 1){
throw new InvalidArgumentException(this, InvalidArgumentException.formatMessage(this, "startPos", position) + ". Must be equal to or greater than 1");
} // End if
if(length < 0){
throw new InvalidArgumentException(this, InvalidArgumentException.formatMessage(this, "length", length));
}
// "The first character of a string is located at position 1 (not position 0)"
int javaPosition = Math.min(position - 1, string.length());
int javaLength = Math.min(length, (string.length() - javaPosition));
// This expression must never throw a StringIndexOutOfBoundsException
return string.substring(javaPosition, javaPosition + javaLength);
}
@Override
public FieldValue evaluate(FieldValue first, FieldValue second, FieldValue third){
String result = evaluate(first.asString(), second.asInteger(), third.asInteger());
return FieldValueUtil.create(TypeInfos.CATEGORICAL_STRING, result);
}
};
StringFunction TRIM_BLANKS = new StringFunction(PMMLFunctions.TRIMBLANKS){
@Override
public String evaluate(String value){
return value.trim();
}
};
AggregateFunction CONCAT = new AggregateFunction(PMMLFunctions.CONCAT){
@Override
public FieldValue evaluate(List arguments){
checkVariableArityArguments(arguments, 2);
StringBuilder sb = new StringBuilder();
for(int i = 0, max = arguments.size(); i < max; i++){
FieldValue value = getOptionalArgument(arguments, i);
if(FieldValueUtil.isMissing(value)){
continue;
}
sb.append(value.asString());
}
String result = sb.toString();
return FieldValueUtil.create(TypeInfos.CATEGORICAL_STRING, result);
}
};
TernaryFunction REPLACE = new TernaryFunction(PMMLFunctions.REPLACE, Arrays.asList("input", "pattern", "replacement")){
public String evaluate(String input, String regex, String replacement){
Pattern pattern = RegExUtil.compile(regex, null);
Matcher matcher = pattern.matcher(input);
return matcher.replaceAll(replacement);
}
@Override
public FieldValue evaluate(FieldValue first, FieldValue second, FieldValue third){
String result = evaluate(first.asString(), second.asString(), third.asString());
return FieldValueUtil.create(TypeInfos.CATEGORICAL_STRING, result);
}
};
BinaryFunction MATCHES = new BinaryFunction(PMMLFunctions.MATCHES, Arrays.asList("input", "pattern")){
public Boolean evaluate(String input, String regex){
Pattern pattern = RegExUtil.compile(regex, null);
Matcher matcher = pattern.matcher(input);
// "The string is considered to match the pattern if any substring matches the pattern"
return Boolean.valueOf(matcher.find());
}
@Override
public FieldValue evaluate(FieldValue first, FieldValue second){
Boolean result = evaluate(first.asString(), second.asString());
return FieldValueUtil.create(TypeInfos.CATEGORICAL_BOOLEAN, result);
}
};
BinaryFunction FORMAT_NUMBER = new BinaryFunction(PMMLFunctions.FORMATNUMBER, Arrays.asList("input", "pattern")){
public String evaluate(Number input, String pattern){
// According to the java.util.Formatter javadoc, Java formatting is more strict than C's printf formatting.
// For example, in Java, if a conversion is incompatible with a flag, an exception will be thrown. In C's printf, inapplicable flags are silently ignored.
try {
return String.format(pattern, input);
} catch(IllegalFormatException ife){
throw new InvalidArgumentException(this, InvalidArgumentException.formatMessage(this, "pattern", pattern))
.initCause(ife);
}
}
@Override
public FieldValue evaluate(FieldValue first, FieldValue second){
String result = evaluate(first.asNumber(), second.asString());
return FieldValueUtil.create(TypeInfos.CATEGORICAL_STRING, result);
}
};
BinaryFunction FORMAT_DATETIME = new BinaryFunction(PMMLFunctions.FORMATDATETIME, Arrays.asList("input", "pattern")){
public String evaluate(Instant input, String pattern){
pattern = translatePattern(pattern);
try {
return input.format(pattern);
} catch(IllegalFormatException ife){
throw new InvalidArgumentException(this, InvalidArgumentException.formatMessage(this, "pattern", pattern))
.initCause(ife);
}
}
@Override
public FieldValue evaluate(FieldValue first, FieldValue second){
String result = evaluate(first.asInstant(), second.asString());
return FieldValueUtil.create(TypeInfos.CATEGORICAL_STRING, result);
}
private String translatePattern(String pattern){
StringBuilder sb = new StringBuilder();
for(int i = 0; i < pattern.length(); i++){
char c = pattern.charAt(i);
sb.append(c);
if(c == '%'){
// Every %[conversion] has to become %1$t[conversion]
// Here, "1$" denotes the first argument, and "t" denotes the prefix for date and time conversion characters
if(i < (pattern.length() - 1) && pattern.charAt(i + 1) != '%'){
sb.append("1$t");
}
}
}
return sb.toString();
}
};
BinaryFunction DATE_DAYS_SINCE_YEAR = new BinaryFunction(PMMLFunctions.DATEDAYSSINCEYEAR, Arrays.asList("input", "referenceYear")){
@Override
public FieldValue evaluate(FieldValue first, FieldValue second){
DaysSinceDate result = (first.asDate()).toDaysSinceYear(second.asInteger());
return FieldValueUtil.create(TypeInfos.CONTINUOUS_INTEGER, result);
}
};
UnaryFunction DATE_SECONDS_SINCE_MIDNIGHT = new UnaryFunction(PMMLFunctions.DATESECONDSSINCEMIDNIGHT, Arrays.asList("input")){
@Override
public FieldValue evaluate(FieldValue value){
SecondsSinceMidnight result = (value.asTime()).toSecondsSinceMidnight();
return FieldValueUtil.create(TypeInfos.CONTINUOUS_INTEGER, result);
}
};
BinaryFunction DATE_SECONDS_SINCE_YEAR = new BinaryFunction(PMMLFunctions.DATESECONDSSINCEYEAR, Arrays.asList("input", "referenceYear")){
@Override
public FieldValue evaluate(FieldValue first, FieldValue second){
SecondsSinceDate result = (first.asDateTime()).toSecondsSinceYear(second.asInteger());
return FieldValueUtil.create(TypeInfos.CONTINUOUS_INTEGER, result);
}
};
BinaryFunction HYPOT = new BinaryFunction(PMMLFunctions.HYPOT){
public Double evaluate(Number x, Number y){
return Math.hypot(x.doubleValue(), y.doubleValue());
}
@Override
public FieldValue evaluate(FieldValue first, FieldValue second){
Double result = evaluate(first.asNumber(), second.asNumber());
return FieldValueUtil.create(TypeInfos.CONTINUOUS_DOUBLE, result);
}
};
TrigonometricFunction SIN = new TrigonometricFunction(PMMLFunctions.SIN){
@Override
public Double evaluate(Number value){
return Math.sin(value.doubleValue());
}
};
TrigonometricFunction COS = new TrigonometricFunction(PMMLFunctions.COS){
@Override
public Double evaluate(Number value){
return Math.cos(value.doubleValue());
}
};
TrigonometricFunction TAN = new TrigonometricFunction(PMMLFunctions.TAN){
@Override
public Double evaluate(Number value){
return Math.tan(value.doubleValue());
}
};
TrigonometricFunction ASIN = new TrigonometricFunction(PMMLFunctions.ASIN){
@Override
public Double evaluate(Number value){
return Math.asin(value.doubleValue());
}
};
TrigonometricFunction ACOS = new TrigonometricFunction(PMMLFunctions.ACOS){
@Override
public Double evaluate(Number value){
return Math.acos(value.doubleValue());
}
};
TrigonometricFunction ATAN = new TrigonometricFunction(PMMLFunctions.ATAN){
@Override
public Double evaluate(Number value){
return Math.atan(value.doubleValue());
}
};
BinaryFunction ATAN2 = new BinaryFunction(PMMLFunctions.ATAN2){
public Double evaluate(Number y, Number x){
return Math.atan2(y.doubleValue(), x.doubleValue());
}
@Override
public FieldValue evaluate(FieldValue first, FieldValue second){
Double result = evaluate(first.asNumber(), second.asNumber());
return FieldValueUtil.create(TypeInfos.CONTINUOUS_DOUBLE, result);
}
};
TrigonometricFunction SINH = new TrigonometricFunction(PMMLFunctions.SINH){
@Override
public Double evaluate(Number value){
return Math.sinh(value.doubleValue());
}
};
TrigonometricFunction COSH = new TrigonometricFunction(PMMLFunctions.COSH){
@Override
public Double evaluate(Number value){
return Math.cosh(value.doubleValue());
}
};
TrigonometricFunction TANH = new TrigonometricFunction(PMMLFunctions.TANH){
@Override
public Double evaluate(Number value){
return Math.tanh(value.doubleValue());
}
};
}