private FieldValue evaluate(FieldValue value){ Boolean result = evaluate(value.asBoolean()); return FieldValueUtil.create(TypeInfos.CATEGORICAL_BOOLEAN, result); } }
@Override public String apply(Integer row){ FieldValue value = table.get(row, name); if(Objects.equals(FieldValues.MISSING_VALUE, value)){ throw new MissingValueException(name); } return value.asString(); } };
/** * <p> * Calculates the order between this value and the reference value. * </p> */ public int compareTo(HasValue<?> hasValue){ if(hasValue instanceof HasParsedValue){ HasParsedValue<?> hasParsedValue = (HasParsedValue<?>)hasValue; return compareTo(hasParsedValue); } return compareToString(ensureValue(hasValue)); }
/** * <p> * A value-safe replacement for {@link #equals(Object)}. * </p> */ public boolean equalsValue(FieldValue value){ if(sameScalarType(value)){ return (getValue()).equals(value.getValue()); } return equalsValue(value.getValue()); }
public ZonedDateTime asZonedDateTime(ZoneId zoneId){ try { LocalDateTime dateTime = asLocalDateTime(); return dateTime.atZone(zoneId); } catch(TypeCheckException tceDateTime){ try { LocalDate localDate = asLocalDate(); LocalTime localTime = LocalTime.MIDNIGHT; return ZonedDateTime.of(localDate, localTime, zoneId); } catch(TypeCheckException tceDate){ // Ignored } try { LocalDate localDate = LocalDate.now(); LocalTime localTime = asLocalTime(); return ZonedDateTime.of(localDate, localTime, zoneId); } catch(TypeCheckException tceTime){ // Ignored } throw tceDateTime; } }
static private Integer getTrials(GeneralRegressionModel generalRegressionModel, EvaluationContext context){ FieldName trialsVariable = generalRegressionModel.getTrialsVariable(); if(trialsVariable != null){ FieldValue value = getVariable(trialsVariable, context); return value.asInteger(); } return generalRegressionModel.getTrialsValue(); }
@Override public FieldValue evaluate(List<FieldValue> arguments){ checkFixedArityArguments(arguments, 2); LocalDateTime instant = getRequiredArgument(arguments, 0, "input").asLocalDateTime(); int year = getRequiredArgument(arguments, 1, "referenceYear").asInteger(); SecondsSinceDate period = new SecondsSinceDate(LocalDate.of(year, 1, 1), instant); return FieldValueUtil.create(TypeInfos.CONTINUOUS_INTEGER, period.intValue()); } };
@Override public FieldValue evaluate(List<FieldValue> arguments){ checkFixedArityArguments(arguments, 2); LocalDate instant = getRequiredArgument(arguments, 0, "input").asLocalDate(); int year = getRequiredArgument(arguments, 1, "referenceYear").asInteger(); DaysSinceDate period = new DaysSinceDate(LocalDate.of(year, 1, 1), instant); return FieldValueUtil.create(TypeInfos.CONTINUOUS_INTEGER, period.intValue()); } };
@Override public boolean test(FieldValue value){ if(Objects.equals(FieldValues.MISSING_VALUE, value)){ return false; } return equalsValue(value); } };
DataType dataType = value.getDataType(); if((AssociationModelEvaluator.STRING_TRUE).equalsValue(value)){ result.add(id); } else if((AssociationModelEvaluator.STRING_FALSE).equalsValue(value)){ break; if((AssociationModelEvaluator.BOOLEAN_TRUE).equalsValue(value)){ result.add(id); } else if((AssociationModelEvaluator.BOOLEAN_FALSE).equalsValue(value)){ break; if(value.equalsString(category)){ result.add(id);
public int compareTo(HasParsedValue<?> hasParsedValue){ FieldValue value = hasParsedValue.getValue(this); return this.compareTo(value); }
@Override public FieldValue evaluate(List<FieldValue> arguments){ checkFixedArityArguments(arguments, 2); ZonedDateTime zonedDateTime = getRequiredArgument(arguments, 0, "input").asZonedDateTime(ZoneId.systemDefault()); Date date = Date.from(zonedDateTime.toInstant()); String pattern = translatePattern(getRequiredArgument(arguments, 1, "pattern").asString()); String result; try { result = String.format(pattern, date); } catch(IllegalFormatException ife){ throw new FunctionException(this, "Invalid \'pattern\' value") .initCause(ife); } return FieldValueUtil.create(TypeInfos.CATEGORICAL_STRING, result); }
/** * <p> * Checks if this value is contained in the set of reference values. * </p> */ public boolean isIn(HasValueSet<?> hasValueSet){ if(hasValueSet instanceof HasParsedValueSet){ HasParsedValueSet<?> hasParsedValueSet = (HasParsedValueSet<?>)hasValueSet; return isIn(hasParsedValueSet); } Array array = hasValueSet.getArray(); if(array == null){ throw new MissingElementException(MissingElementException.formatMessage(XPathUtil.formatElement((Class)hasValueSet.getClass()) + "/" + XPathUtil.formatElement(Array.class)), (PMMLObject)hasValueSet); } List<?> values = ArrayUtil.getContent(array); return values.stream() .anyMatch(value -> equalsValue(value)); }
@Override public FieldValue evaluate(List<FieldValue> arguments){ checkFixedArityArguments(arguments, 2); Number number = getRequiredArgument(arguments, 0, "input").asNumber(); String pattern = getRequiredArgument(arguments, 1, "pattern").asString(); String result; // 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 { result = String.format(pattern, number); } catch(IllegalFormatException ife){ throw new FunctionException(this, "Invalid \'pattern\' value") .initCause(ife); } return FieldValueUtil.create(TypeInfos.CATEGORICAL_STRING, result); } };
case ABS_DIFF: distance = valueFactory.newValue((value.asNumber()).doubleValue()).subtract((referenceValue.asNumber()).doubleValue()); distance = valueFactory.newValue((value.asNumber()).doubleValue()).subtract((referenceValue.asNumber()).doubleValue()); case DELTA: boolean equals = (value).equalsValue(referenceValue); case EQUAL: boolean equals = (value).equalsValue(referenceValue);
FieldValue fieldValue = FieldValueUtil.createOrCast(dataType, opType, value); Value pmmlValue = (Value)fieldValue.getMapping(hasParsedValueMapping); if(pmmlValue != null){ return pmmlValue.getProperty(); FieldValue fieldValue = (FieldValue)value; equals = fieldValue.equalsString(stringValue); } else FieldValue fieldValue = (FieldValue)value; doubleValue = fieldValue.asDouble(); } else
static public FieldValue discretize(Discretize discretize, FieldValue value){ String result = discretize(discretize, value.asDouble()); return FieldValueUtil.create(ExpressionUtil.getDataType(discretize, DataType.STRING), OpType.CATEGORICAL, result); }
@Override public FieldValue evaluate(List<FieldValue> arguments){ checkFixedArityArguments(arguments, 3); String string = getRequiredArgument(arguments, 0, "input").asString(); int position = getRequiredArgument(arguments, 1, "startPos").asInteger(); if(position < 1){ throw new FunctionException(this, "Invalid \'startPos\' value " + position + ". Must be equal or greater than 1"); } // "The first character of a string is located at position 1 (not position 0)" int javaPosition = Math.min(position - 1, string.length()); int length = getRequiredArgument(arguments, 2, "length").asInteger(); if(length < 0){ throw new FunctionException(this, "Invalid \'length\' value " + length); } int javaLength = Math.min(length, (string.length() - javaPosition)); // This expression must never throw a StringIndexOutOfBoundsException String result = string.substring(javaPosition, javaPosition + javaLength); return FieldValueUtil.create(TypeInfos.CATEGORICAL_STRING, result); } };