Giter VIP home page Giter VIP logo

datasketches-java's Introduction

Maven Central Language grade: Java Total alerts Coverage Status

=================

Apache® DataSketches™ Core Java Library Component

This is the core Java component of the DataSketches library. It contains all of the sketching algorithms and can be accessed directly from user applications.

This component is also a dependency of other components of the library that create adaptors for target systems, such as the Apache Pig adaptor and the Apache Hive adaptor.

Note that we have a parallel core component for C++ and Python implementations of the same sketch algorithms, datasketches-cpp.

Please visit the main DataSketches website for more information.

If you are interested in making contributions to this site please see our Community page for how to contact us.


Maven Build Instructions

NOTE: This component accesses resource files for testing. As a result, the directory elements of the full absolute path of the target installation directory must qualify as Java identifiers. In other words, the directory elements must not have any space characters (or non-Java identifier characters) in any of the path elements. This is required by the Oracle Java Specification in order to ensure location-independent access to resources: See Oracle Location-Independent Access to Resources

A JDK8 with Hotspot or JDK11 with Hotspot is required to compile

This component depends on the datasketches-memory component, and, as a result, must be compiled with one of the above JDKs. If your application only relies on the APIs of this component no special JVM arguments are required. However, if your application also directly relies on the APIs of the datasketches-memory component, you may need additional JVM arguments. Please refer to the datasketches-memory README for details.

If your application uses Maven, you can also use the pom.xml of this component as an example of how to automatically configure the JVM arguments for compilation and testing based on the version of the JDK.

Recommended Build Tool

This DataSketches component is structured as a Maven project and Maven is the recommended Build Tool.

There are two types of tests: normal unit tests and tests run by the strict profile.

To run normal unit tests:

$ mvn clean test

To run the strict profile tests (only supported in Java 8):

$ mvn clean test -P strict

To install jars built from the downloaded source:

$ mvn clean install -DskipTests=true

This will create the following jars:

  • datasketches-java-X.Y.Z.jar The compiled main class files.
  • datasketches-java-X.Y.Z-tests.jar The compiled test class files.
  • datasketches-java-X.Y.Z-sources.jar The main source files.
  • datasketches-java-X.Y.Z-test-sources.jar The test source files
  • datasketches-java-X.Y.Z-javadoc.jar The compressed Javadocs.

Dependencies

Run-time

There is one run-time dependency:

  • org.apache.datasketches : datasketches-memory

Testing

See the pom.xml file for test dependencies.

Special Build / Test Instructions for Eclipse

Building and running tests using JDK 8 should not be a problem.

However, with JDK 9+, and Eclipse versions up to and including 4.22.0 (2021-12), Eclipse fails to translate the required JPMS JVM arguments specified in the POM compiler or surefire plugins into the .classpath file, causing illegal reflection access errors eclipse-m2e/m2e-core Bug 543631.

There are two ways to fix this:

Method 1: Manually update .classpath file:

Open the .classpath file in a text editor and find the following classpathentry element (this assumes JDK11, change to suit):

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11">
		<attributes>
			<attribute name="module" value="true"/>
			<attribute name="maven.pomderived" value="true"/>
		</attributes>
	</classpathentry>

Then edit it as follows:

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11">
		<attributes>
			<attribute name="module" value="true"/>
			<attribute name="add-exports" value="java.base/jdk.internal.misc=ALL-UNNAMED:java.base/jdk.internal.ref=ALL-UNNAMED"/>
			<attribute name="add-opens" value="java.base/java.nio=ALL-UNNAMED:java.base/sun.nio.ch=ALL-UNNAMED"/>
			<attribute name="maven.pomderived" value="true"/>
		</attributes>
	</classpathentry>

Finally, refresh.

Method 2: Manually update Module Dependencies

In Eclipse, open the project Properties / Java Build Path / Module Dependencies ...

  • Select java.base
  • Select Configured details
  • Select Expose Package...
    • Enter Package = java.nio
    • Enter Target module = ALL-UNNAMED
    • Select button: opens
    • Hit OK
  • Select Expose Package...
    • Enter Package = jdk.internal.misc
    • Enter Target module = ALL-UNNAMED
    • Select button: exports
    • Hit OK
  • Select Expose Package...
    • Enter Package = jdk.internal.ref
    • Enter Target module = ALL-UNNAMED
    • Select button: exports
    • Hit OK
  • Select Expose Package...
    • Enter Package = sun.nio.ch
    • Enter Target module = ALL-UNNAMED
    • Select button: opens
    • Hit OK

NOTE: If you execute Maven/Update Project... from Eclipse with the option Update project configuration from pom.xml checked, all of the above will be erased, and you will have to redo it.

Known Issues

SpotBugs

  • Make sure you configure SpotBugs with the /tools/FindBugsExcludeFilter.xml file. Otherwise, you may get a lot of false positive or low risk issues that we have examined and eliminated with this exclusion file.

datasketches-java's People

Contributors

alexandersaydakov avatar cheddar avatar davecromberge avatar dengliming avatar freakyzoidberg avatar gianm avatar gitter-badger avatar inigoillan avatar jgeraerts avatar jmalkin avatar justin8712 avatar leerho avatar niketh avatar p- avatar paulk-asert avatar pavelvesely avatar romseygeek avatar will-lauer avatar xcorail avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

datasketches-java's Issues

NPE when trying to grow the buffer in DoublesSketch

Hi, Druid uses the QuantilesSketch to compute approximate quantiles. To keep the approximate quantiles, Druid creates a DoublesUnion which is backed by a WriableMemory wrapping a DirectByteBuffer. Since Druid does not know how many items could be there in advance but the buffer size should be fixed, it estimates the initial size of Memory to be large enough to hold one billion items. The below code snippet shows this and can be found in https://github.com/apache/druid/blob/master/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/quantiles/DoublesSketchMergeBufferAggregatorHelper.java#L47-L53.

  public void init(final ByteBuffer buffer, final int position)
  {
    final WritableMemory mem = getMemory(buffer);
    final WritableMemory region = mem.writableRegion(position, maxIntermediateSize);
    final DoublesUnion union = DoublesUnion.builder().setMaxK(k).build(region);
    putUnion(buffer, position, union);
  }

