@Override public double get(Object o) { return ((org.apache.hadoop.io.DoubleWritable) o).get(); }
/** {@inheritDoc} */ @Override public Double convert(DoubleWritable input) { return input.get(); }
public Double convert(Writable o) { return ((DoubleWritable)o).get(); } });
@Override protected void reduce(LongWritable key, Iterable<DoubleWritable> values, Context context) throws IOException, InterruptedException { double totalRate = 0; int activeMappers = 0; for (DoubleWritable value : values) { totalRate += value.get(); activeMappers++; } context.write(key, new Text(String.format("%f\t%d", totalRate, activeMappers))); } }
/** * Calculates the hash code for array of Objects that contains writables. This is used * to work around the buggy Hadoop DoubleWritable hashCode implementation. This should * only be used for process-local hash codes; don't replace stored hash codes like bucketing. */ public static int writableArrayHashCode(Object[] keys) { if (keys == null) return 0; int hashcode = 1; for (Object element : keys) { hashcode = 31 * hashcode; if (element == null) { // nothing } else if (element instanceof LazyDouble) { long v = Double.doubleToLongBits(((LazyDouble) element).getWritableObject().get()); hashcode = hashcode + (int) (v ^ (v >>> 32)); } else if (element instanceof DoubleWritable) { long v = Double.doubleToLongBits(((DoubleWritable) element).get()); hashcode = hashcode + (int) (v ^ (v >>> 32)); } else if (element instanceof Object[]) { // use deep hashcode for arrays hashcode = hashcode + Arrays.deepHashCode((Object[]) element); } else { hashcode = hashcode + element.hashCode(); } } return hashcode; }
return ((DoubleWritable) writable).get();
protected void runTestStr(String date1, String date2, Double expDiff, GenericUDFMonthsBetween udf) throws HiveException { DeferredJavaObject valueObj1 = new DeferredJavaObject(date1 == null ? null : new Text(date1)); DeferredJavaObject valueObj2 = new DeferredJavaObject(date2 == null ? null : new Text(date2)); DeferredObject[] args = new DeferredObject[] { valueObj1, valueObj2 }; DoubleWritable output = (DoubleWritable) udf.evaluate(args); if (expDiff == null) { assertNull("months_between() test for NULL STRING failed", output); } else { assertNotNull("months_between() test for NOT NULL STRING failed", output); assertEquals("months_between() test for STRING failed", expDiff, output.get(), 0.00000001D); } }
generator.writeNumber(((DoubleWritable) writable).get());
actualValue = ((DoubleWritable) actualValue).get();
protected void runTestTs(String ts1, String ts2, Double expDiff, GenericUDFMonthsBetween udf) throws HiveException { TimestampWritableV2 tsWr1 = ts1 == null ? null : new TimestampWritableV2(Timestamp.valueOf(ts1)); TimestampWritableV2 tsWr2 = ts2 == null ? null : new TimestampWritableV2(Timestamp.valueOf(ts2)); DeferredJavaObject valueObj1 = new DeferredJavaObject(tsWr1); DeferredJavaObject valueObj2 = new DeferredJavaObject(tsWr2); DeferredObject[] args = new DeferredObject[] { valueObj1, valueObj2 }; DoubleWritable output = (DoubleWritable) udf.evaluate(args); if (expDiff == null) { assertNull("months_between() test for NULL TIMESTAMP failed", output); } else { assertNotNull("months_between() test for NOT NULL TIMESTAMP failed", output); assertEquals("months_between() test for TIMESTAMP failed", expDiff, output.get(), 0.00000001D); } }
protected void runTestDt(String dt1, String dt2, Double expDiff, GenericUDFMonthsBetween udf) throws HiveException { DateWritableV2 dtWr1 = dt1 == null ? null : new DateWritableV2(Date.valueOf(dt1)); DateWritableV2 dtWr2 = dt2 == null ? null : new DateWritableV2(Date.valueOf(dt2)); DeferredJavaObject valueObj1 = new DeferredJavaObject(dtWr1); DeferredJavaObject valueObj2 = new DeferredJavaObject(dtWr2); DeferredObject[] args = new DeferredObject[] { valueObj1, valueObj2 }; DoubleWritable output = (DoubleWritable) udf.evaluate(args); if (expDiff == null) { assertNull("months_between() test for NULL DATE failed", output); } else { assertNotNull("months_between() test for NOT NULL DATE failed", output); assertEquals("months_between() test for DATE failed", expDiff, output.get(), 0.00000001D); } } }
public void reduce (final IntWritable key, final Iterator<DoubleWritable> values, final OutputCollector<IntWritable, DoubleWritable> output, final Reporter reporter) throws IOException { double sum = 0; int count = 0; while (values.hasNext()) { double cur_val = values.next().get(); sum += cur_val; count++; } output.collect( key, new DoubleWritable( sum/count ) ); } }
public void reduce (final Text key, final Iterator<DoubleWritable> values, final OutputCollector<Text, DoubleWritable> output, final Reporter reporter) throws IOException { double sum = 0; while (values.hasNext()) { double cur_val = values.next().get(); sum += cur_val; } output.collect( key, new DoubleWritable( sum ) ); } }
public void reduce (final IntWritable key, final Iterator<DoubleWritable> values, final OutputCollector<IntWritable, DoubleWritable> output, final Reporter reporter) throws IOException { double sum = 0; while (values.hasNext()) { double cur_val = values.next().get(); sum += cur_val; } output.collect( key, new DoubleWritable( sum ) ); } }
public void reduce (final LongWritable key, final Iterator<DoubleWritable> values, final OutputCollector<LongWritable, DoubleWritable> output, final Reporter reporter) throws IOException { double sum = 0; while (values.hasNext()) { double cur_val = values.next().get(); sum += cur_val; } output.collect( key, new DoubleWritable( sum ) ); } }
@Override public Tuple2<Tuple2<String,String>,Double> call(Tuple2<PairOfStrings,DoubleWritable> rec) { PairOfStrings pair = rec._1; Tuple2<String,String> K2 = new Tuple2<String,String>(pair.getLeftElement(), pair.getRightElement()); Double V2 = rec._2.get(); return new Tuple2<Tuple2<String,String>,Double>(K2, V2); } });
actualValue = ((DoubleWritable) actualValue).get();