@Override public Object getWritableConstantValue() { if (value==null) { return null; } return new DoubleWritable(value); } }
@Override public Object create(double value) { return new DoubleWritable(value); }
LazyBinaryDouble(WritableDoubleObjectInspector oi) { super(oi); data = new DoubleWritable(); }
@Override public DoubleWritable div(DoubleWritable sum, long numRows) { if (sum == null || numRows == 0) return null; return new DoubleWritable(sum.get() / (double)numRows); } }
@Override protected Object doTerminate(AverageAggregationBuffer<Double> aggregation) { if(aggregation.count == 0) { return null; } else { DoubleWritable result = new DoubleWritable(0); result.set(aggregation.sum / aggregation.count); return result; } } @Override
protected DoubleWritable round(DoubleWritable input, int scale) { double d = input.get(); if (Double.isNaN(d) || Double.isInfinite(d)) { return new DoubleWritable(d); } else { return new DoubleWritable(RoundUtils.round(d, scale)); } }
@Override protected DoubleWritable round(DoubleWritable input, int scale) { double d = input.get(); if (Double.isNaN(d) || Double.isInfinite(d)) { return new DoubleWritable(d); } else { return new DoubleWritable(RoundUtils.bround(d, scale)); } }
@Override public Object copyObject(Object o) { return o == null ? null : new DoubleWritable(get(o)); }
protected DoubleWritable trunc(DoubleWritable input, int scale) { BigDecimal bigDecimal = new BigDecimal(input.get()); BigDecimal trunc = trunc(bigDecimal, scale); DoubleWritable doubleWritable = new DoubleWritable(trunc.doubleValue()); return doubleWritable; }
@Override public ObjectInspector init(Mode m, ObjectInspector[] parameters) throws HiveException { assert (parameters.length == 1); super.init(m, parameters); result = new DoubleWritable(0); inputOI = (PrimitiveObjectInspector) parameters[0]; outputOI = (PrimitiveObjectInspector)ObjectInspectorUtils.getStandardObjectInspector(inputOI, ObjectInspectorCopyOption.JAVA); return PrimitiveObjectInspectorFactory.writableDoubleObjectInspector; }
public DoubleWritable readDouble(DoubleWritable dw) throws IOException { if (dw == null) { dw = new DoubleWritable(); } dw.set(in.readDouble()); return dw; }
@Override public Object terminate(AggregationBuffer agg) throws HiveException { PercentileAggBuf myagg = (PercentileAggBuf) agg; if (myagg.histogram.getUsedBins() < 1) { // SQL standard - return null for zero elements return null; } else { assert(myagg.quantiles != null); return new DoubleWritable(myagg.histogram.quantile(myagg.quantiles[0])); } } }
@Override protected void doTerminatePartial(AverageAggregationBuffer<Double> aggregation) { if(partialResult[1] == null) { partialResult[1] = new DoubleWritable(0); } ((LongWritable) partialResult[0]).set(aggregation.count); ((DoubleWritable) partialResult[1]).set(aggregation.sum); }
@Override public DoubleWritable add(DoubleWritable t1, DoubleWritable t2) { if (t1 == null && t2 == null) return null; return new DoubleWritable((t1 == null ? 0 : t1.get()) + (t2 == null ? 0 : t2.get())); }
public void avgDouble(Iterator<Double> inVals, int inSz, int numPreceding, int numFollowing, Iterator<Double> outVals) throws HiveException { GenericUDAFAverage fnR = new GenericUDAFAverage(); TypeInfo[] inputTypes = { TypeInfoFactory.doubleTypeInfo }; ObjectInspector[] inputOIs = { PrimitiveObjectInspectorFactory.writableDoubleObjectInspector }; DoubleWritable[] in = new DoubleWritable[1]; in[0] = new DoubleWritable(); TestStreamingSum._agg(fnR, inputTypes, inVals, TypeHandler.DoubleHandler, in, inputOIs, inSz, numPreceding, numFollowing, outVals); }
@Test(expected = AssertionError.class) public void testPrimitiveDoubleNaN() throws SerDeException { String[][] schema = { {"double1", "double"}, }; Object[][] rows = {{new DoubleWritable(Double.NaN)}}; initAndSerializeAndDeserialize(schema, rows); }
public void sumDouble(Iterator<Double> inVals, int inSz, int numPreceding, int numFollowing, Iterator<Double> outVals) throws HiveException { GenericUDAFSum fnR = new GenericUDAFSum(); TypeInfo[] inputTypes = { TypeInfoFactory.doubleTypeInfo }; ObjectInspector[] inputOIs = { PrimitiveObjectInspectorFactory.writableDoubleObjectInspector }; DoubleWritable[] in = new DoubleWritable[1]; in[0] = new DoubleWritable(); _agg(fnR, inputTypes, inVals, TypeHandler.DoubleHandler, in, inputOIs, inSz, numPreceding, numFollowing, outVals); }
private void runDouble(double v, IntWritable scale, Double expV, GenericUDF udf) throws HiveException { DeferredObject valueObj0 = new DeferredJavaObject(new DoubleWritable(v)); DeferredObject valueObj1 = new DeferredJavaObject(scale); DeferredObject[] args = { valueObj0, valueObj1 }; DoubleWritable output = (DoubleWritable) udf.evaluate(args); Assert.assertEquals("bround() test ", expV.doubleValue(), output.get(), 0.00001); }
private void runAndVerify(Double in, Double expResult, GenericUDF udf) throws HiveException { DeferredObject valueObj0 = new DeferredJavaObject(in != null ? new DoubleWritable(in) : null); DeferredObject[] args = { valueObj0 }; DoubleWritable output = (DoubleWritable) udf.evaluate(args); if (expResult == null) { assertNull("cbrt() test", output); } else { assertNotNull("cbrt() test", output); assertEquals("cbrt() test", expResult.doubleValue(), output.get(), 1E-10); } } }
private Writable getWritableValue(TypeInfo ti, double value) { if (ti.equals(TypeInfoFactory.floatTypeInfo)) { return new FloatWritable((float) value); } else if (ti.equals(TypeInfoFactory.doubleTypeInfo)) { return new DoubleWritable(value); } return null; }