This is causing a problem that DirectUpdateDoublesSketch throws NPE at this line when there are actually more than one billion items added in the union (reported in apache/druid#11544). DirectUpdateDoublesSketch tried to allocate extra memory to hold more items than that was initially estimated, but WritableMemory in it was BBWritableMemoryImpl (because it was created by wrapping DirectByteBuffer) which returns null in getMemoryRequestServer(). I thought that the fix could be returning a valid memoryRequestServer for BBWritableMemoryImpl, but the Javadoc of WriableMemory.getMemoryRequestServer states that this method is supposed to return null for non-direct memory. So, I was not sure what the right fix would be. What is the reason for non-direct memory to return null in getMemoryRequestServer()?

Avoid unnecessary allocations in HllSketch

MurmurHash3 does a bunch of unnecessary allocations, which means that every HllSketch update there are at least two object allocations. All these objects are very short lived and need to be garbage collected which is undesirable.

Given the other sketches code doesn't do this and we don't guarantee thread safety, this seems to be an oversight. Let me know if you'd like contributions for this fix.

https://github.com/DataSketches/sketches-core/blob/master/src/main/java/com/yahoo/sketches/hash/MurmurHash3.java#L59
https://github.com/DataSketches/sketches-core/blob/master/src/main/java/com/yahoo/sketches/hash/MurmurHash3.java#L253

ThetaSketch update hangs

Here's a minimal repro:

Union sketch = new SetOperationBuilder()
        .setNominalEntries(4096)
        .buildUnion();
for (int i = 0; i < 64; i++) {
    sketch.update(i);
}

// serialize + deserialize
sketch = Sketches.wrapUnion(WritableMemory.wrap(sketch.toByteArray()));

for (int i = 64; i < 128; i++) {
    sketch.update(i);
}

sketch.update(128); // this hangs

It seems to hang in HashOperations#fastHashSearchOrInsert

I'm guessing there is some state that isn't getting serialized?

could not access class in package 'sun.misc'

I used sketch-core in an hadoop-style enviorment with QuantileSketch and Memory class, but encountered the following problem. Because of the security policy of the platform, the librabry couldn't used. please help me!

Caused by: java.lang.RuntimeException: Unable to acquire Unsafe. 
    at com.yahoo.sketches.memory.UnsafeUtil.<clinit>(UnsafeUtil.java:105)
    ... 5 more
Caused by: java.security.AccessControlException: access denied ("java.lang.RuntimePermission" "accessClassInPackage.sun.misc")
    at java.security.AccessControlContext.checkPermission(AccessControlContext.java:472)
    at java.security.AccessController.checkPermission(AccessController.java:884)
    at java.lang.SecurityManager.checkPermission(SecurityManager.java:549)
    at com.alibaba.apsara.sandking.SandboxSecurityManager.checkPermission(SandboxSecurityManager.java:354)
    at java.lang.SecurityManager.checkPackageAccess(SecurityManager.java:1564)
    at com.alibaba.apsara.sandking.SandboxLauncher$AppClassLoader.loadClass(SandboxLauncher.java:247)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    at com.yahoo.sketches.memory.UnsafeUtil.<clinit>(UnsafeUtil.java:68)
    ... 5 more

Merge and Update a Theta Sketch

I'm trying to update a theta sketch using a spark typed imperative aggregate. In order to achieve this, I want a representation of the sketch which supports both update and union. In my brief experimentation, this doesn't seem possible (or I could be missing something).

  • com.yahoo.sketches.theta.Sketch doesn't support update or union
  • com.yahoo.sketches.theta.CompactSketch doesn't support update, but can be merged via PairwiseSetOperations#union
  • com.yahoo.sketches.theta.Union seems the most feasible; it can be updated and converted to a compact result, but ultimately it would be fairly awkward to update and merge several times.

I hope I'm just missing something simple; thanks in advance!

DoublesUnion serde issue

Stacktrace:

java.lang.AssertionError: reqOffset: 8, reqLength: 8, (reqOff + reqLen): 16, allocSize: 8
	at com.yahoo.memory.UnsafeUtil.assertBounds(UnsafeUtil.java:141)
	at com.yahoo.memory.WritableMemoryImpl.getLong(WritableMemoryImpl.java:250)
	at com.yahoo.sketches.quantiles.DoublesUnionImpl.heapifyInstance(DoublesUnionImpl.java:80)
	at com.yahoo.sketches.quantiles.DoublesUnionBuilder.heapify(DoublesUnionBuilder.java:87)

Repro:

        DoublesUnion union = DoublesUnion.builder().build();
        DoublesUnionBuilder.heapify(Memory.wrap(union.toByteArray()));

Theta sketch - Concurrent union implementation

The implementation of a concurrent theta sketch is based on two main design choices

  1. updating threads write into a local buffer which is propagated in the background to a shared sketch
  2. query threads read from a snapshot created by the shared sketch, namely they always see a consistent state of the shared sketch.
    More details can be found here https://datasketches.github.io/docs/Theta/ConcurrentThetaSketch.html

This issue discusses 3 design alternatives for implementing a concurrent union operation.

Design option I: This design works very similar to the design of concurrent theta sketch. It allows updating only the local buffers, and querying only the shared union object.

  1. ConcurrentSharedUnionImpl extends Union overrides all update methods with UnsupportedException
  2. ConcurrentHeapUnionBuffer extends Union overrides getResult and getByteArray methods with UnsupportedException
  3. Add to SetOperationBuilder 2 methods:
    -buildShared gets ConcurrentSharedThetaSketch returns ConcurrentSharedUnionImpl
    -buildLocal gets ConcurrentSharedUnionImpl returns ConcurrentHeapUnionBuffer

Design option II: This design has some pros over the first design alternative mainly simplicity, however it means the “backend” is a shared sketch, and querying the union object is done through one of the local buffers, which is only available to the updating threads. Question: is this a reasonable setting?

  1. ConcurrentHeapUnionBuffer extends Union supports all methods both updates and queries
  2. Add to SetOperationBuilder 1 method:
    -buildLocal gets ConcurrentSharedThetaSketch returns ConcurrentHeapUnionBuffer

Design option III: This design is very similar to the second option however users cannot query the local buffer. This design assumes that queries can be delegated to the ConcurrentSharedThetaSketch “backend” which is available somewhere in the system. Question: is this a reasonable setting?

  1. ConcurrentHeapUnionBuffer extends Union overrides getResult and getByteArray methods with UnsupportedException
  2. Add to SetOperationBuilder 1 method:
    -buildLocal gets ConcurrentSharedThetaSketch returns ConcurrentHeapUnionBuffer

Backward compatibility for empty sketches generated from older versions

The latest version of sketches doesn't seem to be backward compatible for empty sketches generated using older versions. For example in an union operation, using an empty sketch such as AQMDAAAazJM= generated using the older versions would throw the error:

java.lang.AssertionError: reqOffset: 8, reqLength: 8, (reqOff + reqLen): 16, allocSize: 8

    at com.yahoo.memory.UnsafeUtil.assertBounds(UnsafeUtil.java:167)
    at com.yahoo.memory.BaseState.assertValidAndBoundsForRead(BaseState.java:330)
    at com.yahoo.memory.BaseWritableMemoryImpl.getNativeOrderedLong(BaseWritableMemoryImpl.java:284)
    at com.yahoo.memory.WritableMemoryImpl.getLong(WritableMemoryImpl.java:133)
    at com.yahoo.sketches.theta.UnionImpl.update(UnionImpl.java:278)

@AlexanderSaydakov @leerho This is the same problem that I had discussed with you and I'm logging this issue for tracking purposes.

How to serialize|deserialize sketch?

Hi,
thank you for that great library, one question: how to serialize|deserialize sketch?
For example, HeapUpdateSketch has toByteArray method and I can write to file, but how to deserialize from byte array?

Result list of FrequentItems sketch empty after a while

I'm currently running the FrequentItem Sketch on the ratings only dataset:
http://jmcauley.ucsd.edu/data/amazon/links.html
I'm creating the sketch and update it with the ASIN (Product ID) from the dataset. In the beginning it works but after a while the result simply gets empty.

TopNQueryResult{resultList=[TopNQueryResultItem{item=0007444117, estimate=1180, lowerBound=753, upperBound=1180}, TopNQueryResultItem{item=0007442920, estimate=975, lowerBound=548, upperBound=975}, TopNQueryResultItem{item=0007386648, estimate=872, lowerBound=445, upperBound=872}]}
TopNQueryResult{resultList=[TopNQueryResultItem{item=0007444117, estimate=1180, lowerBound=724, upperBound=1180}, TopNQueryResultItem{item=0007442920, estimate=975, lowerBound=519, upperBound=975}]}
TopNQueryResult{resultList=[TopNQueryResultItem{item=0007444117, estimate=1180, lowerBound=677, upperBound=1180}]}
TopNQueryResult{resultList=[TopNQueryResultItem{item=0007444117, estimate=1180, lowerBound=641, upperBound=1180}]}
TopNQueryResult{resultList=[TopNQueryResultItem{item=0007444117, estimate=1180, lowerBound=603, upperBound=1180}]}
TopNQueryResult{resultList=[]}

The TopNQueryResult is just a wrapper for reboxing the results.
SketchMapSize is 64 and error type is ErrorType.NO_FALSE_POSITIVES. I assume this is due to the error type?

0.10.0 SketchesReadOnlyException

Seeing the following after upgrading to 0.10.0:

com.yahoo.sketches.SketchesReadOnlyException: Write operation attempted on a read-only class.
	at com.yahoo.sketches.theta.DirectQuickSelectSketchR.hashUpdate(DirectQuickSelectSketchR.java:288)
	at com.yahoo.sketches.theta.UnionImpl.update(UnionImpl.java:261)

Didn't see anything helpful in the Union#update(Sketch sketchIn) javadocs regarding what might be going wrong.

Interface differences

Hi,
first thanks a lot for this amazing library! Really appreciated.

I'm currently wondering about the interface of the HllSketch. Is there a design choice in using Generics in the ItemsSketch but not in the HllSketch?
Similarly, the ThetaSketch uses a Builder Pattern while others do not. Would be great to know about these design choices!

Native Memory

When I create a NativeMemory object from a byte[] with a length greater than 1024, the remaining members of the array become 0 when I attempt to operate on them. Am I missing something?

Deserialize HLLSketch

HLLSketch has a toByteArray method for serialization, but I can't figure out how to construct a HLLSketch from a byte array. Am I missing something?

Theta sketch intersection estimation value is greater than source sketch estimation value

Sample code:

import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.theta.*;

import java.nio.ByteOrder;
import java.util.Base64;

import static org.apache.datasketches.Util.DEFAULT_UPDATE_SEED;

public class ThetaSketchIntesectionApp {
    public static void main(String[] args) {
        byte[] sketch1Arr = Base64.getDecoder().decode("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");
        final Memory serializedSketch = Memory.wrap(sketch1Arr,
                                                    0,
                                                    sketch1Arr.length,
                                                    ByteOrder.nativeOrder());
        Sketch sketch1 = Sketch.wrap(serializedSketch, DEFAULT_UPDATE_SEED);

        byte[] sketch2Arr = Base64.getDecoder().decode("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");
        final Memory serializedSketch2 = Memory.wrap(sketch2Arr,
                                                    0,
                                                     sketch2Arr.length,
                                                    ByteOrder.nativeOrder());
        Sketch sketch2 = Sketch.wrap(serializedSketch2, DEFAULT_UPDATE_SEED);

        Sketch intSketch = Intersection.builder()
                    .buildIntersection()
                    .intersect(sketch1, sketch2);

        System.out.println("Sketch#1 Estimation: " + sketch1.getEstimate());
        System.out.println("Sketch#2 Estimation: " + sketch2.getEstimate());
        System.out.println("Sketch#1 and Sketch#2 Intersection Estimation: " + intSketch.getEstimate());
    }
}

Result:

Sketch#1 Estimation: 2.6420417306809786E8
Sketch#2 Estimation: 20693.591312562978
Sketch#1 and Sketch#2 Intersection Estimation: 64502.97194045358

Does Union support multi Sketch flavor updates?

I am trying to understand why the following code doesn't work as intended

Version

 <groupId>com.yahoo.datasketches</groupId>
 <artifactId>sketches-core</artifactId>
 <version>0.12.0</version>

Code

    Union set1 = Union.builder().setNominalEntries(4096).buildUnion();
    set1.update(1);
    set1.update(2);
    set1.update(3);
    set1.update(4);
    set1.update(5);
    set1.update(6);
    set1.update(6);
    set1.update(6);

    Union set2 = Union.builder().setNominalEntries(4096).buildUnion();
    set2.update(1);

    AnotB aNotB = Sketches.setOperationBuilder().setNominalEntries(4096).buildANotB();
    aNotB.update(set1.getResult(), set2.getResult());
    System.out.println(aNotB.getResult().getEstimate());

    Union finalUnion = Union.builder().setNominalEntries(4096).buildUnion();
    finalUnion.update(aNotB.getResult());
    System.out.println(finalUnion.getResult().getEstimate());

I am expecting the printout to be

5.0
5.0

but instead I get

5.0
0.0

I must be doing something trivially wrong, or does Union update only support compactSketch from Union?

Maximal estimate error

Hi, is there a formula for cpc or hll sketches to calculate max error for estimate ? I wonder what are the practices for assuring correctness(high accuracy) of execution while using sketches ?

Sketches, probablistic models for performing such operations as distinct counting looks great in both terms storage and performance, however crucial thing for me is whether there are hard boundaries for accuracy and error ?

Util.java throws InvalidPathException on Windows

The test suite fails with numerous errors on Windows:

[ERROR] Failures:
[ERROR]   UtilTest.resourceBytesCorrect:348 » InvalidPath Illegal char <:> at index 2: /...
[ERROR]   KllFloatsSketchTest.deserializeOneItemV1:355 » InvalidPath Illegal char <:> at...
[ERROR]   ForwardCompatibilityTest.check030_1000:49->getAndCheck:121 » InvalidPath Illeg...
[ERROR]   ForwardCompatibilityTest.check030_50:39->getAndCheck:121 » InvalidPath Illegal...
[ERROR]   ForwardCompatibilityTest.check060_1000:69->getAndCheck:121 » InvalidPath Illeg...
[ERROR]   ForwardCompatibilityTest.check060_50:59->getAndCheck:121 » InvalidPath Illegal...
[ERROR]   ForwardCompatibilityTest.check080_1000:89->getAndCheck:121 » InvalidPath Illeg...
[ERROR]   ForwardCompatibilityTest.check080_50:79->getAndCheck:121 » InvalidPath Illegal...
[ERROR]   ForwardCompatibilityTest.check083_1000:109->getAndCheck:121 » InvalidPath Ille...
[ERROR]   ForwardCompatibilityTest.check083_50:99->getAndCheck:121 » InvalidPath Illegal...
[ERROR]   ArrayOfDoublesUnionTest.noSupportHeapifyV0_9_1 » Test
Expected exception of t...
[ERROR]   ArrayOfDoublesUnionTest.noSupportWrapV0_9_1 » Test
Expected exception of type...
[ERROR]   CompactSketchWithDoubleSummaryTest.serialVersion1Compatibility:192 » InvalidPath
[INFO]
[ERROR] Tests run: 1387, Failures: 13, Errors: 0, Skipped: 0

The stacktrace of one of the errors is shown below:

[ERROR] serialVersion1Compatibility(org.apache.datasketches.tuple.CompactSketchWithDoubleSummaryTest)  Time elapsed: 0.002 s  <<< FAILURE!
java.nio.file.InvalidPathException: Illegal char <:> at index 2: /D:/projects/incubator-datasketches-java/target/test-classes/CompactSketchWithDoubleSummary4K_serialVersion1.bin
        at sun.nio.fs.WindowsPathParser.normalize(WindowsPathParser.java:182)
        at sun.nio.fs.WindowsPathParser.parse(WindowsPathParser.java:153)
        at sun.nio.fs.WindowsPathParser.parse(WindowsPathParser.java:77)
        at sun.nio.fs.WindowsPath.parse(WindowsPath.java:94)
        at sun.nio.fs.WindowsFileSystem.getPath(WindowsFileSystem.java:255)
        at java.nio.file.Paths.get(Paths.java:84)
        at org.apache.datasketches.Util.getResourceBytes(Util.java:761)
        at org.apache.datasketches.tuple.CompactSketchWithDoubleSummaryTest.serialVersion1Compatibility(CompactSketchWithDoubleSummaryTest.java:192)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.lang.reflect.Method.invoke(Method.java:498)
        at org.testng.internal.MethodInvocationHelper.invokeMethod(MethodInvocationHelper.java:124)
        at org.testng.internal.Invoker.invokeMethod(Invoker.java:583)
        at org.testng.internal.Invoker.invokeTestMethod(Invoker.java:719)
        at org.testng.internal.Invoker.invokeTestMethods(Invoker.java:989)
        at org.testng.internal.TestMethodWorker.invokeTestMethods(TestMethodWorker.java:125)
        at org.testng.internal.TestMethodWorker.run(TestMethodWorker.java:109)
        at org.testng.TestRunner.privateRun(TestRunner.java:648)
        at org.testng.TestRunner.run(TestRunner.java:505)
        at org.testng.SuiteRunner.runTest(SuiteRunner.java:455)
        at org.testng.SuiteRunner.runSequentially(SuiteRunner.java:450)
        at org.testng.SuiteRunner.privateRun(SuiteRunner.java:415)
        at org.testng.SuiteRunner.run(SuiteRunner.java:364)
        at org.testng.SuiteRunnerWorker.runSuite(SuiteRunnerWorker.java:52)
        at org.testng.SuiteRunnerWorker.run(SuiteRunnerWorker.java:84)
        at org.testng.TestNG.runSuitesSequentially(TestNG.java:1208)
        at org.testng.TestNG.runSuitesLocally(TestNG.java:1137)
        at org.testng.TestNG.runSuites(TestNG.java:1049)
        at org.testng.TestNG.run(TestNG.java:1017)
        at org.apache.maven.surefire.testng.TestNGExecutor.run(TestNGExecutor.java:135)
        at org.apache.maven.surefire.testng.TestNGDirectoryTestSuite.executeMulti(TestNGDirectoryTestSuite.java:193)
        at org.apache.maven.surefire.testng.TestNGDirectoryTestSuite.execute(TestNGDirectoryTestSuite.java:94)
        at org.apache.maven.surefire.testng.TestNGProvider.invoke(TestNGProvider.java:146)
        at org.apache.maven.surefire.booter.ForkedBooter.invokeProviderInSameClassLoader(ForkedBooter.java:384)
        at org.apache.maven.surefire.booter.ForkedBooter.runSuitesInProcess(ForkedBooter.java:345)
        at org.apache.maven.surefire.booter.ForkedBooter.execute(ForkedBooter.java:126)
        at org.apache.maven.surefire.booter.ForkedBooter.main(ForkedBooter.java:418)

Alternative to reservoir sketches

I recently did a review of the literature and some experiments with reservoir sampling, and found there are lower overhead sampling algorithms equivalent to the implementation of "algorithm R" in this library. I would like to contribute the best performing implementation to the library.

I have a few questions

  • does this library need another reservoir sketch and is it likely to accept one? That is, is preparing a patch a worthwhile use of my time?
  • Is my testing strategy agreeable? If not, what kind of tests would I need to provide? My strategy is:
    • generate input data from a known parametric distribution
    • sort the data to introduce sequential bias which must not be evident in the sample
    • take a sample
    • evaluate the maximum likelihood estimator over the sample to check I recover the distribution parameters within some tolerance.
  • is it better to replace or to complement ReservoirLongsSketch/ReservoirItemsSketch?

getPMF of UpdateDoublesSketch is giving different results for same data

I am using tuple sketch to get the distribution of data by using Probability Histogram of values, For larger datasets I am getting different distribution for same data.

I am doing something like this:

ArrayOfDoublesSketch unionSketch = getUnionOfSketches(List list);

ArrayOfDoublesSketch result = unionSketch.getResult() ;
UpdateDoublesSketch quantilesSketch = DoublesSketch.builder().build();
ArrayOfDoublesSketchIterator itr =result.iterator();
while (itr.next()) {
quantilesSketch.update(itr.getValues()[0]);
}
double [] fr = quantilesSketch.getPMF(new double[] {1.0, 2.0, 3.0, 4.0, 5.0,6.0,7.0,8.0});

public static ArrayOfDoublesUnion getUnionOfSketches(List arrayOfDoublesSketches ){
ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion();
for(ArrayOfDoublesSketch arrayOfDoublesSketch: arrayOfDoublesSketches){
union.update(arrayOfDoublesSketch);
}
return union;
}

In fr[] I am getting different values for same data on multiple runs. Basically the values are oscillating between 2-3 values.

Question related to union performance

Hi, I just wanted to ask whether CpcSketch is fastest Sketch for performing union ? And whether is there other way to speed up unions than decreasing logK param ?

`

static class UnionPerfTest {
    public static void main(String[] args) {

        int logK = 11;
        Random r = new Random();

        CpcSketch fllcpc = new CpcSketch(logK);
        IntStream.generate(() -> r.nextInt(10_000_000)).distinct().limit(100_000).forEach(fllcpc::update);

        CpcSketch sllcpc = new CpcSketch(logK);
        IntStream.generate(() -> r.nextInt(10_000_000)).distinct().limit(1_000_000).forEach(sllcpc::update);

        long blackHole = 0;
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1_000_000; i++) {
            CpcUnion cpcUnion = new CpcUnion(logK);

            cpcUnion.update(sllcpc);
            cpcUnion.update(fllcpc);

            blackHole += cpcUnion.getResult().getEstimate();
        }

        System.out.println("Millis: " + (System.currentTimeMillis() - start));
        System.out.println("bc: " + blackHole);
    }
}

`

NullPointer exception when resize factor != X1

Hi, I'm running data sketches on spark using scala serialisation wrapper like this.

@throws(classOf[IOException])
  private def writeObject(out: ObjectOutputStream): Unit = synchronized {
    out.writeObject(union.toByteArray)
  }

  @throws(classOf[IOException])
  private def readObject(in: ObjectInputStream): Unit = synchronized {
    val bytes = in.readObject().asInstanceOf[Array[Byte]]
    Sketches.wrapUnion(new NativeMemory(bytes))
  }

But when my sketches don't have ResizeFactor.X1 property set I get a null pointer error:

Caused by: java.lang.NullPointerException
  at com.yahoo.sketches.theta.DirectQuickSelectSketch.hashUpdate(DirectQuickSelectSketch.java:404)
  at com.yahoo.sketches.theta.UpdateSketch.update(UpdateSketch.java:169)
  at com.yahoo.sketches.theta.UnionImpl.update(UnionImpl.java:269)
  at com.myproject.spark.SerUnion.update(SerUnion.scala:32)
  at $anonfun$createDataSketches$2.apply(<console>:73)
  at $anonfun$createDataSketches$2.apply(<console>:73)
  at org.apache.spark.util.collection.ExternalSorter$$anonfun$5.apply(ExternalSorter.scala:190)
  at org.apache.spark.util.collection.ExternalSorter$$anonfun$5.apply(ExternalSorter.scala:189)
  at org.apache.spark.util.collection.AppendOnlyMap.changeValue(AppendOnlyMap.scala:144)
  at org.apache.spark.util.collection.SizeTrackingAppendOnlyMap.changeValue(SizeTrackingAppendOnlyMap.scala:32)
  at org.apache.spark.util.collection.ExternalSorter.insertAll(ExternalSorter.scala:195)
  at org.apache.spark.shuffle.sort.SortShuffleWriter.write(SortShuffleWriter.scala:63)
  at org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:79)
  at org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:47)
  at org.apache.spark.scheduler.Task.run(Task.scala:86)
  at org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:274)
  at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
  at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
  at java.lang.Thread.run(Thread.java:745)

