/** * Updates this sketch with a long key and U value. * The value is passed to update() method of the Summary object associated with the key * * @param key The given long key * @param value The given U value */ public void update(final long key, final U value) { update(new long[] {key}, value); }
/** * Updates this sketch with a double key and U value. * The value is passed to update() method of the Summary object associated with the key * * @param key The given double key * @param value The given U value */ public void update(final double key, final U value) { update(Util.doubleToLongArray(key), value); }
/** * Updates this sketch with a String key and U value. * The value is passed to update() method of the Summary object associated with the key * * @param key The given String key * @param value The given U value */ public void update(final String key, final U value) { update(Util.stringToByteArray(key), value); }
private static void fillSketch(UpdatableSketch<Double, DoubleSummary> sketch, int numberOfElements, Double sketchValue) { for (int cont = 0; cont < numberOfElements; cont++) { sketch.update(random.nextLong(), sketchValue); } } }
@Test public void updatesOfAllKeyTypes() { UpdatableSketch<Double, DoubleSummary> sketch = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); sketch.update(1L, 1.0); sketch.update(2.0, 1.0); byte[] bytes = { 3 }; sketch.update(bytes, 1.0); int[] ints = { 4 }; sketch.update(ints, 1.0); long[] longs = { 5L }; sketch.update(longs, 1.0); sketch.update("a", 1.0); Assert.assertEquals(sketch.getEstimate(), 6.0); }
@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()); }
@Test public void sampling() { float samplingProbability = 0.001f; UpdatableSketch<Double, DoubleSummary> sketch = new UpdatableSketchBuilder<>( new DoubleSummaryFactory()).setSamplingProbability(samplingProbability).build(); sketch.update("a", 1.0); Assert.assertFalse(sketch.isEmpty()); Assert.assertTrue(sketch.isEstimationMode()); Assert.assertEquals(sketch.getEstimate(), 0.0); Assert.assertTrue(sketch.getUpperBound(1) > 0.0); Assert.assertEquals(sketch.getLowerBound(1), 0.0, 0.0000001); Assert.assertEquals(sketch.getThetaLong() / (double) Long.MAX_VALUE, (double) samplingProbability); Assert.assertEquals(sketch.getTheta(), (double) samplingProbability); }
@Test public void intersectionExactWithEmpty() { UpdatableSketch<Double, DoubleSummary> sketch1 = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); sketch1.update(1, 1.0); sketch1.update(2, 1.0); sketch1.update(3, 1.0); Sketch<DoubleSummary> sketch2 = Sketches.createEmptySketch(); Intersection<DoubleSummary> intersection = new Intersection<>(new DoubleSummarySetOperations(Mode.Sum)); intersection.update(sketch1); intersection.update(sketch2); CompactSketch<DoubleSummary> result = intersection.getResult(); Assert.assertEquals(result.getRetainedEntries(), 0); Assert.assertTrue(result.isEmpty()); Assert.assertEquals(result.getEstimate(), 0.0); Assert.assertEquals(result.getLowerBound(1), 0.0); Assert.assertEquals(result.getUpperBound(1), 0.0); }
@Test public void intersectionExactWithNull() { UpdatableSketch<Double, DoubleSummary> sketch1 = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); sketch1.update(1, 1.0); sketch1.update(2, 1.0); sketch1.update(3, 1.0); Intersection<DoubleSummary> intersection = new Intersection<>(new DoubleSummarySetOperations()); intersection.update(sketch1); intersection.update(null); CompactSketch<DoubleSummary> result = intersection.getResult(); Assert.assertEquals(result.getRetainedEntries(), 0); Assert.assertTrue(result.isEmpty()); Assert.assertEquals(result.getEstimate(), 0.0); Assert.assertEquals(result.getLowerBound(1), 0.0); Assert.assertEquals(result.getUpperBound(1), 0.0); }
@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 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 estimationModeWithSamplingNoResizing() { UpdatableSketch<Double, DoubleSummary> sketch = new UpdatableSketchBuilder<>( new DoubleSummaryFactory()) .setSamplingProbability(0.5f) .setResizeFactor(ResizeFactor.X1).build(); for (int i = 0; i < 16384; i++) { sketch.update(i, 1.0); } Assert.assertTrue(sketch.isEstimationMode()); Assert.assertEquals(sketch.getEstimate(), 16384, 16384 * 0.01); Assert.assertTrue(sketch.getEstimate() >= sketch.getLowerBound(1)); Assert.assertTrue(sketch.getEstimate() < sketch.getUpperBound(1)); }
@Test public void aNotBEmptyA() { UpdatableSketch<Double, DoubleSummary> sketchA = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); UpdatableSketch<Double, DoubleSummary> sketchB = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); sketchB.update(1, 1.0); sketchB.update(2, 1.0); AnotB<DoubleSummary> aNotB = new AnotB<>(); aNotB.update(sketchA, sketchB); CompactSketch<DoubleSummary> result = aNotB.getResult(); Assert.assertEquals(result.getRetainedEntries(), 0); Assert.assertTrue(result.isEmpty()); Assert.assertEquals(result.getEstimate(), 0.0); Assert.assertEquals(result.getLowerBound(1), 0.0); Assert.assertEquals(result.getUpperBound(1), 0.0); }
@Test public void nonEmptySketchWithNoEntries() { UpdatableSketch<Double, DoubleSummary> sketch = new UpdatableSketchBuilder<>( new DoubleSummaryFactory()).setSamplingProbability(0.0001f).build(); sketch.update(0, 0.0); Assert.assertFalse(sketch.isEmpty()); Assert.assertEquals(sketch.getRetainedEntries(), 0); Filter<DoubleSummary> filter = new Filter<>(o -> true); Sketch<DoubleSummary> filteredSketch = filter.filter(sketch); Assert.assertFalse(filteredSketch.isEmpty()); Assert.assertEquals(filteredSketch.getEstimate(), sketch.getEstimate()); Assert.assertEquals(filteredSketch.getThetaLong(), sketch.getThetaLong()); Assert.assertEquals(filteredSketch.getLowerBound(1), sketch.getLowerBound(1)); Assert.assertEquals(filteredSketch.getUpperBound(1), sketch.getUpperBound(1)); }
@Test public void intersectionNotEmptyNoEntries() { UpdatableSketch<Double, DoubleSummary> sketch1 = new UpdatableSketchBuilder<> (new DoubleSummaryFactory()).setSamplingProbability(0.01f).build(); sketch1.update("a", 1.0); // this happens to get rejected because of sampling with low probability Intersection<DoubleSummary> intersection = new Intersection<>(new DoubleSummarySetOperations()); intersection.update(sketch1); CompactSketch<DoubleSummary> result = intersection.getResult(); Assert.assertEquals(result.getRetainedEntries(), 0); Assert.assertFalse(result.isEmpty()); Assert.assertEquals(result.getEstimate(), 0.0); Assert.assertEquals(result.getLowerBound(1), 0.0, 0.0001); Assert.assertTrue(result.getUpperBound(1) > 0); }
@Test public void serializeDeserializeSampling() throws Exception { int sketchSize = 16384; int numberOfUniques = sketchSize; UpdatableSketch<Double, DoubleSummary> sketch1 = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()) .setNominalEntries(sketchSize).setSamplingProbability(0.5f).build(); for (int i = 0; i < numberOfUniques; i++) { sketch1.update(i, 1.0); } Sketch<DoubleSummary> sketch2 = Sketches.heapifySketch( Memory.wrap(sketch1.toByteArray()), new DoubleSummaryDeserializer()); Assert.assertTrue(sketch2.isEstimationMode()); Assert.assertEquals(sketch2.getEstimate() / numberOfUniques, 1.0, 0.01); Assert.assertEquals(sketch2.getRetainedEntries() / (double) numberOfUniques, 0.5, 0.01); Assert.assertEquals(sketch1.getTheta(), sketch2.getTheta()); }
@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(expectedExceptions = SketchesArgumentException.class) public void deserializeWrongType() { UpdatableSketch<Double, DoubleSummary> us = new UpdatableSketchBuilder<>(new DoubleSummaryFactory()).build(); for (int i = 0; i < 8192; i++) us.update(i, 1.0); CompactSketch<DoubleSummary> sketch1 = us.compact(); Sketches.heapifyUpdatableSketch(Memory.wrap(sketch1.toByteArray()), new DoubleSummaryDeserializer(), new DoubleSummaryFactory()); }
@Test public void unionEstimationMode() { 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); } Union<DoubleSummary> union = new Union<>(4096, new DoubleSummarySetOperations()); union.update(sketch1); union.update(sketch2); CompactSketch<DoubleSummary> result = union.getResult(); Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01); Assert.assertTrue(result.getLowerBound(1) <= result.getEstimate()); Assert.assertTrue(result.getUpperBound(1) > result.getEstimate()); }
@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); }