public Float asFloat(){ Number number = asNumber(); return number.floatValue(); }
/** * Getting the value of a field as {@link Double}: * <pre> * FieldValue value = ...; * Double result = value.asDouble(); * </pre> * * Getting the value of a field as <code>double</code>: * <pre> * FieldValue value = ...; * double result = (value.asNumber()).doubleValue(); * </pre> * * @see #asNumber() */ public Double asDouble(){ Number number = asNumber(); return number.doubleValue(); }
private FieldValue evaluate(FieldValue left, FieldValue right){ DataType dataType = TypeUtil.getCommonDataType(left.getDataType(), right.getDataType()); Double result = Math.pow((left.asNumber()).doubleValue(), (right.asNumber()).doubleValue()); return FieldValueUtil.create(dataType, OpType.CONTINUOUS, result); } };
@Override public FieldValue evaluate(List<FieldValue> arguments){ checkFixedArityArguments(arguments, 2); Number x = getRequiredArgument(arguments, 0).asNumber(); Number y = getRequiredArgument(arguments, 1).asNumber(); Double result = Math.hypot(x.doubleValue(), y.doubleValue()); return FieldValueUtil.create(TypeInfos.CONTINUOUS_DOUBLE, result); } };
static public FieldValue normalize(NormContinuous normContinuous, FieldValue value){ double result = normalize(normContinuous, (value.asNumber()).doubleValue()); return FieldValueUtil.create(TypeInfos.CONTINUOUS_DOUBLE, result); }
private FieldValue evaluate(FieldValue left, FieldValue right){ DataType dataType = TypeUtil.getCommonDataType(left.getDataType(), right.getDataType()); Integer result = ((left.asNumber()).doubleValue() > (right.asNumber()).doubleValue()) ? Numbers.INTEGER_ONE : Numbers.INTEGER_ZERO; return FieldValueUtil.create(dataType, OpType.CONTINUOUS, result); } };
@Override public FieldValue evaluate(List<FieldValue> arguments){ checkFixedArityArguments(arguments, 2); Number y = getRequiredArgument(arguments, 0).asNumber(); Number x = getRequiredArgument(arguments, 1).asNumber(); Double result = Math.atan2(y.doubleValue(), x.doubleValue()); if(result.isNaN()){ throw new NaNResultException(); } return FieldValueUtil.create(TypeInfos.CONTINUOUS_DOUBLE, result); } };
private FieldValue evaluate(FieldValue value){ Number result = evaluate(value.asNumber()); return FieldValueUtil.create(TypeInfos.CONTINUOUS_DOUBLE, result); } }
private FieldValue evaluate(FieldValue value){ DataType dataType = value.getDataType(); Number result = evaluate(value.asNumber()); return FieldValueUtil.create(dataType, OpType.CONTINUOUS, result); } }
private FieldValue evaluate(FieldValue left, FieldValue right){ // "If one of the input fields of a simple arithmetic function is a missing value, then the result evaluates to missing value" if(Objects.equals(FieldValues.MISSING_VALUE, left) || Objects.equals(FieldValues.MISSING_VALUE, right)){ return FieldValues.MISSING_VALUE; } DataType dataType = TypeUtil.getCommonDataType(left.getDataType(), right.getDataType()); Number result; try { result = evaluate(left.asNumber(), right.asNumber()); } catch(ArithmeticException ae){ throw new UndefinedResultException() .initCause(ae); } return FieldValueUtil.create(dataType, OpType.CONTINUOUS, result); } }
@Override public int compareToValue(FieldValue value){ Number number; try { number = (Number)TypeUtil.cast(DataType.DOUBLE, value.asNumber()); } catch(TypeCheckException tce){ throw new TypeCheckException(DataType.DOUBLE, value.getValue()); } return ((Comparable)TypeUtil.cast(DataType.DOUBLE, asBoolean())).compareTo(number); }
@Override public FieldValue evaluate(List<FieldValue> arguments){ checkFixedArityArguments(arguments, 1); // Angle in radians Number angle = getRequiredArgument(arguments, 0, "x").asNumber(); Double result = evaluate(angle); if(result.isNaN()){ throw new NaNResultException(); } return FieldValueUtil.create(TypeInfos.CONTINUOUS_DOUBLE, result); } }
@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); } };
@Override public FieldValue evaluate(List<FieldValue> arguments){ StorelessUnivariateStatistic statistic = createStatistic(); DataType dataType = null; for(int i = 0; i < arguments.size(); i++){ FieldValue value = getOptionalArgument(arguments, i); // "Missing values in the input to an aggregate function are simply ignored" if(Objects.equals(FieldValues.MISSING_VALUE, value)){ continue; } statistic.increment((value.asNumber()).doubleValue()); if(dataType != null){ dataType = TypeUtil.getCommonDataType(dataType, value.getDataType()); } else { dataType = value.getDataType(); } } // "If all inputs are missing, then the result evaluates to a missing value" if(statistic.getN() == 0){ return FieldValues.MISSING_VALUE; } Double result = statistic.getResult(); return FieldValueUtil.create(getResultDataType(dataType), OpType.CONTINUOUS, result); }
result.add(value.asNumber()); } else
Number numberValue = value.asNumber();
private void calculateContinuousProbabilities(ProbabilityMap<String, ?> probabilities, TargetValueStats targetValueStats, double threshold, FieldValue value){ Number x = value.asNumber(); for(TargetValueStat targetValueStat : targetValueStats){ String targetCategory = targetValueStat.getValue(); if(targetCategory == null){ throw new MissingAttributeException(targetValueStat, PMMLAttributes.TARGETVALUESTAT_VALUE); } ContinuousDistribution distribution = targetValueStat.getContinuousDistribution(); if(distribution == null){ throw new MissingElementException(MissingElementException.formatMessage(XPathUtil.formatElement(targetValueStat.getClass()) + "/<ContinuousDistribution>"), targetValueStat); } // End if double probability; // "For Naive Bayes models, continuous distribution types are restricted to Gaussian and Poisson distributions" if((distribution instanceof GaussianDistribution) || (distribution instanceof PoissonDistribution)){ if(DistributionUtil.isNoOp(distribution)){ continue; } probability = DistributionUtil.probability(distribution, x); } else { throw new MisplacedElementException(distribution); } // The calculated probability cannot fall below the default probability probability = Math.max(probability, threshold); probabilities.multiply(targetCategory, probability); } }
double time = (value.asNumber()).doubleValue();
Number number = value.asNumber();