I'm using version 0.8.3 for the following modules.

 'com.yahoo.datasketches:sketches:0.8.3'
 'com.yahoo.datasketches:memory:0.8.3'
 'com.yahoo.datasketches:sketches-core:0.8.3'

Quantile error bounds

Is it possible to get upper/lower bounds for quantile results? E.g. I'd like to know that the median is 5.0 +/- 0.05 with 95% confidence.

There seem to be comments that mention that the normalized rank error can't directly be applied to determine these bounds, but surely there must be some way to bound the error here?

Naming Conventions ItemSketch

Small nit. Since we (Splice Machine) are using both frequencies and quantiles, it would be nice if they were not named the same (ItemSketch)...

Update sketches will have large error rate in some cases.

All of update sketch don't deal with duplicate datas.
So in such situation:

val sketch1 = UpdateSketch()
sketch1.update(1)
sketch1.update(1)
sketch2.update(xxx)
val sketch2 = UpdateSketch()
sketch2.update(1)
sketch2.update(xxx)
anotb.update(sketch1, sketch2)
anotb.getResult()

Int this cases, because the number 1 add two times and only remove once, so it should counts in the final result.
But actually it will not. It will cause very large error rate in small data.

PairwiseSetOperations.aNotB throws ArrayOutOfBoundsException

