public static void inputDouble(QuantileDigestState state, double value, long weight, double accuracy) { inputBigint(state, doubleToSortableLong(value), weight, accuracy); }
public static void inputReal(QuantileDigestState state, long value, long weight, double accuracy) { inputBigint(state, floatToSortableInt(intBitsToFloat((int) value)), weight, accuracy); }
@ScalarFunction("value_at_quantile") @Description("Given an input q between [0, 1], find the value whose rank in the sorted sequence of the n values represented by the qdigest is qn.") @SqlType(StandardTypes.REAL) public static long valueAtQuantileReal(@SqlType("qdigest(real)") Slice input, @SqlType(StandardTypes.DOUBLE) double quantile) { return floatToRawIntBits(sortableIntToFloat((int) valueAtQuantileBigint(input, quantile))); }
@OutputFunction("array(double)") public static void output(@AggregationState DigestAndPercentileArrayState state, BlockBuilder out) { QuantileDigest digest = state.getDigest(); List<Double> percentiles = state.getPercentiles(); if (percentiles == null || digest == null) { out.appendNull(); return; } BlockBuilder blockBuilder = out.beginBlockEntry(); for (int i = 0; i < percentiles.size(); i++) { Double percentile = percentiles.get(i); DOUBLE.writeDouble(blockBuilder, sortableLongToDouble(digest.getQuantile(percentile))); } out.closeEntry(); } }
@ScalarFunction("value_at_quantile") @Description("Given an input q between [0, 1], find the value whose rank in the sorted sequence of the n values represented by the qdigest is qn.") @SqlType(StandardTypes.DOUBLE) public static double valueAtQuantileDouble(@SqlType("qdigest(double)") Slice input, @SqlType(StandardTypes.DOUBLE) double quantile) { return sortableLongToDouble(valueAtQuantileBigint(input, quantile)); }
@InputFunction public static void input(@AggregationState DigestAndPercentileState state, @SqlType(StandardTypes.REAL) long value, @SqlType(StandardTypes.DOUBLE) double percentile) { ApproximateLongPercentileAggregations.input(state, floatToSortableInt(intBitsToFloat((int) value)), percentile); }
@InputFunction public static void input(@AggregationState DigestAndPercentileArrayState state, @SqlType(StandardTypes.DOUBLE) double value, @SqlType("array(double)") Block percentilesArrayBlock) { ApproximateLongPercentileArrayAggregations.input(state, doubleToSortableLong(value), percentilesArrayBlock); }
@OutputFunction("array(real)") public static void output(@AggregationState DigestAndPercentileArrayState state, BlockBuilder out) { QuantileDigest digest = state.getDigest(); List<Double> percentiles = state.getPercentiles(); if (percentiles == null || digest == null) { out.appendNull(); return; } BlockBuilder blockBuilder = out.beginBlockEntry(); for (int i = 0; i < percentiles.size(); i++) { Double percentile = percentiles.get(i); REAL.writeLong(blockBuilder, floatToRawIntBits(sortableIntToFloat((int) digest.getQuantile(percentile)))); } out.closeEntry(); } }
@OutputFunction(StandardTypes.DOUBLE) public static void output(@AggregationState DigestAndPercentileState state, BlockBuilder out) { QuantileDigest digest = state.getDigest(); double percentile = state.getPercentile(); if (digest == null || digest.getCount() == 0.0) { out.appendNull(); } else { checkState(percentile != -1.0, "Percentile is missing"); checkCondition(0 <= percentile && percentile <= 1, INVALID_FUNCTION_ARGUMENT, "Percentile must be between 0 and 1"); DOUBLE.writeDouble(out, sortableLongToDouble(digest.getQuantile(percentile))); } } }
@InputFunction public static void input(@AggregationState DigestAndPercentileArrayState state, @SqlType(StandardTypes.REAL) long value, @SqlType("array(double)") Block percentilesArrayBlock) { ApproximateLongPercentileArrayAggregations.input(state, floatToSortableInt(intBitsToFloat((int) value)), percentilesArrayBlock); }
@InputFunction public static void input(@AggregationState DigestAndPercentileState state, @SqlType(StandardTypes.DOUBLE) double value, @SqlType(StandardTypes.DOUBLE) double percentile) { ApproximateLongPercentileAggregations.input(state, doubleToSortableLong(value), percentile); }
@OutputFunction(StandardTypes.REAL) public static void output(@AggregationState DigestAndPercentileState state, BlockBuilder out) { QuantileDigest digest = state.getDigest(); double percentile = state.getPercentile(); if (digest == null || digest.getCount() == 0.0) { out.appendNull(); } else { checkState(percentile != -1.0, "Percentile is missing"); checkCondition(0 <= percentile && percentile <= 1, INVALID_FUNCTION_ARGUMENT, "Percentile must be between 0 and 1"); REAL.writeLong(out, floatToRawIntBits(sortableIntToFloat((int) digest.getQuantile(percentile)))); } } }
@ScalarFunction("values_at_quantiles") @Description("For each input q between [0, 1], find the value whose rank in the sorted sequence of the n values represented by the qdigest is qn.") @SqlType("array(double)") public static Block valuesAtQuantilesDouble(@SqlType("qdigest(double)") Slice input, @SqlType("array(double)") Block percentilesArrayBlock) { QuantileDigest digest = new QuantileDigest(input); BlockBuilder output = DOUBLE.createBlockBuilder(null, percentilesArrayBlock.getPositionCount()); for (int i = 0; i < percentilesArrayBlock.getPositionCount(); i++) { DOUBLE.writeDouble(output, sortableLongToDouble(digest.getQuantile(DOUBLE.getDouble(percentilesArrayBlock, i)))); } return output.build(); }
@InputFunction public static void weightedInput(@AggregationState DigestAndPercentileArrayState state, @SqlType(StandardTypes.REAL) long value, @SqlType(StandardTypes.BIGINT) long weight, @SqlType("array(double)") Block percentilesArrayBlock) { ApproximateLongPercentileArrayAggregations.weightedInput(state, floatToSortableInt(intBitsToFloat((int) value)), weight, percentilesArrayBlock); }
@InputFunction public static void weightedInput(@AggregationState DigestAndPercentileArrayState state, @SqlType(StandardTypes.DOUBLE) double value, @SqlType(StandardTypes.BIGINT) long weight, @SqlType("array(double)") Block percentilesArrayBlock) { ApproximateLongPercentileArrayAggregations.weightedInput(state, doubleToSortableLong(value), weight, percentilesArrayBlock); }
@ScalarFunction("values_at_quantiles") @Description("For each input q between [0, 1], find the value whose rank in the sorted sequence of the n values represented by the qdigest is qn.") @SqlType("array(real)") public static Block valuesAtQuantilesReal(@SqlType("qdigest(real)") Slice input, @SqlType("array(double)") Block percentilesArrayBlock) { QuantileDigest digest = new QuantileDigest(input); BlockBuilder output = REAL.createBlockBuilder(null, percentilesArrayBlock.getPositionCount()); for (int i = 0; i < percentilesArrayBlock.getPositionCount(); i++) { REAL.writeLong(output, floatToRawIntBits(sortableIntToFloat((int) digest.getQuantile(DOUBLE.getDouble(percentilesArrayBlock, i))))); } return output.build(); }
@InputFunction public static void weightedInput(@AggregationState DigestAndPercentileState state, @SqlType(StandardTypes.REAL) long value, @SqlType(StandardTypes.BIGINT) long weight, @SqlType(StandardTypes.DOUBLE) double percentile) { ApproximateLongPercentileAggregations.weightedInput(state, floatToSortableInt(intBitsToFloat((int) value)), weight, percentile); }
@InputFunction public static void weightedInput(@AggregationState DigestAndPercentileState state, @SqlType(StandardTypes.DOUBLE) double value, @SqlType(StandardTypes.BIGINT) long weight, @SqlType(StandardTypes.DOUBLE) double percentile) { ApproximateLongPercentileAggregations.weightedInput(state, doubleToSortableLong(value), weight, percentile); }
@InputFunction public static void weightedInput(@AggregationState DigestAndPercentileState state, @SqlType(StandardTypes.REAL) long value, @SqlType(StandardTypes.BIGINT) long weight, @SqlType(StandardTypes.DOUBLE) double percentile, @SqlType(StandardTypes.DOUBLE) double accuracy) { ApproximateLongPercentileAggregations.weightedInput(state, floatToSortableInt(intBitsToFloat((int) value)), weight, percentile, accuracy); }
@InputFunction public static void weightedInput(@AggregationState DigestAndPercentileState state, @SqlType(StandardTypes.DOUBLE) double value, @SqlType(StandardTypes.BIGINT) long weight, @SqlType(StandardTypes.DOUBLE) double percentile, @SqlType(StandardTypes.DOUBLE) double accuracy) { ApproximateLongPercentileAggregations.weightedInput(state, doubleToSortableLong(value), weight, percentile, accuracy); }