@Test public void updateDoubleSummary() { DoubleSummary ds = new DoubleSummary(); ds.update(1.0); Assert.assertEquals(ds.getValue(), 1.0); }
@Test public void serialVersion1Compatibility() throws Exception { byte[] bytes = TestUtil.readBytesFromFile(getClass().getClassLoader() .getResource("CompactSketchWithDoubleSummary4K_serialVersion1.bin").getFile()); Sketch<DoubleSummary> sketch = Sketches.heapifySketch(Memory.wrap(bytes), new DoubleSummaryDeserializer()); Assert.assertTrue(sketch.isEstimationMode()); Assert.assertEquals(sketch.getEstimate(), 8192, 8192 * 0.99); Assert.assertEquals(sketch.getRetainedEntries(), 4096); int count = 0; SketchIterator<DoubleSummary> it = sketch.iterator(); while (it.next()) { Assert.assertEquals(it.getSummary().getValue(), 1.0); count++; } Assert.assertEquals(count, 4096); }
@Test public void serialVersion1Compatibility() throws Exception { byte[] bytes = TestUtil.readBytesFromFile(getClass().getClassLoader() .getResource("UpdatableSketchWithDoubleSummary4K_serialVersion1.bin").getFile()); UpdatableSketch<Double, DoubleSummary> sketch = Sketches.heapifyUpdatableSketch( Memory.wrap(bytes), new DoubleSummaryDeserializer(), new DoubleSummaryFactory()); Assert.assertTrue(sketch.isEstimationMode()); Assert.assertEquals(sketch.getEstimate(), 8192, 8192 * 0.99); Assert.assertEquals(sketch.getRetainedEntries(), 4096); int count = 0; SketchIterator<DoubleSummary> it = sketch.iterator(); while (it.next()) { Assert.assertEquals(it.getSummary().getValue(), 10.0); count++; } Assert.assertEquals(count, 4096); }
@Test public void doubleSummaryMaxMode() { UpdatableSketch<Double, DoubleSummary> sketch = new UpdatableSketchBuilder<>( new DoubleSummaryFactory(DoubleSummary.Mode.Max)).build(); { sketch.update(1, 1.0); Assert.assertEquals(sketch.getRetainedEntries(), 1); SketchIterator<DoubleSummary> it = sketch.iterator(); Assert.assertTrue(it.next()); Assert.assertEquals(it.getSummary().getValue(), 1.0); Assert.assertFalse(it.next()); } { sketch.update(1, 0.7); Assert.assertEquals(sketch.getRetainedEntries(), 1); SketchIterator<DoubleSummary> it = sketch.iterator(); Assert.assertTrue(it.next()); Assert.assertEquals(it.getSummary().getValue(), 1.0); Assert.assertFalse(it.next()); } { sketch.update(1, 2.0); Assert.assertEquals(sketch.getRetainedEntries(), 1); SketchIterator<DoubleSummary> it = sketch.iterator(); Assert.assertTrue(it.next()); Assert.assertEquals(it.getSummary().getValue(), 2.0); Assert.assertFalse(it.next()); } }
@Test public void doubleSummaryDefaultSumMode() { UpdatableSketch<Double, DoubleSummary> sketch = new UpdatableSketchBuilder<>( new DoubleSummaryFactory()).build(); { sketch.update(1, 1.0); Assert.assertEquals(sketch.getRetainedEntries(), 1); SketchIterator<DoubleSummary> it = sketch.iterator(); Assert.assertTrue(it.next()); Assert.assertEquals(it.getSummary().getValue(), 1.0); Assert.assertFalse(it.next()); } { sketch.update(1, 0.7); Assert.assertEquals(sketch.getRetainedEntries(), 1); SketchIterator<DoubleSummary> it = sketch.iterator(); Assert.assertTrue(it.next()); Assert.assertEquals(it.getSummary().getValue(), 1.7); Assert.assertFalse(it.next()); } { sketch.update(1, 0.8); Assert.assertEquals(sketch.getRetainedEntries(), 1); SketchIterator<DoubleSummary> it = sketch.iterator(); Assert.assertTrue(it.next()); Assert.assertEquals(it.getSummary().getValue(), 2.5); Assert.assertFalse(it.next()); } }
SketchIterator<DoubleSummary> it = sketch.iterator(); Assert.assertTrue(it.next()); Assert.assertEquals(it.getSummary().getValue(), 1.0); Assert.assertFalse(it.next()); SketchIterator<DoubleSummary> it = sketch.iterator(); Assert.assertTrue(it.next()); Assert.assertEquals(it.getSummary().getValue(), 0.7); Assert.assertFalse(it.next()); SketchIterator<DoubleSummary> it = sketch.iterator(); Assert.assertTrue(it.next()); Assert.assertEquals(it.getSummary().getValue(), 0.7); Assert.assertFalse(it.next());
@Test public void filledSketchShouldFilterOutElements() { UpdatableSketch<Double, DoubleSummary> sketch = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); fillSketch(sketch, numberOfElements, 0.0); fillSketch(sketch, 2 * numberOfElements, 1.0); Filter<DoubleSummary> filter = new Filter<>(o -> o.getValue() < 0.5); Sketch<DoubleSummary> filteredSketch = filter.filter(sketch); Assert.assertEquals(filteredSketch.getEstimate(), (double) numberOfElements); Assert.assertEquals(filteredSketch.getThetaLong(), sketch.getThetaLong()); Assert.assertFalse(filteredSketch.isEmpty()); Assert.assertTrue(filteredSketch.getLowerBound(1) <= filteredSketch.getEstimate()); Assert.assertTrue(filteredSketch.getUpperBound(1) >= filteredSketch.getEstimate()); }
SketchIterator<DoubleSummary> it = sketch.iterator(); while (it.next()) { Assert.assertEquals(it.getSummary().getValue(), 1.0); count++;
@Test public void exactModeFromQuickSelectSketch() { UpdatableSketch<Double, DoubleSummary> us = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); us.update(1, 1.0); us.update(2, 1.0); us.update(3, 1.0); us.update(1, 1.0); us.update(2, 1.0); us.update(3, 1.0); CompactSketch<DoubleSummary> sketch = us.compact(); Assert.assertFalse(sketch.isEmpty()); Assert.assertFalse(sketch.isEstimationMode()); Assert.assertEquals(sketch.getEstimate(), 3.0); Assert.assertEquals(sketch.getLowerBound(1), 3.0); Assert.assertEquals(sketch.getUpperBound(1), 3.0); Assert.assertEquals(sketch.getRetainedEntries(), 3); Assert.assertEquals(sketch.getThetaLong(), Long.MAX_VALUE); Assert.assertEquals(sketch.getTheta(), 1.0); SketchIterator<DoubleSummary> it = sketch.iterator(); int count = 0; while (it.next()) { Assert.assertEquals(it.getSummary().getValue(), 2.0); count++; } Assert.assertEquals(count, 3); }
SketchIterator<DoubleSummary> it = sketch.iterator(); while (it.next()) { Assert.assertEquals(it.getSummary().getValue(), 1.0); count++;
@Test public void filteringInEstimationMode() { UpdatableSketch<Double, DoubleSummary> sketch = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); int n = 10000; fillSketch(sketch, n, 0.0); fillSketch(sketch, 2 * n, 1.0); Filter<DoubleSummary> filter = new Filter<>(o -> o.getValue() < 0.5); Sketch<DoubleSummary> filteredSketch = filter.filter(sketch); Assert.assertEquals(filteredSketch.getEstimate(), n, n * 0.05); Assert.assertEquals(filteredSketch.getThetaLong(), sketch.getThetaLong()); Assert.assertFalse(filteredSketch.isEmpty()); Assert.assertTrue(filteredSketch.getLowerBound(1) <= filteredSketch.getEstimate()); Assert.assertTrue(filteredSketch.getUpperBound(1) >= filteredSketch.getEstimate()); }
@Test public void serializeDeserializeSmallExact() { UpdatableSketch<Double, DoubleSummary> us = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); us.update("a", 1.0); us.update("b", 1.0); us.update("c", 1.0); CompactSketch<DoubleSummary> sketch1 = us.compact(); Sketch<DoubleSummary> sketch2 = Sketches.heapifySketch(Memory.wrap(sketch1.toByteArray()), new DoubleSummaryDeserializer()); Assert.assertFalse(sketch2.isEmpty()); Assert.assertFalse(sketch2.isEstimationMode()); Assert.assertEquals(sketch2.getEstimate(), 3.0); Assert.assertEquals(sketch2.getLowerBound(1), 3.0); Assert.assertEquals(sketch2.getUpperBound(1), 3.0); Assert.assertEquals(sketch2.getRetainedEntries(), 3); Assert.assertEquals(sketch2.getThetaLong(), Long.MAX_VALUE); Assert.assertEquals(sketch2.getTheta(), 1.0); SketchIterator<DoubleSummary> it = sketch2.iterator(); int count = 0; while (it.next()) { Assert.assertEquals(it.getSummary().getValue(), 1.0); count++; } Assert.assertEquals(count, 3); }
@Test public void serializeDeserializeExact() throws Exception { UpdatableSketch<Double, DoubleSummary> sketch1 = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); sketch1.update(1, 1.0); UpdatableSketch<Double, DoubleSummary> sketch2 = Sketches.heapifyUpdatableSketch( Memory.wrap(sketch1.toByteArray()), new DoubleSummaryDeserializer(), new DoubleSummaryFactory()); Assert.assertEquals(sketch2.getEstimate(), 1.0); SketchIterator<DoubleSummary> it = sketch2.iterator(); Assert.assertTrue(it.next()); Assert.assertEquals(it.getSummary().getValue(), 1.0); Assert.assertFalse(it.next()); // the same key, so still one unique sketch2.update(1, 1.0); Assert.assertEquals(sketch2.getEstimate(), 1.0); sketch2.update(2, 1.0); Assert.assertEquals(sketch2.getEstimate(), 2.0); }
@Test public void serializeDeserializeEstimation() throws Exception { UpdatableSketch<Double, DoubleSummary> us = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); for (int i = 0; i < 8192; i++) us.update(i, 1.0); us.trim(); CompactSketch<DoubleSummary> sketch1 = us.compact(); byte[] bytes = sketch1.toByteArray(); // for visual testing //TestUtil.writeBytesToFile(bytes, "CompactSketchWithDoubleSummary4K.bin"); Sketch<DoubleSummary> sketch2 = Sketches.heapifySketch(Memory.wrap(bytes), new DoubleSummaryDeserializer()); Assert.assertFalse(sketch2.isEmpty()); Assert.assertTrue(sketch2.isEstimationMode()); Assert.assertEquals(sketch2.getEstimate(), sketch1.getEstimate()); Assert.assertEquals(sketch2.getThetaLong(), sketch1.getThetaLong()); SketchIterator<DoubleSummary> it = sketch2.iterator(); int count = 0; while (it.next()) { Assert.assertEquals(it.getSummary().getValue(), 1.0); count++; } Assert.assertEquals(count, 4096); }
@Test public void serializeDeserializeEstimationNoResizing() throws Exception { UpdatableSketch<Double, DoubleSummary> sketch1 = new UpdatableSketchBuilder<>( new DoubleSummaryFactory()).setResizeFactor(ResizeFactor.X1).build(); for (int j = 0; j < 10; j++) { for (int i = 0; i < 8192; i++) { sketch1.update(i, 1.0); } } sketch1.trim(); byte[] bytes = sketch1.toByteArray(); //for visual testing //TestUtil.writeBytesToFile(bytes, "UpdatableSketchWithDoubleSummary4K.bin"); Sketch<DoubleSummary> sketch2 = Sketches.heapifySketch(Memory.wrap(bytes), new DoubleSummaryDeserializer()); Assert.assertTrue(sketch2.isEstimationMode()); Assert.assertEquals(sketch2.getEstimate(), 8192, 8192 * 0.99); Assert.assertEquals(sketch1.getTheta(), sketch2.getTheta()); SketchIterator<DoubleSummary> it = sketch2.iterator(); int count = 0; while (it.next()) { Assert.assertEquals(it.getSummary().getValue(), 10.0); count++; } Assert.assertEquals(count, 4096); }
@Test public void aNotBExactMode() { UpdatableSketch<Double, DoubleSummary> sketchA = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); sketchA.update(1, 1.0); sketchA.update(1, 1.0); sketchA.update(2, 1.0); sketchA.update(2, 1.0); UpdatableSketch<Double, DoubleSummary> sketchB = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); sketchB.update(2, 1.0); sketchB.update(2, 1.0); sketchB.update(3, 1.0); sketchB.update(3, 1.0); AnotB<DoubleSummary> aNotB = new AnotB<>(); aNotB.update(sketchA, sketchB); CompactSketch<DoubleSummary> result = aNotB.getResult(); Assert.assertEquals(result.getRetainedEntries(), 1); Assert.assertFalse(result.isEmpty()); Assert.assertEquals(result.getEstimate(), 1.0); Assert.assertEquals(result.getLowerBound(1), 1.0); Assert.assertEquals(result.getUpperBound(1), 1.0); SketchIterator<DoubleSummary> it = result.iterator(); Assert.assertTrue(it.next()); Assert.assertEquals(it.getSummary().getValue(), 2.0); Assert.assertFalse(it.next()); }
SketchIterator<DoubleSummary> it = result.iterator(); Assert.assertTrue(it.next()); Assert.assertEquals(it.getSummary().getValue(), 4.0); Assert.assertFalse(it.next());
@Test public void intersectionEstimationMode() { int key = 0; UpdatableSketch<Double, DoubleSummary> sketch1 = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); for (int i = 0; i < 8192; i++) { sketch1.update(key++, 1.0); } key -= 4096; // overlap half of the entries UpdatableSketch<Double, DoubleSummary> sketch2 = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); for (int i = 0; i < 8192; i++) { sketch2.update(key++, 1.0); } Intersection<DoubleSummary> intersection = new Intersection<>(new DoubleSummarySetOperations()); intersection.update(sketch1); intersection.update(sketch2); CompactSketch<DoubleSummary> result = intersection.getResult(); Assert.assertFalse(result.isEmpty()); // crude estimate of RSE(95%) = 2 / sqrt(result.getRetainedEntries()) Assert.assertEquals(result.getEstimate(), 4096.0, 4096 * 0.03); Assert.assertTrue(result.getLowerBound(1) <= result.getEstimate()); Assert.assertTrue(result.getUpperBound(1) > result.getEstimate()); SketchIterator<DoubleSummary> it = result.iterator(); while (it.next()) { Assert.assertEquals(it.getSummary().getValue(), 2.0); } }