Reproduced with:

        UpdateSketch one = new UpdateSketchBuilder().setNominalEntries(4096).build();
        UpdateSketch two = new UpdateSketchBuilder().setNominalEntries(4096).build();
        UpdateSketch three = new UpdateSketchBuilder().setNominalEntries(4096).build();
        for (int i = 0; i < 1_000_000; i++) {
            one.update(i);
            two.update(1_000_000 + i);
            three.update(2_000_000 + i);
        }
        PairwiseSetOperations.aNotB(PairwiseSetOperations.intersect(one.compact(), two.compact()), three.compact());

The bug itself doesn't seem to be in the implementation of aNotB, but rather that CompactSketch.isEmpty() (which aNotB checks) is deceiving, and may return false despite the internal array being length 0. When aNotB checks to see if the sketch is empty, it sees it is not, and then proceeds to attempt the set difference which fails to the zero length array. If you attempt the same thing, but replace one.compact() with a newly constructed empty sketch, aNotB works as expected.

ArrayIndexOutOfBoundsException during serialization

Seeing this sporadically for FrequentItems:

java.lang.ArrayIndexOutOfBoundsException: 13
	at com.yahoo.sketches.frequencies.ReversePurgeItemHashMap.getActiveValues(ReversePurgeItemHashMap.java:180)
	at com.yahoo.sketches.frequencies.ItemsSketch.toByteArray(ItemsSketch.java:316)

