@Override protected Double getTestValue(final DoublesUnion object) { return object.getResult().getQuantile(0.5D); // assertEquals(quantile1, unionDeserialised.getResult().getQuantile(0.5D), DELTA); }
@Test public void checkBounds() { final UpdateDoublesSketch sketch = DoublesSketch.builder().build(); for (int i = 0; i < 1000; i++) { sketch.update(i); } double eps = sketch.getNormalizedRankError(false); double est = sketch.getQuantile(0.5); double ub = sketch.getQuantileUpperBound(0.5); double lb = sketch.getQuantileLowerBound(0.5); assertEquals(ub, sketch.getQuantile(.5 + eps)); assertEquals(lb, sketch.getQuantile(0.5 - eps)); println("Ext : " + est); println("UB : " + ub); println("LB : " + lb); }
qs3.update(i); assert (qs1.getQuantile (0.0) == 1.0); assert (qs1.getQuantile (0.5) == 5.0); assert (qs1.getQuantile (1.0) == 8.0); assert (qs2.getQuantile (0.0) == 11.0); assert (qs2.getQuantile (0.5) == 15.0); assert (qs2.getQuantile (1.0) == 18.0); assert (qs3.getQuantile (0.0) == 1.0); assert (qs3.getQuantile (0.5) == 5.0); assert (qs3.getQuantile (1.0) == 8.0);
assertTrue(qs1.getQuantile(0.0) == 1.0); assertTrue(qs1.getQuantile(1.0) == 999.0); assertTrue(qs2.getQuantile(0.0) == 1001.0); assertTrue(qs2.getQuantile(1.0) == 1999.0); assertTrue((qs3.getQuantile(0.0) == 1.0)); assertTrue(qs3.getQuantile(1.0) == 999.0);
@Test public void testAggregate() { final DoublesUnionAggregator unionAggregator = new DoublesUnionAggregator(); DoublesUnion currentState = union1; assertEquals(3L, currentState.getResult().getN()); assertEquals(2.0D, currentState.getResult().getQuantile(0.5D), DELTA); currentState = unionAggregator.apply(currentState, union2); assertEquals(7L, currentState.getResult().getN()); assertEquals(4.0D, currentState.getResult().getQuantile(0.5D), DELTA); }
assertTrue(qs1.getQuantile(0.0) == 1.0); assertTrue(qs1.getQuantile(1.0) == 999.0); assertTrue(qs2.getQuantile(0.0) == 1001.0); assertTrue(qs2.getQuantile(1.0) == 1999.0); assertTrue((qs3.getQuantile(0.0) == 1.0)); assertTrue(qs3.getQuantile(1.0) == 999.0);
@Test public void itemsToDoubles() { final ItemsSketch<Double> sketch1 = ItemsSketch.getInstance(Comparator.naturalOrder()); for (int i = 1; i <= 500; i++) { sketch1.update((double) i); } final byte[] bytes = sketch1.toByteArray(serDe); final UpdateDoublesSketch sketch2; sketch2 = UpdateDoublesSketch.heapify(Memory.wrap(bytes)); for (int i = 501; i <= 1000; i++) { sketch2.update(i); } Assert.assertEquals(sketch2.getN(), 1000); Assert.assertTrue(sketch2.getRetainedItems() < 1000); Assert.assertEquals(sketch2.getMinValue(), 1.0); Assert.assertEquals(sketch2.getMaxValue(), 1000.0); // based on ~1.7% normalized rank error for this particular case Assert.assertEquals(sketch2.getQuantile(0.5), 500.0, 17); }
qs3.update(i); assert (qs1.getQuantile (0.0) == 1.0); assert (qs1.getQuantile (0.5) == 5.0); assert (qs1.getQuantile (1.0) == 8.0); assert (qs2.getQuantile (0.0) == 11.0); assert (qs2.getQuantile (0.5) == 15.0); assert (qs2.getQuantile (1.0) == 18.0); assert (qs3.getQuantile (0.0) == 1.0); assert (qs3.getQuantile (0.5) == 5.0); assert (qs3.getQuantile (1.0) == 8.0);
@Test public void serializeDeserializeEmptyNonCompact() { UpdateDoublesSketch sketch1 = DoublesSketch.builder().build(); byte[] byteArr = sketch1.toByteArray(false); //Ordered, Not Compact, Empty assertEquals(byteArr.length, sketch1.getStorageBytes()); Memory mem = Memory.wrap(byteArr); UpdateDoublesSketch sketch2 = (UpdateDoublesSketch) DoublesSketch.heapify(mem); for (int i = 0; i < 1000; i++) { sketch2.update(i); } assertEquals(sketch2.getMinValue(), 0.0); assertEquals(sketch2.getMaxValue(), 999.0); assertEquals(sketch2.getQuantile(0.5), 500.0, 4.0); }
@Test public void serializeDeserializeCompact() { UpdateDoublesSketch sketch1 = DoublesSketch.builder().build(); for (int i = 0; i < 1000; i++) { sketch1.update(i); } UpdateDoublesSketch sketch2; sketch2 = (UpdateDoublesSketch) DoublesSketch.heapify(Memory.wrap(sketch1.toByteArray())); for (int i = 0; i < 1000; i++) { sketch2.update(i + 1000); } assertEquals(sketch2.getMinValue(), 0.0); assertEquals(sketch2.getMaxValue(), 1999.0); assertEquals(sketch2.getQuantile(0.5), 1000.0, 10.0); }
@Test public void directToHeap() { int sizeBytes = 10000; UpdateDoublesSketch directSketch = DoublesSketch.builder().build(WritableMemory.wrap(new byte[sizeBytes])); for (int i = 0; i < 1000; i++) { directSketch.update(i); } UpdateDoublesSketch heapSketch; heapSketch = (UpdateDoublesSketch) DoublesSketch.heapify(WritableMemory.wrap(directSketch.toByteArray())); for (int i = 0; i < 1000; i++) { heapSketch.update(i + 1000); } assertEquals(heapSketch.getMinValue(), 0.0); assertEquals(heapSketch.getMaxValue(), 1999.0); assertEquals(heapSketch.getQuantile(0.5), 1000.0, 10.0); }
@Test public void checkWrapInstance() { final int k = 128; final int n = 1000; final UpdateDoublesSketch sketch = DoublesSketch.builder().setK(k).build(); for (int i = 1; i <= n; i++) { sketch.update(i); } final double skMedian = sketch.getQuantile(.5); Assert.assertEquals(skMedian, 500, 10); final byte[] byteArr = sketch.toByteArray(false); final WritableMemory mem = WritableMemory.wrap(byteArr); final DoublesUnion union = DoublesUnion.wrap(mem); Assert.assertFalse(union.isEmpty()); assertTrue(union.isDirect()); final DoublesSketch sketch2 = union.getResult(); final double uMedian = sketch2.getQuantile(0.5); Assert.assertEquals(skMedian, uMedian, 0.0); // check serializing again final byte[] bytesOut = union.toByteArray(); assertEquals(bytesOut.length, byteArr.length); assertEquals(bytesOut, byteArr); // wrapped, so should be exact }
@Test public void serializeDeserialize() { int sizeBytes = DoublesSketch.getUpdatableStorageBytes(128, 2000); WritableMemory mem = WritableMemory.wrap(new byte[sizeBytes]); UpdateDoublesSketch sketch1 = DoublesSketch.builder().build(mem); for (int i = 0; i < 1000; i++) { sketch1.update(i); } UpdateDoublesSketch sketch2 = UpdateDoublesSketch.wrap(mem); for (int i = 0; i < 1000; i++) { sketch2.update(i + 1000); } assertEquals(sketch2.getMinValue(), 0.0); assertEquals(sketch2.getMaxValue(), 1999.0); assertEquals(sketch2.getQuantile(0.5), 1000.0, 10.0); byte[] arr2 = sketch2.toByteArray(false); assertEquals(arr2.length, sketch2.getStorageBytes()); DoublesSketch sketch3 = DoublesSketch.wrap(WritableMemory.wrap(arr2)); assertEquals(sketch3.getMinValue(), 0.0); assertEquals(sketch3.getMaxValue(), 1999.0); assertEquals(sketch3.getQuantile(0.5), 1000.0, 10.0); }
@Test public void checkLimitedMemoryScenarios() { //Requesting application final int k = 128; final int u = 40 * k; final int initBytes = ((2 * k) + 4) << 3; //just the BB //########## Owning Implementation // This part would actually be part of the Memory owning implemention so it is faked here try (WritableDirectHandle wdh = WritableMemory.allocateDirect(initBytes)) { final WritableMemory wmem = wdh.get(); println("Initial mem size: " + wmem.getCapacity()); //########## Receiving Application // The receiving application has been given wmem to use for a sketch, // but alas, it is not ultimately large enough. final UpdateDoublesSketch usk1 = DoublesSketch.builder().setK(k).build(wmem); assertTrue(usk1.isEmpty()); //Load the sketch for (int i = 0; i < u; i++) { // The sketch uses The MemoryRequest, acquired from wmem, to acquire more memory as // needed, and requests via the MemoryRequest to free the old allocations. usk1.update(i); } final double result = usk1.getQuantile(0.5); println("Result: " + result); assertEquals(result, u / 2.0, 0.05 * u); //Success //########## Owning Implementation //The actual Memory has been re-allocated several times, // so the above wmem reference is invalid. println("\nFinal mem size: " + wmem.getCapacity()); } }