as well as Quantiles:

java.lang.ArrayIndexOutOfBoundsException: null
	at java.lang.System.arraycopy(Native Method)
	at com.yahoo.sketches.quantiles.ItemsByteArrayImpl.combinedBufferToItemsArray(ItemsByteArrayImpl.java:104)
	at com.yahoo.sketches.quantiles.ItemsByteArrayImpl.toByteArray(ItemsByteArrayImpl.java:55)
	at com.yahoo.sketches.quantiles.ItemsSketch.toByteArray(ItemsSketch.java:471)
	at com.yahoo.sketches.quantiles.ItemsSketch.toByteArray(ItemsSketch.java:461)

Has anyone seen this before? Might it be related to memory corruption as we suspected in #175?

Does the Kappa parameter for KLL determine the number of retained elements?

AFAIK KLL uses a cascade of compactors to produce its interval estimates.

What I'm wondering is what exactly is the effect of the K parameter. Does setting K to a specific value mean that overall, that many values will be retained between all the compactors?

Or does K indicate some other aspect of the sketch? In that case, is it actually possible to determine how many values are being retained in the compactors?

CompactSketch ArrayIndexOutOfBoundsException

Hi, we are using Theta Sketches java library to calculate reach metrics. Based on the Java Example from the Data Sketch website, we are using Union to join multiple sketches and then get the CompactSketch in binary format.

However, we do observe issues when we get CompactSketch from Union as the following stacktrace:

Caused by: java.lang.ArrayIndexOutOfBoundsException: Index 137 out of bounds for length 137 
at org.apache.datasketches.theta.CompactSketch.compactCache(CompactSketch.java:97) 
at org.apache.datasketches.theta.UnionImpl.getResult(UnionImpl.java:238) 
at org.apache.datasketches.theta.UnionImpl.getResult(UnionImpl.java:212) 

Can you guys let us know under what case this would happen and what's the root cause?

Thanks,
Bill

DirectDoublesSketch has error (maybe in propagate-carry?)

Running the following code (yes, allocating way more memory than needed):

final int k = 16;
final int n = k * 2 + 7;
final ByteBuffer bb = ByteBuffer.allocateDirect(100 + n << 3);
final Memory mem = AllocMemory.wrap(bb);

final DoublesSketchBuilder dsb = DoublesSketch.builder();
dsb.initMemory(mem);
final DoublesSketch ds = dsb.build(k);

for (int i = 0; i < n; ++i) {
  ds.update(i);
}

System.out.println(ds.toString(true, true));

The base buffer seems ok, but data In the first level has unexpected 0.0s. If I use n = k * 4 + m, I was getting 0.0 values in the middle of the level.

Quantiles DirectDoublesSketch DATA DETAIL:

 BaseBuffer   :       32.0      33.0      34.0      35.0      36.0      37.0      38.0
 Valid | Level
   T       0:        0.0       0.0       0.0       2.0       4.0       6.0       8.0      10.0      12.0      14.0      16.0      18.0      20.0      22.0      24.0      26.0
### END DATA DETAIL

Quantiles Sketch Density

If you have a quantiles sketch for a bounded set of data, how would you provide an estimate for data out of those bounds?

For example,

Known values:

int[] values = new int[]{1,2,3,4,5,6,7,8,9,10};

Estimate Between
[12,15]

Can I get the average density from the known values and then apply that to the unknown values?

Thanks
John

Duplicate detection

Hey folks,

Was wondering if you had any thoughts on approximate duplicate detection algorithms. One could conceivably use an HLL (compare cardinality to total stream length), but I don't think the confidence interval there will be satisfyingly tight.

Found this paper which seems potentially interesting: http://www.vldb.org/pvldb/vol6/p589-dutta.pdf

In general, have you had any requests for supporting approximate membership queries?

EDIT: let me know if this isn't the proper channel for discussions like these

Testing equality of HllSketch

The following code snippet fails:

        Union hll1 = new Union(12);
        Stream.of("1", "2", "3", "4", "5", "6", "7", "8", "9").forEach(hll1::update);

        Union hll2 = Union.heapify(Memory.wrap(hll1.toCompactByteArray()));

        if (!Arrays.equals(hll1.toCompactByteArray(), hll2.toCompactByteArray())) {
            throw new AssertionError("Hlls not equal");
        }

(using com.yahoo.sketches.hll.Union)

Is this a bug in hll serde?

Track Purge count in ReversePurgeItemHashMap

I want to add a purgeCount field to the the ReversePurgeItemHashMap.
I also want to expose this in the ItemsSketch object

My use case is this: I want to be able to tell if my Stream is an enum (i.e. contains < k distinct values). This can be achieved by creating a ItemsSketch with capacity k, and then seeing if the map is ever purged.

I am happy to implement this; what do you guys think?

tuple.QuickSelectSketch throws NullPointerException

I'm running into this NullPointerException error when getting results for a tuple.Union:

java.lang.NullPointerException
at com.yahoo.sketches.tuple.QuickSelectSketch.rebuild(QuickSelectSketch.java:434)
at com.yahoo.sketches.tuple.QuickSelectSketch.rebuild(QuickSelectSketch.java:409)
at com.yahoo.sketches.tuple.Union.getResult(Union.java:65)

After reading the source code for tuple.QuickSelectSketch, this seems to be linked to a null "summaries_" array.

I'm having difficulty diagnosing the problem because it doesn't seem to affect every getResult operation, only a few of them. The only similarity I can see is that the failing Unions have a single tuple.CompactSketch with 0 retained entries and a theta less than 1.0--though some Unions with a tuple.CompactSketch with 0 retained entries and a theta less than 1.0 don't fail.

The code is something like:

val union = new Union(k, summarySetOperations)
union.update(sketch)
union.getResult

Range Selectivity

My reading of the quantiles sketch api is that it includes the values provided as the bounds.

int[] foo = new int[] {1,2,3,4,5,6,7,8,9,10};

so the getCDF can handle easily [2,5].

Is there a clear way to handle (2,5)?

Would I need to increment in the outer code (transform (2,5) to [3,4]?

Need flexible ArrayOfByte tuple sketch with creation option from theta sketch

I'm building an Druid aggregator to do distinct counting with a frequency estimate (how many unique values that occurred a minimum number of times). To build this, I want to use an efficient tuple sketch implementation. Druid has an aggregator that uses the ArrayOfDouble tuple sketch, but I really want to do integral counting, so a LongTuple sketch would be ideal, but an ArrayOfByte tuple sketch would probably allow me the most flexibility, allowing me to treat the bytes as an int, long, or any other value that I want.

For this to work, I would need to control how the tuple value to computed in both union and intersection collision cases. ArrayOfDouble assumes double sum when a union occurs, but allows an ArrayOfDoubleSketchCombiner instance to be used to compute the result in an intersection case. I would want the Combiner to be used for both Union, Intersection, and Difference (separate methods for each).

The other feature I need is the ability to create one of these new sketches from a theta sketch, providing a default value for the tuple. Its not hard to do this, but it requires access to some internals of the theta sketch. If the new tuple sketch lived in the same package as the theta sketch, it could access these. If not, some part of the protections in theta sketch would need to be loosened. In order to properly construct a tuple sketch from a theta sketch, it looks like I need access to Sketch.getCache(), SKetch.getThetaLong(), and Sketch.getSeedHash().

FrequentItems IllegalArgumentException

Still working on the repo, but we recently saw this in our logs:

java.lang.IllegalArgumentException: reqOffset: 4, reqLength: , (reqOff + reqLen): 1413567575, allocSize: 480
  at com.yahoo.memory.UnsafeUtil.checkBounds(UnsafeUtil.java:156)
  at com.yahoo.sketches.ArrayOfStringsSerDe.deserializeFromMemory(ArrayOfStringsSerDe.java:54)
  at com.yahoo.sketches.ArrayOfStringsSerDe.deserializeFromMemory(ArrayOfStringsSerDe.java:23)
  at com.yahoo.sketches.frequencies.ItemsSketch.getInstance(ItemsSketch.java:263)

Posting here in case someone might know just from the message what might be going wrong.

cpc/hll - hardcoded hash function

I noticed that both CpcSketch and HllSketch use MurmurHash3 hashing, and it's hardcoded. In some cases, inputs may have been hashed already for other purposes, or a faster hash function may be preferred. It would be nice if there's a way to specify the hash function(constructor/setter/builder etc.), and let MurmurHash3 be the default.

Python Bindings for HLL Sketch

As per the discussion in this thread in the google group - https://groups.google.com/d/msg/sketches-user/8TaAXaT_6qo/A2JJkIuZBQAJ

there is traction for having a python binding for the different sketch families in sketches-core, similar to how the library has for pig and hive. I was thinking we could get started on the python adaptors by having a wrapper library for the hyperloglog sketches. Would that be a good place to start?

For Pig and Hive the bindings were defined as UDFs that pig and hive scripts can use. How will we define the wrapper classes in python? Will it be something on the lines of Jython - http://www.jython.org/jythonbook/en/1.0/JythonAndJavaIntegration.html

NULL handling in Quantiles sketch

If the input data contains NULL values, Quantiles is throwing NP exception.

$ cat data.json
{"value": 1, "category": "a"}
{"value": 2, "category": "a"}
{"value": null, "category": "a"}

$ cat test.pig
register memory-0.11.0.jar;
register sketches-core-0.11.1.jar;
register sketches-pig-0.11.0.jar;

define dataToSketch com.yahoo.sketches.pig.quantiles.DataToDoublesSketch();
--a = load 'data.txt' as (value:double, category);
a = load 'data.json' Using JsonLoader('value:double, category: chararray');
b = group a by category;
c = foreach b generate flatten(group) as (category), flatten(dataToSketch(a.value)) as sketch;
dump c;

$ pig -x local test.pig 

...
2019-02-05 19:38:49,748 [Thread-24] WARN  org.apache.hadoop.mapred.LocalJobRunner - job_local_0001
org.apache.pig.backend.executionengine.ExecException: ERROR 0: Exception while executing (Name: b: Local Rearrange[tuple]{chararray}(false) - scope-37 Operator Key: scope-37): org.apache.pig.backend.executionengine.ExecException: ERROR 0: Exception while executing [POUserFunc (Name: POUserFunc(com.yahoo.sketches.pig.quantiles.DataToDoublesSketch$IntermediateFinal)[tuple] - scope-28 Operator Key: scope-28) children: null at []]: java.lang.NullPointerException
	at org.apache.pig.backend.hadoop.executionengine.physicalLayer.PhysicalOperator.processInput(PhysicalOperator.java:314)
	at org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators.POLocalRearrange.getNextTuple(POLocalRearrange.java:287)
	at org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.PigCombiner$Combine.processOnePackageOutput(PigCombiner.java:198)
	at org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.PigCombiner$Combine.reduce(PigCombiner.java:176)
	at org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.PigCombiner$Combine.reduce(PigCombiner.java:52)
	at org.apache.hadoop.mapreduce.Reducer.run(Reducer.java:176)
	at org.apache.hadoop.mapred.Task$NewCombinerRunner.combine(Task.java:1502)
	at org.apache.hadoop.mapred.MapTask$MapOutputBuffer.sortAndSpill(MapTask.java:1436)
	at org.apache.hadoop.mapred.MapTask$MapOutputBuffer.flush(MapTask.java:1298)
	at org.apache.hadoop.mapred.MapTask$NewOutputCollector.close(MapTask.java:699)
	at org.apache.hadoop.mapred.MapTask.runNewMapper(MapTask.java:766)
	at org.apache.hadoop.mapred.MapTask.run(MapTask.java:370)
	at org.apache.hadoop.mapred.LocalJobRunner$Job.run(LocalJobRunner.java:212)
Caused by: org.apache.pig.backend.executionengine.ExecException: ERROR 0: Exception while executing [POUserFunc (Name: POUserFunc(com.yahoo.sketches.pig.quantiles.DataToDoublesSketch$IntermediateFinal)[tuple] - scope-28 Operator Key: scope-28) children: null at []]: java.lang.NullPointerException
	at org.apache.pig.backend.hadoop.executionengine.physicalLayer.PhysicalOperator.getNext(PhysicalOperator.java:364)
	at org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators.POForEach.processPlan(POForEach.java:404)
	at org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators.POForEach.getNextTuple(POForEach.java:321)
	at org.apache.pig.backend.hadoop.executionengine.physicalLayer.PhysicalOperator.processInput(PhysicalOperator.java:305)
	... 12 more
Caused by: java.lang.NullPointerException
	at com.yahoo.sketches.pig.quantiles.DataToDoublesSketch$IntermediateFinal.exec(DataToDoublesSketch.java:320)
	at com.yahoo.sketches.pig.quantiles.DataToDoublesSketch$IntermediateFinal.exec(DataToDoublesSketch.java:269)
	at org.apache.pig.backend.hadoop.executionengine.physicalLayer.expressionOperators.POUserFunc.getNext(POUserFunc.java:326)
	at org.apache.pig.backend.hadoop.executionengine.physicalLayer.expressionOperators.POUserFunc.getNextTuple(POUserFunc.java:365)
	at org.apache.pig.backend.hadoop.executionengine.physicalLayer.PhysicalOperator.getNext(PhysicalOperator.java:359)
	... 15 more
Input(s):
Failed to read data from "data.json"

Output(s):
Failed to produce result in "file:/tmp/temp-120668530/tmp-2117801155"

Counting Nulls

I am currently using Theta, Quantile, and Frequent Sketches to plugin to a RDBMS statistics structure. It was not clear to me if there is an existing place to count nulls or is that something I should implement separately.

Set Operations should support implied hash seeds

Currently, all the set operations enforce that incoming sketches have a specified hash seed. If no hash seed is specified, the default hash seed is implied. As an option, these operations should be able to infer the hash seed from the first sketch seen, allowing the operations to be used with non-standard seeds without having to specify the seed (a secret) up front. This has the effect of moving a possible error (mismatched seeds) later in the processing and possibly hiding the error all together if only a single sketch is seen, but has the advantage that users of the set operations don't have to know what their seeds are.

Comparison between DataSketches, DDSketch, t-digests et al.

I see DataSketches and DDSketch both offer a floating-point quantile-based sketch based on Agarwal et al.'s Mergeable summaries. I also noticed that DataSketches maintains an extensive test suite for benchmarking purposes. It would be nice to see a performance comparison between these two mergeable quantile sketching implementations, as their interfaces (at least at first glance) appear to be quite similar. Or are there any significant differences I might have overlooked? Thank you!

cc: @CharlesMasson @richardstartin

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.