You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datasketches.apache.org by le...@apache.org on 2021/02/08 00:42:31 UTC
[datasketches-java] 01/01: Made parallel APIs for SetOperations in
Theta, and Tuple (generics).
This is an automated email from the ASF dual-hosted git repository.
leerho pushed a commit to branch Prep_for_2.0.0-RC3
in repository https://gitbox.apache.org/repos/asf/datasketches-java.git
commit 54432598d05123f286eef6f30e4083102c123a79
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Sun Feb 7 16:40:24 2021 -0800
Made parallel APIs for SetOperations in Theta, and Tuple (generics).
---
.../java/org/apache/datasketches/BinarySearch.java | 6 +-
.../datasketches/GenericInequalitySearch.java | 5 -
.../apache/datasketches/theta/Intersection.java | 4 +-
.../java/org/apache/datasketches/theta/Union.java | 19 +-
.../org/apache/datasketches/theta/UnionImpl.java | 13 +-
.../apache/datasketches/tuple/Intersection.java | 117 +++++++--
.../java/org/apache/datasketches/tuple/Union.java | 119 +++++++--
.../tuple/adouble/DoubleSummarySetOperations.java | 21 +-
.../arrayofdoubles/ArrayOfDoublesIntersection.java | 35 ++-
.../tuple/arrayofdoubles/ArrayOfDoublesUnion.java | 36 ++-
.../arrayofdoubles/DirectArrayOfDoublesUnionR.java | 2 +-
.../org/apache/datasketches/BinarySearchTest.java | 210 +++++++++++++--
.../datasketches/tuple/ReadOnlyMemoryTest.java | 53 ++--
.../datasketches/tuple/TupleExamples2Test.java | 288 +++++++++++++++++++++
.../datasketches/tuple/TupleExamplesTest.java | 110 +++++++-
.../tuple/adouble/AdoubleIntersectionTest.java | 126 ++++-----
.../tuple/adouble/AdoubleUnionTest.java | 56 ++--
.../tuple/aninteger/EngagementTest.java | 76 +++---
.../tuple/aninteger/IntegerSketchTest.java | 92 +++----
.../ArrayOfDoublesIntersectionTest.java | 138 +++++-----
.../arrayofdoubles/ArrayOfDoublesUnionTest.java | 196 +++++++-------
21 files changed, 1231 insertions(+), 491 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/BinarySearch.java b/src/main/java/org/apache/datasketches/BinarySearch.java
index fc5db16..b6901fe 100644
--- a/src/main/java/org/apache/datasketches/BinarySearch.java
+++ b/src/main/java/org/apache/datasketches/BinarySearch.java
@@ -30,7 +30,7 @@ public final class BinarySearch {
/**
* Binary Search for the index of the exact float value in the given search range.
* If -1 is returned there are no values in the search range that equals the given value.
- * @param arr The given array to search.
+ * @param arr The given ordered array to search.
* @param low the index of the lowest value of the search range
* @param high the index of the highest value of the search range
* @param v the value to search for
@@ -53,7 +53,7 @@ public final class BinarySearch {
/**
* Binary Search for the index of the exact double value in the given search range.
* If -1 is returned there are no values in the search range that equals the given value.
- * @param arr The given array to search.
+ * @param arr The given ordered array to search.
* @param low the index of the lowest value of the search range
* @param high the index of the highest value of the search range
* @param v the value to search for
@@ -76,7 +76,7 @@ public final class BinarySearch {
/**
* Binary Search for the index of the exact long value in the given search range.
* If -1 is returned there are no values in the search range that equals the given value.
- * @param arr The given array to search.
+ * @param arr The given ordered array to search.
* @param low the index of the lowest value of the search range
* @param high the index of the highest value of the search range
* @param v the value to search for
diff --git a/src/main/java/org/apache/datasketches/GenericInequalitySearch.java b/src/main/java/org/apache/datasketches/GenericInequalitySearch.java
index 2903b77..d886003 100644
--- a/src/main/java/org/apache/datasketches/GenericInequalitySearch.java
+++ b/src/main/java/org/apache/datasketches/GenericInequalitySearch.java
@@ -95,11 +95,6 @@ public class GenericInequalitySearch {
}
/**
- * Constructs this class
- */
- public GenericInequalitySearch() { }
-
- /**
* Binary Search for the index of the generic value in the given search range that satisfies
* the given inequality.
* If -1 is returned there are no values in the search range that satisfy the inequality.
diff --git a/src/main/java/org/apache/datasketches/theta/Intersection.java b/src/main/java/org/apache/datasketches/theta/Intersection.java
index b9dc47e..9ebcad1 100644
--- a/src/main/java/org/apache/datasketches/theta/Intersection.java
+++ b/src/main/java/org/apache/datasketches/theta/Intersection.java
@@ -86,8 +86,8 @@ public abstract class Intersection extends SetOperation {
public abstract CompactSketch getResult(boolean dstOrdered, WritableMemory dstMem);
/**
- * Returns true if there is an intersection result available
- * @return true if there is an intersection result available
+ * Returns true if there is a valid intersection result available
+ * @return true if there is a valid intersection result available
*/
public abstract boolean hasResult();
diff --git a/src/main/java/org/apache/datasketches/theta/Union.java b/src/main/java/org/apache/datasketches/theta/Union.java
index 1e9ea7a..1229927 100644
--- a/src/main/java/org/apache/datasketches/theta/Union.java
+++ b/src/main/java/org/apache/datasketches/theta/Union.java
@@ -24,7 +24,8 @@ import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableMemory;
/**
- * The API for Union operations
+ * Compute the union of two or more theta sketches.
+ * A new instance represents an empty set.
*
* @author Lee Rhodes
*/
@@ -59,7 +60,7 @@ public abstract class Union extends SetOperation {
public abstract CompactSketch getResult(boolean dstOrdered, WritableMemory dstMem);
/**
- * Resets this Union. The seed remains intact, otherwise reverts back to its virgin state.
+ * Resets this Union. The seed remains intact, everything else reverts back to its virgin state.
*/
public abstract void reset();
@@ -71,7 +72,7 @@ public abstract class Union extends SetOperation {
/**
* This implements a stateless, pair-wise union operation. The returned sketch will be cutback to
- * k if required, similar to the regular Union operation.
+ * the smaller of the two k values if required.
*
* <p>Nulls and empty sketches are ignored.</p>
*
@@ -104,7 +105,8 @@ public abstract class Union extends SetOperation {
* This method is not valid for the older SetSketch, which was prior to Open Source (August, 2015).
*
* <p>This method can be repeatedly called.
- * If the given sketch is null it is interpreted as an empty sketch.</p>
+ *
+ * <p>Nulls and empty sketches are ignored.</p>
*
* @param sketchIn The incoming sketch.
*/
@@ -116,7 +118,8 @@ public abstract class Union extends SetOperation {
* This method is not valid for the older SetSketch, which was prior to Open Source (August, 2015).
*
* <p>This method can be repeatedly called.
- * If the given sketch is null it is interpreted as an empty sketch.</p>
+ *
+ * <p>Nulls and empty sketches are ignored.</p>
*
* @param sketchIn The incoming sketch.
* @deprecated 2.0.0. Use {@link #union(Sketch)} instead.
@@ -130,7 +133,8 @@ public abstract class Union extends SetOperation {
* called the SetSketch (circa 2012), which was prior to Open Source and are compact and ordered.
*
* <p>This method can be repeatedly called.
- * If the given sketch is null it is interpreted as an empty sketch.</p>
+ *
+ * <p>Nulls and empty sketches are ignored.</p>
*
* @param mem Memory image of sketch to be merged
*/
@@ -142,7 +146,8 @@ public abstract class Union extends SetOperation {
* called the SetSketch (circa 2012), which was prior to Open Source and are compact and ordered.
*
* <p>This method can be repeatedly called.
- * If the given sketch is null it is interpreted as an empty sketch.</p>
+ *
+ * <p>Nulls and empty sketches are ignored.</p>
*
* @param mem Memory image of sketch to be merged
* @deprecated 2.0.0. Use {@link #union(Memory)} instead.
diff --git a/src/main/java/org/apache/datasketches/theta/UnionImpl.java b/src/main/java/org/apache/datasketches/theta/UnionImpl.java
index 700ee71..591d1ca 100644
--- a/src/main/java/org/apache/datasketches/theta/UnionImpl.java
+++ b/src/main/java/org/apache/datasketches/theta/UnionImpl.java
@@ -272,9 +272,12 @@ final class UnionImpl extends Union {
@Override
public CompactSketch union(final Sketch sketchA, final Sketch sketchB, final boolean dstOrdered,
final WritableMemory dstMem) {
- update(sketchA);
- update(sketchB);
- return getResult(dstOrdered, dstMem);
+ reset();
+ union(sketchA);
+ union(sketchB);
+ final CompactSketch csk = getResult(dstOrdered, dstMem);
+ reset();
+ return csk;
}
@Deprecated
@@ -369,13 +372,13 @@ final class UnionImpl extends Union {
if (serVer == 2) { //older Sketch, which is compact and ordered
Util.checkSeedHashes(seedHash_, (short)extractSeedHash(skMem));
final CompactSketch csk = ForwardCompatibility.heapify2to3(skMem, DEFAULT_UPDATE_SEED);
- update(csk);
+ union(csk);
return;
}
if (serVer == 1) { //much older Sketch, which is compact and ordered
final CompactSketch csk = ForwardCompatibility.heapify1to3(skMem, DEFAULT_UPDATE_SEED);
- update(csk);
+ union(csk);
return;
}
diff --git a/src/main/java/org/apache/datasketches/tuple/Intersection.java b/src/main/java/org/apache/datasketches/tuple/Intersection.java
index d92f203..ea841c6 100644
--- a/src/main/java/org/apache/datasketches/tuple/Intersection.java
+++ b/src/main/java/org/apache/datasketches/tuple/Intersection.java
@@ -34,7 +34,8 @@ import org.apache.datasketches.SketchesStateException;
/**
- * Computes an intersection of two or more generic tuple sketches.
+ * Computes an intersection of two or more generic tuple sketches or generic tuple sketches
+ * combined with theta sketches.
* A new instance represents the Universal Set. Because the Universal Set
* cannot be realized a <i>getResult()</i> on a new instance will produce an error.
* Every update() computes an intersection with the internal state, which will never
@@ -64,20 +65,66 @@ public class Intersection<S extends Summary> {
}
/**
- * Updates the internal state by intersecting it with the given sketch.
- * @param sketchIn input sketch to intersect with the internal state. It may not be null.
+ * Perform a stateless intersect set operation on the two given tuple sketches and returns the
+ * result as an unordered CompactSketch on the heap.
+ * @param tupleSketchA The first sketch argument. It must not be null.
+ * @param tupleSketchB The second sketch argument. It must not be null.
+ * @return an unordered CompactSketch on the heap
*/
- public void update(final Sketch<S> sketchIn) {
- if (sketchIn == null) { throw new SketchesArgumentException("Sketch may not be null"); }
+ public CompactSketch<S> intersect(final Sketch<S> tupleSketchA, final Sketch<S> tupleSketchB) {
+ reset();
+ intersect(tupleSketchA);
+ intersect(tupleSketchB);
+ final CompactSketch<S> csk = getResult();
+ reset();
+ return csk;
+ }
+
+ /**
+ * Perform a stateless intersect set operation on a tuple sketch and a theta sketch and returns the
+ * result as an unordered CompactSketch on the heap.
+ * @param tupleSketch The first sketch argument. It must not be null.
+ * @param thetaSketch The second sketch argument. It must not be null.
+ * @param summary the given proxy summary for the theta sketch, which doesn't have one.
+ * This must not be null.
+ * @return an unordered CompactSketch on the heap
+ */
+ public CompactSketch<S> intersect(final Sketch<S> tupleSketch,
+ final org.apache.datasketches.theta.Sketch thetaSketch, final S summary) {
+ reset();
+ intersect(tupleSketch);
+ intersect(thetaSketch, summary);
+ final CompactSketch<S> csk = getResult();
+ reset();
+ return csk;
+ }
+
+ /**
+ * Performs a stateful intersection of the internal set with the given tupleSketch.
+ * @param tupleSketch input sketch to intersect with the internal state. It must not be null.
+ * @deprecated 2.0.0. Please use {@link #intersect(Sketch)}.
+ */
+ @Deprecated
+ public void update(final Sketch<S> tupleSketch) {
+ intersect(tupleSketch);
+ }
+
+ /**
+ * Performs a stateful intersection of the internal set with the given tupleSketch.
+ * @param tupleSketch input sketch to intersect with the internal state. It must not be null.
+ */
+ public void intersect(final Sketch<S> tupleSketch) {
+ if (tupleSketch == null) { throw new SketchesArgumentException("Sketch must not be null"); }
final boolean firstCall = firstCall_;
firstCall_ = false;
// input sketch could be first or next call
- final long thetaLongIn = sketchIn.getThetaLong();
- final int countIn = sketchIn.getRetainedEntries();
+ final long thetaLongIn = tupleSketch.getThetaLong();
+ final int countIn = tupleSketch.getRetainedEntries();
thetaLong_ = min(thetaLong_, thetaLongIn); //Theta rule
// Empty rule extended in case incoming sketch does not have empty bit properly set
- empty_ |= countIn == 0 && thetaLongIn == Long.MAX_VALUE;
+ final boolean emptyIn = countIn == 0 && thetaLongIn == Long.MAX_VALUE;
+ empty_ |= emptyIn; //empty rule
if (countIn == 0) {
hashTables_.clear();
return;
@@ -85,7 +132,7 @@ public class Intersection<S extends Summary> {
// input sketch will have valid entries > 0
if (firstCall) {
- final Sketch<S> firstSketch = sketchIn;
+ final Sketch<S> firstSketch = tupleSketch;
//Copy firstSketch data into local instance hashTables_
hashTables_.fromSketch(firstSketch);
}
@@ -95,7 +142,7 @@ public class Intersection<S extends Summary> {
if (hashTables_.count_ == 0) {
return;
}
- final Sketch<S> nextSketch = sketchIn;
+ final Sketch<S> nextSketch = tupleSketch;
//Match nextSketch data with local instance data, filtering by theta
final int maxMatchSize = min(hashTables_.count_, nextSketch.getRetainedEntries());
@@ -126,29 +173,47 @@ public class Intersection<S extends Summary> {
}
/**
- * Updates the internal set by intersecting it with the given Theta sketch.
- * @param sketchIn input Theta Sketch to intersect with the internal state. It may not be null.
- * @param summary the given proxy summary for the Theta Sketch, which doesn't have one.
- * It will be copied for each matching index. It may not be null.
+ * Performs a stateful intersection of the internal set with the given thetaSketch by combining entries
+ * using the hashes from the theta sketch and summary values from the given summary and rules
+ * from the summarySetOps defined by the Intersection constructor.
+ * @param thetaSketch input theta sketch to intersect with the internal state. It must not be null.
+ * @param summary the given proxy summary for the theta sketch, which doesn't have one.
+ * It will be copied for each matching index. It must not be null.
+ * @deprecated 2.0.0. Please use intersect(org.apache.datasketches.theta.Sketch, S).
+ */
+ @Deprecated //note the {at_link} does not work in the above
+ public void update(final org.apache.datasketches.theta.Sketch thetaSketch, final S summary) {
+ intersect(thetaSketch, summary);
+ }
+
+ /**
+ * Performs a stateful intersection of the internal set with the given thetaSketch by combining entries
+ * using the hashes from the theta sketch and summary values from the given summary and rules
+ * from the summarySetOps defined by the Intersection constructor.
+ * @param thetaSketch input theta sketch to intersect with the internal state. It must not be null.
+ * @param summary the given proxy summary for the theta sketch, which doesn't have one.
+ * It will be copied for each matching index. It must not be null.
*/
- public void update(final org.apache.datasketches.theta.Sketch sketchIn, final S summary) {
- if (sketchIn == null) { throw new SketchesArgumentException("Sketch may not be null"); }
+ public void intersect(final org.apache.datasketches.theta.Sketch thetaSketch, final S summary) {
+ if (thetaSketch == null) { throw new SketchesArgumentException("Sketch must not be null"); }
if (summary == null) { throw new SketchesArgumentException("Summary cannot be null."); }
final boolean firstCall = firstCall_;
firstCall_ = false;
+
// input sketch is not null, could be first or next call
- final long thetaLongIn = sketchIn.getThetaLong();
- final int countIn = sketchIn.getRetainedEntries(true);
+ final long thetaLongIn = thetaSketch.getThetaLong();
+ final int countIn = thetaSketch.getRetainedEntries(true);
thetaLong_ = min(thetaLong_, thetaLongIn); //Theta rule
// Empty rule extended in case incoming sketch does not have empty bit properly set
- empty_ |= countIn == 0 && thetaLongIn == Long.MAX_VALUE;
+ final boolean emptyIn = countIn == 0 && thetaLongIn == Long.MAX_VALUE;
+ empty_ |= emptyIn; //empty rule
if (countIn == 0) {
hashTables_.clear();
return;
}
// input sketch will have valid entries > 0
if (firstCall) {
- final org.apache.datasketches.theta.Sketch firstSketch = sketchIn;
+ final org.apache.datasketches.theta.Sketch firstSketch = thetaSketch;
//Copy firstSketch data into local instance hashTables_
hashTables_.fromSketch(firstSketch, summary);
}
@@ -158,7 +223,7 @@ public class Intersection<S extends Summary> {
if (hashTables_.count_ == 0) {
return;
}
- final org.apache.datasketches.theta.Sketch nextSketch = sketchIn;
+ final org.apache.datasketches.theta.Sketch nextSketch = thetaSketch;
//Match nextSketch data with local instance data, filtering by theta
final int maxMatchSize = min(hashTables_.count_, nextSketch.getRetainedEntries(true));
@@ -166,7 +231,7 @@ public class Intersection<S extends Summary> {
S[] matchSummaries = null;
int matchCount = 0;
- final org.apache.datasketches.theta.HashIterator it = sketchIn.iterator();
+ final org.apache.datasketches.theta.HashIterator it = thetaSketch.iterator();
final Class<S> summaryType = (Class<S>) hashTables_.summaryTable_.getClass().getComponentType();
while (it.next()) {
final long hash = it.get();
@@ -222,6 +287,14 @@ public class Intersection<S extends Summary> {
}
/**
+ * Returns true if there is a valid intersection result available
+ * @return true if there is a valid intersection result available
+ */
+ public boolean hasResult() {
+ return !firstCall_;
+ }
+
+ /**
* Resets the internal set to the initial state, which represents the Universal Set
*/
public void reset() {
diff --git a/src/main/java/org/apache/datasketches/tuple/Union.java b/src/main/java/org/apache/datasketches/tuple/Union.java
index 5debba6..467507f 100644
--- a/src/main/java/org/apache/datasketches/tuple/Union.java
+++ b/src/main/java/org/apache/datasketches/tuple/Union.java
@@ -28,10 +28,8 @@ import org.apache.datasketches.QuickSelect;
import org.apache.datasketches.SketchesArgumentException;
/**
- * Compute a union of two or more tuple sketches.
- * A new instance represents an empty set.
- * Every update() computes a union with the internal set
- * and can only grow the internal set.
+ * Compute the union of two or more generic tuple sketches or generic tuple sketches combined with
+ * theta sketches. A new instance represents an empty set.
* @param <S> Type of Summary
*/
public class Union<S extends Summary> {
@@ -41,7 +39,7 @@ public class Union<S extends Summary> {
private boolean empty_;
/**
- * Creates new Intersection instance with instructions on how to process two summaries that
+ * Creates new Union instance with instructions on how to process two summaries that
* overlap. This will have the default nominal entries (K).
* @param summarySetOps instance of SummarySetOperations
*/
@@ -50,9 +48,8 @@ public class Union<S extends Summary> {
}
/**
- * Creates new Intersection instance with instructions on how to process two summaries that
+ * Creates new Union instance with instructions on how to process two summaries that
* overlap.
- * Creates new instance
* @param nomEntries nominal entries (K). Forced to the nearest power of 2 greater than
* given value.
* @param summarySetOps instance of SummarySetOperations
@@ -65,15 +62,70 @@ public class Union<S extends Summary> {
}
/**
- * Updates the internal set by adding entries from the given sketch
- * @param sketchIn input sketch to add to the internal set.
- * If null or empty, it is ignored.
+ * Perform a stateless, pair-wise union operation between two tuple sketches.
+ * The returned sketch will be cutback to the smaller of the two k values if required.
+ *
+ * <p>Nulls and empty sketches are ignored.</p>
+ *
+ * @param tupleSketchA The first argument
+ * @param tupleSketchB The second argument
+ * @return the result ordered CompactSketch on the heap.
*/
- public void update(final Sketch<S> sketchIn) {
- if (sketchIn == null || sketchIn.isEmpty()) { return; }
+ public CompactSketch<S> union(final Sketch<S> tupleSketchA, final Sketch<S> tupleSketchB) {
+ reset();
+ union(tupleSketchA);
+ union(tupleSketchB);
+ final CompactSketch<S> csk = getResult();
+ reset();
+ return csk;
+ }
+
+ /**
+ * Perform a stateless, pair-wise union operation between a tupleSketch and a thetaSketch.
+ * The returned sketch will be cutback to the smaller of the two k values if required.
+ *
+ * <p>Nulls and empty sketches are ignored.</p>
+ *
+ * @param tupleSketch The first argument
+ * @param thetaSketch The second argument
+ * @param summary the given proxy summary for the theta sketch, which doesn't have one.
+ * This may not be null.
+ * @return the result ordered CompactSketch on the heap.
+ */
+ public CompactSketch<S> union(final Sketch<S> tupleSketch,
+ final org.apache.datasketches.theta.Sketch thetaSketch, final S summary) {
+ reset();
+ union(tupleSketch);
+ union(thetaSketch, summary);
+ final CompactSketch<S> csk = getResult();
+ reset();
+ return csk;
+ }
+
+ /**
+ * Performs a stateful union of the internal set with the given tupleSketch.
+ * @param tupleSketch input tuple sketch to add to the internal set.
+ *
+ * <p>Nulls and empty sketches are ignored.</p>
+ *
+ * @deprecated 2.0.0. Please use {@link #union(org.apache.datasketches.tuple.Sketch)}.
+ */
+ @Deprecated
+ public void update(final Sketch<S> tupleSketch) {
+ union(tupleSketch);
+ }
+
+ /**
+ * Performs a stateful union of the internal set with the given tupleSketch.
+ * @param tupleSketch input tuple sketch to merge with the internal set.
+ *
+ * <p>Nulls and empty sketches are ignored.</p>
+ */
+ public void union(final Sketch<S> tupleSketch) {
+ if (tupleSketch == null || tupleSketch.isEmpty()) { return; }
empty_ = false;
- if (sketchIn.thetaLong_ < thetaLong_) { thetaLong_ = sketchIn.thetaLong_; }
- final SketchIterator<S> it = sketchIn.iterator();
+ if (tupleSketch.thetaLong_ < thetaLong_) { thetaLong_ = tupleSketch.thetaLong_; }
+ final SketchIterator<S> it = tupleSketch.iterator();
while (it.next()) {
qsk_.merge(it.getHash(), it.getSummary(), summarySetOps_);
}
@@ -83,22 +135,36 @@ public class Union<S extends Summary> {
}
/**
- * Updates the internal set by combining entries using the hashes from the Theta Sketch and
- * summary values from the given summary and rules from the summarySetOps defined by the
- * Union constructor.
- * @param sketchIn the given Theta Sketch input. If null or empty, it is ignored.
- * @param summary the given proxy summary for the Theta Sketch, which doesn't have one. This may
+ * Performs a stateful union of the internal set with the given thetaSketch by combining entries
+ * using the hashes from the theta sketch and summary values from the given summary and rules
+ * from the summarySetOps defined by the Union constructor.
+ * @param thetaSketch the given theta sketch input. If null or empty, it is ignored.
+ * @param summary the given proxy summary for the theta sketch, which doesn't have one. This may
+ * not be null.
+ * @deprecated 2.0.0. Please use union(org.apache.datasketches.theta.Sketch, S).
+ */
+ @Deprecated //note the {at_link} does not work in the above
+ public void update(final org.apache.datasketches.theta.Sketch thetaSketch, final S summary) {
+ union(thetaSketch, summary);
+ }
+
+ /**
+ * Performs a stateful union of the internal set with the given thetaSketch by combining entries
+ * using the hashes from the theta sketch and summary values from the given summary and rules
+ * from the summarySetOps defined by the Union constructor.
+ * @param thetaSketch the given theta sketch input. If null or empty, it is ignored.
+ * @param summary the given proxy summary for the theta sketch, which doesn't have one. This may
* not be null.
*/
@SuppressWarnings("unchecked")
- public void update(final org.apache.datasketches.theta.Sketch sketchIn, final S summary) {
+ public void union(final org.apache.datasketches.theta.Sketch thetaSketch, final S summary) {
if (summary == null) {
throw new SketchesArgumentException("Summary cannot be null."); }
- if (sketchIn == null || sketchIn.isEmpty()) { return; }
+ if (thetaSketch == null || thetaSketch.isEmpty()) { return; }
empty_ = false;
- final long thetaIn = sketchIn.getThetaLong();
+ final long thetaIn = thetaSketch.getThetaLong();
if (thetaIn < thetaLong_) { thetaLong_ = thetaIn; }
- final org.apache.datasketches.theta.HashIterator it = sketchIn.iterator();
+ final org.apache.datasketches.theta.HashIterator it = thetaSketch.iterator();
while (it.next()) {
qsk_.merge(it.get(), (S)summary.copy(), summarySetOps_);
}
@@ -108,8 +174,8 @@ public class Union<S extends Summary> {
}
/**
- * Gets the internal set as an unordered CompactSketch
- * @return result of the unions so far
+ * Gets the result of a sequence of stateful <i>union</i> operations as an unordered CompactSketch
+ * @return result of the stateful unions so far
*/
@SuppressWarnings("unchecked")
public CompactSketch<S> getResult() {
@@ -159,7 +225,8 @@ public class Union<S extends Summary> {
}
/**
- * Resets the internal set to the initial state, which represents an empty set
+ * Resets the internal set to the initial state, which represents an empty set. This is only useful
+ * after sequences of stateful union operations.
*/
public void reset() {
qsk_.reset();
diff --git a/src/main/java/org/apache/datasketches/tuple/adouble/DoubleSummarySetOperations.java b/src/main/java/org/apache/datasketches/tuple/adouble/DoubleSummarySetOperations.java
index 961a658..9a2fdd3 100644
--- a/src/main/java/org/apache/datasketches/tuple/adouble/DoubleSummarySetOperations.java
+++ b/src/main/java/org/apache/datasketches/tuple/adouble/DoubleSummarySetOperations.java
@@ -37,7 +37,26 @@ public final class DoubleSummarySetOperations implements SummarySetOperations<Do
private final Mode intersectionSummaryMode_;
/**
- * Creates a new instance with two modes
+ * Creates an instance with default mode of <i>sum</i> for both union and intersection.
+ * This exists for backward compatibility.
+ */
+ public DoubleSummarySetOperations() {
+ unionSummaryMode_ = DoubleSummary.Mode.Sum;
+ intersectionSummaryMode_ = DoubleSummary.Mode.Sum;
+ }
+
+ /**
+ * Creates an instance given a DoubleSummary update mode where the mode is the same for both
+ * union and intersection. This exists for backward compatibility.
+ * @param summaryMode DoubleSummary update mode.
+ */
+ public DoubleSummarySetOperations(final Mode summaryMode) {
+ unionSummaryMode_ = summaryMode;
+ intersectionSummaryMode_ = summaryMode;
+ }
+
+ /**
+ * Creates an instance with two modes.
* @param unionSummaryMode for unions
* @param intersectionSummaryMode for intersections
*/
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersection.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersection.java
index 2242f5e..8224b5b 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersection.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersection.java
@@ -51,37 +51,48 @@ public abstract class ArrayOfDoublesIntersection {
}
/**
- * Updates the internal set by intersecting it with the given sketch.
- * @param sketchIn Input sketch to intersect with the internal set.
+ * Performs a stateful intersection of the internal set with the given tupleSketch.
+ * @param tupleSketch Input sketch to intersect with the internal set.
* @param combiner Method of combining two arrays of double values
+ * @deprecated 2.0.0 Please use {@link #intersect(ArrayOfDoublesSketch, ArrayOfDoublesCombiner)}.
*/
- public void update(final ArrayOfDoublesSketch sketchIn, final ArrayOfDoublesCombiner combiner) {
+ @Deprecated
+ public void update(final ArrayOfDoublesSketch tupleSketch, final ArrayOfDoublesCombiner combiner) {
+ intersect(tupleSketch, combiner);
+ }
+
+ /**
+ * Performs a stateful intersection of the internal set with the given tupleSketch.
+ * @param tupleSketch Input sketch to intersect with the internal set.
+ * @param combiner Method of combining two arrays of double values
+ */
+ public void intersect(final ArrayOfDoublesSketch tupleSketch, final ArrayOfDoublesCombiner combiner) {
final boolean isFirstCall = isFirstCall_;
isFirstCall_ = false;
- if (sketchIn == null) {
+ if (tupleSketch == null) {
isEmpty_ = true;
sketch_ = null;
return;
}
- Util.checkSeedHashes(seedHash_, sketchIn.getSeedHash());
- theta_ = min(theta_, sketchIn.getThetaLong());
- isEmpty_ |= sketchIn.isEmpty();
- if (isEmpty_ || sketchIn.getRetainedEntries() == 0) {
+ Util.checkSeedHashes(seedHash_, tupleSketch.getSeedHash());
+ theta_ = min(theta_, tupleSketch.getThetaLong());
+ isEmpty_ |= tupleSketch.isEmpty();
+ if (isEmpty_ || tupleSketch.getRetainedEntries() == 0) {
sketch_ = null;
return;
}
if (isFirstCall) {
- sketch_ = createSketch(sketchIn.getRetainedEntries(), numValues_, seed_);
- final ArrayOfDoublesSketchIterator it = sketchIn.iterator();
+ sketch_ = createSketch(tupleSketch.getRetainedEntries(), numValues_, seed_);
+ final ArrayOfDoublesSketchIterator it = tupleSketch.iterator();
while (it.next()) {
sketch_.insert(it.getKey(), it.getValues());
}
} else { //not the first call
- final int matchSize = min(sketch_.getRetainedEntries(), sketchIn.getRetainedEntries());
+ final int matchSize = min(sketch_.getRetainedEntries(), tupleSketch.getRetainedEntries());
final long[] matchKeys = new long[matchSize];
final double[][] matchValues = new double[matchSize][];
int matchCount = 0;
- final ArrayOfDoublesSketchIterator it = sketchIn.iterator();
+ final ArrayOfDoublesSketchIterator it = tupleSketch.iterator();
while (it.next()) {
final double[] values = sketch_.find(it.getKey());
if (values != null) {
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnion.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnion.java
index f8313fe..7835c82 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnion.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnion.java
@@ -119,21 +119,37 @@ public abstract class ArrayOfDoublesUnion {
}
/**
+ * Performs a stateful union of the internal set with the given tupleSketch.
+ * @param tupleSketch input tuple sketch to add to the internal set.
+ *
+ * <p>Nulls and empty sketches are ignored.</p>
+ *
+ * @deprecated 2.0.0. Please use {@link #union(ArrayOfDoublesSketch)}.
+ */
+ @Deprecated
+ public void update(final ArrayOfDoublesSketch tupleSketch) {
+ union(tupleSketch);
+ }
+
+ /**
* Updates the union by adding a set of entries from a given sketch
- * @param sketchIn sketch to add to the union
+ *
+ * <p>Nulls and empty sketches are ignored.</p>
+ *
+ * @param tupleSketch sketch to add to the union
*/
- public void update(final ArrayOfDoublesSketch sketchIn) {
- if (sketchIn == null) { return; }
- Util.checkSeedHashes(sketch_.getSeedHash(), sketchIn.getSeedHash());
- if (sketch_.getNumValues() != sketchIn.getNumValues()) {
+ public void union(final ArrayOfDoublesSketch tupleSketch) {
+ if (tupleSketch == null) { return; }
+ Util.checkSeedHashes(sketch_.getSeedHash(), tupleSketch.getSeedHash());
+ if (sketch_.getNumValues() != tupleSketch.getNumValues()) {
throw new SketchesArgumentException("Incompatible sketches: number of values mismatch "
- + sketch_.getNumValues() + " and " + sketchIn.getNumValues());
+ + sketch_.getNumValues() + " and " + tupleSketch.getNumValues());
}
- if (sketchIn.isEmpty()) { return; }
- if (sketchIn.getThetaLong() < theta_) {
- setThetaLong(sketchIn.getThetaLong());
+ if (tupleSketch.isEmpty()) { return; }
+ if (tupleSketch.getThetaLong() < theta_) {
+ setThetaLong(tupleSketch.getThetaLong());
}
- final ArrayOfDoublesSketchIterator it = sketchIn.iterator();
+ final ArrayOfDoublesSketchIterator it = tupleSketch.iterator();
while (it.next()) {
if (it.getKey() < theta_) {
sketch_.merge(it.getKey(), it.getValues());
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesUnionR.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesUnionR.java
index 8b4e360..3cde49a 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesUnionR.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesUnionR.java
@@ -34,7 +34,7 @@ final class DirectArrayOfDoublesUnionR extends DirectArrayOfDoublesUnion {
}
@Override
- public void update(final ArrayOfDoublesSketch sketchIn) {
+ public void union(final ArrayOfDoublesSketch tupleSketch) {
throw new SketchesReadOnlyException();
}
diff --git a/src/test/java/org/apache/datasketches/BinarySearchTest.java b/src/test/java/org/apache/datasketches/BinarySearchTest.java
index 5b25df0..b1bac81 100644
--- a/src/test/java/org/apache/datasketches/BinarySearchTest.java
+++ b/src/test/java/org/apache/datasketches/BinarySearchTest.java
@@ -37,6 +37,7 @@ import org.testng.annotations.Test;
public class BinarySearchTest {
static Random rand = new Random(1);
private static final String LS = System.getProperty("line.separator");
+ private static int randDelta() { return rand.nextDouble() < 0.4 ? 0 : 1; }
private static float[] buildRandFloatArr(final int len) {
final float[] arr = new float[len];
@@ -58,21 +59,18 @@ public class BinarySearchTest {
return arr;
}
- private static int randDelta() { return rand.nextDouble() < 0.4 ? 0 : 1; }
-
- @Test //visual testing only
- //@SuppressWarnings("unused")
- private static void checkBuildRandArr() {
- final int len = 10;
- for (int i = 0; i < 10; i++) {
- final float[] tarr = buildRandFloatArr(len);
- for (int j = 0; j < len; j++) {
- printf("%4.1f,", tarr[j]);
- }
- println("");
+ private static long[] buildRandLongArr(final int len) {
+ final long[] arr = new long[len];
+ long v = 1L;
+ for (int i = 0; i < len; i++) {
+ arr[i] = v;
+ v += 2 * randDelta();
}
+ return arr;
}
+ //double array
+
@Test
public void checkBinSearchDblLimits() {
for (int len = 10; len <= 13; len++) {
@@ -87,8 +85,9 @@ public class BinarySearchTest {
private static String listDblArray(final double[] arr, final int low, final int high) {
final StringBuilder sb = new StringBuilder();
sb.append(LS);
- sb.append("arr: ");
- for (int i = 0; i < arr.length; i++) {
+ final int len = arr.length;
+ sb.append("double[" + len + "]: ");
+ for (int i = 0; i < len; i++) {
if (i == low || i == high) { sb.append(String.format("(%.0f) ", arr[i])); }
else { sb.append(String.format("%.0f ", arr[i])); }
}
@@ -176,6 +175,8 @@ public class BinarySearchTest {
assertEquals(res, -1);
}
+ //float array
+
@Test
public void checkBinSearchFltLimits() {
for (int len = 10; len <= 13; len++) {
@@ -190,8 +191,9 @@ public class BinarySearchTest {
private static String listFltArray(final float[] arr, final int low, final int high) {
final StringBuilder sb = new StringBuilder();
sb.append(LS);
- sb.append("arr: ");
- for (int i = 0; i < arr.length; i++) {
+ final int len = arr.length;
+ sb.append("float[" + len + "]: ");
+ for (int i = 0; i < len; i++) {
if (i == low || i == high) { sb.append(String.format("(%.0f) ", arr[i])); }
else { sb.append(String.format("%.0f ", arr[i])); }
}
@@ -279,7 +281,115 @@ public class BinarySearchTest {
assertEquals(res, -1);
}
- @Test // visual only
+ //long array
+
+ @Test
+ public void checkBinSearchLongLimits() {
+ for (int len = 10; len <= 13; len++) {
+ final long[] tarr = buildRandLongArr(len);
+ final int low = 2;
+ final int high = len - 2;
+ println(listLongArray(tarr, low, high));
+ checkBinarySearchLongLimits(tarr, low, high);
+ }
+ }
+
+ private static String listLongArray(final long[] arr, final int low, final int high) {
+ final StringBuilder sb = new StringBuilder();
+ sb.append(LS);
+ final int len = arr.length;
+ sb.append("long[" + len + "]: ");
+ for (int i = 0; i < len; i++) {
+ if (i == low || i == high) { sb.append(String.format("(%d) ", arr[i])); }
+ else { sb.append(String.format("%d ", arr[i])); }
+ }
+ return sb.toString();
+ }
+
+ private static void checkBinarySearchLongLimits(final long[] arr, final int low, final int high) {
+ final long lowV = arr[low];
+ final long highV = arr[high];
+ long v;
+ int res;
+ v = lowV - 1;
+ res = InequalitySearch.find(arr, low, high, v, LT);
+ println(LT.desc(arr, low, high, v, res));
+ assertEquals(res, -1);
+
+ v = lowV;
+ res = InequalitySearch.find(arr, low, high, v, LT);
+ println(LT.desc(arr, low, high, v, res));
+ assertEquals(res, -1);
+
+ v = highV + 1;
+ res = InequalitySearch.find(arr, low, high, v, LT);
+ println(LT.desc(arr, low, high, v, res));
+ assertEquals(res, high);
+
+ v = lowV -1;
+ res = InequalitySearch.find(arr, low, high, v, LE);
+ println(LE.desc(arr, low, high, v, res));
+ assertEquals(res, -1);
+
+ v = highV;
+ res = InequalitySearch.find(arr, low, high, v, LE);
+ println(LE.desc(arr, low, high, v, res));
+ assertEquals(res, high);
+
+ v = highV + 1;
+ res = InequalitySearch.find(arr, low, high, v, LE);
+ println(LE.desc(arr, low, high, v, res));
+ assertEquals(res, high);
+
+ v = lowV - 1;
+ res = InequalitySearch.find(arr, low, high, v, EQ);
+ println(EQ.desc(arr, low, high, v, res));
+ assertEquals(res, -1);
+
+ v = highV;
+ res = InequalitySearch.find(arr, low, high, v, EQ);
+ println(EQ.desc(arr, low, high, v, res));
+ assertEquals(arr[res], v);
+
+ v = highV + 1;
+ res = InequalitySearch.find(arr, low, high, v, EQ);
+ println(EQ.desc(arr, low, high, v, res));
+ assertEquals(res, -1);
+
+ v = lowV - 1;
+ res = InequalitySearch.find(arr, low, high, v, GT);
+ println(GT.desc(arr, low, high, v, res));
+ assertEquals(res, low);
+
+ v = highV;
+ res = InequalitySearch.find(arr, low, high, v, GT);
+ println(GT.desc(arr, low, high, v, res));
+ assertEquals(res, -1);
+
+ v = highV + 1;
+ res = InequalitySearch.find(arr, low, high, v, GT);
+ println(GT.desc(arr, low, high, v, res));
+ assertEquals(res, -1);
+
+ v = lowV - 1;
+ res = InequalitySearch.find(arr, low, high, v, GE);
+ println(GE.desc(arr, low, high, v, res));
+ assertEquals(res, low);
+
+ v = lowV;
+ res = InequalitySearch.find(arr, low, high, v, GE);
+ println(GE.desc(arr, low, high, v, res));
+ assertEquals(res, low);
+
+ v = highV + 1;
+ res = InequalitySearch.find(arr, low, high, v, GE);
+ println(GE.desc(arr, low, high, v, res));
+ assertEquals(res, -1);
+ }
+
+ /****************/
+
+ @Test // visual only for doubles inequality
public void exerciseDblBinSearch() {
// 0 1 2 3 4 5,6
final double[] arr = {1,1,3,3,4,5,5};
@@ -308,7 +418,7 @@ public class BinarySearchTest {
println("");
}
- @Test // visual only
+ @Test // visual only for floats inequality
public void exerciseFltBinSearch() {
// 0 1 2 3 4 5 6 7 8 9
final float[] arr = {5,5,5,6,6,6,7,8,8,8};
@@ -321,7 +431,7 @@ public class BinarySearchTest {
private static void checkFindFloat(final float[] arr, final InequalitySearch crit) {
println("InequalitySearch: " + crit.name());
final int len = arr.length;
- for (float v = 0.5f; v <= arr[len - 1] + 0.5f; v += .5f)
+ for (float v = 0.5f; v <= arr[len - 1] + 0.5f; v += 0.5f)
//final double v = 0.5;
{
final int low = 0;
@@ -337,6 +447,38 @@ public class BinarySearchTest {
println("");
}
+ @Test // visual only for longs inequality
+ public void exerciseLongBinSearch() {
+ // 0 1 2 3 4 5 6 7 8 9
+ final long[] arr = {5,5,5,7,7,7,9,11,11,11};
+ checkFindLong(arr, LT);
+ checkFindLong(arr, LE);
+ checkFindLong(arr, GT);
+ checkFindLong(arr, GE);
+ }
+
+ /****************/
+
+ private static void checkFindLong(final long[] arr, final InequalitySearch crit) {
+ println("InequalitySearch: " + crit.name());
+ final int len = arr.length;
+ for (long v = 1L; v <= arr[len - 1] + 1L; v++)
+ {
+ final int low = 0;
+ final int high = len - 1;
+ final int idx = InequalitySearch.find(arr, low, high, v, crit);
+ if (idx == -1) {
+ println("LT: " + v + " Not resolved, return -1.");
+ }
+ else {
+ println(crit.desc(arr, low, high, v, idx));
+ }
+ }
+ println("");
+ }
+
+ //test equality binary searches
+
@Test
public void checkSimpleFindFloat() {
final int len = 10;
@@ -369,6 +511,36 @@ public class BinarySearchTest {
assertEquals(idx, -1);
}
+ @Test
+ public void checkSimpleFindLong() {
+ final int len = 11;
+ final long[] arr = new long[len];
+ for (int i = 0; i < len; i++) { arr[i] = i; }
+ int idx;
+ for (int i = 0; i < len; i++) {
+ idx = BinarySearch.find(arr, 0, len - 1, i);
+ assertEquals(idx, i);
+ }
+ idx = BinarySearch.find(arr, 0, len - 1, -1);
+ assertEquals(idx, -1);
+ idx = BinarySearch.find(arr, 0, len - 1, len);
+ assertEquals(idx, -1);
+ }
+
+ /****************/
+
+ //@Test //visual testing only
+ @SuppressWarnings("unused")
+ private static void checkBuildRandFloatArr() {
+ final int len = 10;
+ for (int i = 0; i < 10; i++) {
+ final float[] tarr = buildRandFloatArr(len);
+ for (int j = 0; j < len; j++) {
+ printf("%4.1f,", tarr[j]);
+ }
+ println("");
+ }
+ }
/**
* @param format the format
diff --git a/src/test/java/org/apache/datasketches/tuple/ReadOnlyMemoryTest.java b/src/test/java/org/apache/datasketches/tuple/ReadOnlyMemoryTest.java
index 8d50d86..0171247 100644
--- a/src/test/java/org/apache/datasketches/tuple/ReadOnlyMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/ReadOnlyMemoryTest.java
@@ -19,9 +19,7 @@
package org.apache.datasketches.tuple;
-import org.testng.Assert;
-import org.testng.annotations.Test;
-
+import org.apache.datasketches.SketchesReadOnlyException;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.tuple.arrayofdoubles.ArrayOfDoublesSetOperationBuilder;
import org.apache.datasketches.tuple.arrayofdoubles.ArrayOfDoublesSketch;
@@ -29,28 +27,29 @@ import org.apache.datasketches.tuple.arrayofdoubles.ArrayOfDoublesSketches;
import org.apache.datasketches.tuple.arrayofdoubles.ArrayOfDoublesUnion;
import org.apache.datasketches.tuple.arrayofdoubles.ArrayOfDoublesUpdatableSketch;
import org.apache.datasketches.tuple.arrayofdoubles.ArrayOfDoublesUpdatableSketchBuilder;
-import org.apache.datasketches.SketchesReadOnlyException;
+import org.testng.Assert;
+import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class ReadOnlyMemoryTest {
@Test
public void wrapAndTryUpdatingSketch() {
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
sketch1.update(1, new double[] {1});
- ArrayOfDoublesUpdatableSketch sketch2 = (ArrayOfDoublesUpdatableSketch)
+ final ArrayOfDoublesUpdatableSketch sketch2 = (ArrayOfDoublesUpdatableSketch)
ArrayOfDoublesSketches.wrapSketch(Memory.wrap(sketch1.toByteArray()));
Assert.assertEquals(sketch2.getEstimate(), 1.0);
sketch2.toByteArray();
boolean thrown = false;
try {
sketch2.update(2, new double[] {1});
- } catch (SketchesReadOnlyException e) {
+ } catch (final SketchesReadOnlyException e) {
thrown = true;
}
try {
sketch2.trim();
- } catch (SketchesReadOnlyException e) {
+ } catch (final SketchesReadOnlyException e) {
thrown = true;
}
Assert.assertTrue(thrown);
@@ -58,10 +57,10 @@ public class ReadOnlyMemoryTest {
@Test
public void heapifyAndUpdateSketch() {
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
sketch1.update(1, new double[] {1});
// downcasting is not recommended, for testing only
- ArrayOfDoublesUpdatableSketch sketch2 = (ArrayOfDoublesUpdatableSketch)
+ final ArrayOfDoublesUpdatableSketch sketch2 = (ArrayOfDoublesUpdatableSketch)
ArrayOfDoublesSketches.heapifySketch(Memory.wrap(sketch1.toByteArray()));
sketch2.update(2, new double[] {1});
Assert.assertEquals(sketch2.getEstimate(), 2.0);
@@ -69,29 +68,29 @@ public class ReadOnlyMemoryTest {
@Test
public void wrapAndTryUpdatingUnionEstimationMode() {
- int numUniques = 10000;
+ final int numUniques = 10000;
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < numUniques; i++) {
sketch1.update(key++, new double[] {1});
}
- ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().buildUnion();
- union1.update(sketch1);
- ArrayOfDoublesUnion union2 = ArrayOfDoublesSketches.wrapUnion(Memory.wrap(union1.toByteArray()));
- ArrayOfDoublesSketch resultSketch = union2.getResult();
+ final ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().buildUnion();
+ union1.union(sketch1);
+ final ArrayOfDoublesUnion union2 = ArrayOfDoublesSketches.wrapUnion(Memory.wrap(union1.toByteArray()));
+ final ArrayOfDoublesSketch resultSketch = union2.getResult();
Assert.assertTrue(resultSketch.isEstimationMode());
Assert.assertEquals(resultSketch.getEstimate(), numUniques, numUniques * 0.04);
// make sure union update actually needs to modify the union
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < numUniques; i++) {
sketch2.update(key++, new double[] {1});
}
boolean thrown = false;
try {
- union2.update(sketch2);
- } catch (SketchesReadOnlyException e) {
+ union2.union(sketch2);
+ } catch (final SketchesReadOnlyException e) {
thrown = true;
}
Assert.assertTrue(thrown);
@@ -99,25 +98,25 @@ public class ReadOnlyMemoryTest {
@Test
public void heapifyAndUpdateUnion() {
- int numUniques = 10000;
+ final int numUniques = 10000;
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < numUniques; i++) {
sketch1.update(key++, new double[] {1});
}
- ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().buildUnion();
- union1.update(sketch1);
- ArrayOfDoublesUnion union2 = ArrayOfDoublesSketches.heapifyUnion(Memory.wrap(union1.toByteArray()));
- ArrayOfDoublesSketch resultSketch = union2.getResult();
+ final ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().buildUnion();
+ union1.union(sketch1);
+ final ArrayOfDoublesUnion union2 = ArrayOfDoublesSketches.heapifyUnion(Memory.wrap(union1.toByteArray()));
+ final ArrayOfDoublesSketch resultSketch = union2.getResult();
Assert.assertTrue(resultSketch.isEstimationMode());
Assert.assertEquals(resultSketch.getEstimate(), numUniques, numUniques * 0.04);
// make sure union update actually needs to modify the union
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < numUniques; i++) {
sketch2.update(key++, new double[] {1});
}
- union2.update(sketch2);
+ union2.union(sketch2);
}
}
diff --git a/src/test/java/org/apache/datasketches/tuple/TupleExamples2Test.java b/src/test/java/org/apache/datasketches/tuple/TupleExamples2Test.java
new file mode 100644
index 0000000..92b9951
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/tuple/TupleExamples2Test.java
@@ -0,0 +1,288 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.datasketches.tuple;
+
+ import static org.testng.Assert.assertEquals;
+
+import org.apache.datasketches.theta.UpdateSketch;
+import org.apache.datasketches.theta.UpdateSketchBuilder;
+import org.apache.datasketches.tuple.adouble.DoubleSummary;
+import org.apache.datasketches.tuple.adouble.DoubleSummary.Mode;
+import org.apache.datasketches.tuple.adouble.DoubleSummaryFactory;
+import org.apache.datasketches.tuple.adouble.DoubleSummarySetOperations;
+import org.testng.annotations.Test;
+
+ /**
+ * Tests for Version 2.0.0
+ * @author Lee Rhodes
+ */
+ @SuppressWarnings("javadoc")
+ public class TupleExamples2Test {
+ private final DoubleSummary.Mode umode = Mode.Sum;
+ private final DoubleSummary.Mode imode = Mode.AlwaysOne;
+ private final DoubleSummarySetOperations dsso0 = new DoubleSummarySetOperations();
+ private final DoubleSummarySetOperations dsso1 = new DoubleSummarySetOperations(umode);
+ private final DoubleSummarySetOperations dsso2 = new DoubleSummarySetOperations(umode, imode);
+ private final DoubleSummaryFactory ufactory = new DoubleSummaryFactory(umode);
+ private final DoubleSummaryFactory ifactory = new DoubleSummaryFactory(imode);
+ private final UpdateSketchBuilder thetaBldr = UpdateSketch.builder();
+ private final UpdatableSketchBuilder<Double, DoubleSummary> tupleBldr =
+ new UpdatableSketchBuilder<>(ufactory);
+
+
+ @Test
+ public void example1() { // stateful: tuple, theta, use dsso2
+ //Load source sketches
+ final UpdatableSketch<Double, DoubleSummary> tupleSk = tupleBldr.build();
+ final UpdateSketch thetaSk = thetaBldr.build();
+ for (int i = 1; i <= 12; i++) {
+ tupleSk.update(i, 1.0);
+ thetaSk.update(i + 3);
+ }
+
+ //Union
+ final Union<DoubleSummary> union = new Union<>(dsso2);
+ union.union(tupleSk);
+ union.union(thetaSk, ufactory.newSummary().update(1.0));
+ final CompactSketch<DoubleSummary> ucsk = union.getResult();
+ int entries = ucsk.getRetainedEntries();
+ println("Union Stateful: tuple, theta: " + entries);
+ final SketchIterator<DoubleSummary> uiter = ucsk.iterator();
+ int counter = 1;
+ int twos = 0;
+ int ones = 0;
+ while (uiter.next()) {
+ final int i = (int)uiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 2, 6 entries = 1
+ if (i == 1) { ones++; }
+ if (i == 2) { twos++; }
+ }
+ assertEquals(ones, 6);
+ assertEquals(twos, 9);
+
+ //Intersection
+ final Intersection<DoubleSummary> inter = new Intersection<>(dsso2);
+ inter.intersect(tupleSk);
+ inter.intersect(thetaSk, ifactory.newSummary().update(1.0));
+ final CompactSketch<DoubleSummary> icsk = inter.getResult();
+ entries = icsk.getRetainedEntries();
+ println("Intersection Stateful: tuple, theta: " + entries);
+ final SketchIterator<DoubleSummary> iiter = icsk.iterator();
+ counter = 1;
+ while (iiter.next()) {
+ final int i = (int)iiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 1
+ assertEquals(i, 1);
+ }
+ }
+
+ @Test
+ public void example2() { //stateless: tuple1, tuple2, use dsso2
+ //Load source sketches
+ final UpdatableSketch<Double, DoubleSummary> tupleSk1 = tupleBldr.build();
+ final UpdatableSketch<Double, DoubleSummary> tupleSk2 = tupleBldr.build();
+
+ for (int i = 1; i <= 12; i++) {
+ tupleSk1.update(i, 1.0);
+ tupleSk2.update(i + 3, 1.0);
+ }
+
+ //Union
+ final Union<DoubleSummary> union = new Union<>(dsso2);
+ final CompactSketch<DoubleSummary> ucsk = union.union(tupleSk1, tupleSk2);
+ int entries = ucsk.getRetainedEntries();
+ println("Union: " + entries);
+ final SketchIterator<DoubleSummary> uiter = ucsk.iterator();
+ int counter = 1;
+ int twos = 0;
+ int ones = 0;
+ while (uiter.next()) {
+ final int i = (int)uiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 2, 6 entries = 1
+ if (i == 1) { ones++; }
+ if (i == 2) { twos++; }
+ }
+ assertEquals(ones, 6);
+ assertEquals(twos, 9);
+
+ //Intersection
+ final Intersection<DoubleSummary> inter = new Intersection<>(dsso2);
+ final CompactSketch<DoubleSummary> icsk = inter.intersect(tupleSk1, tupleSk2);
+ entries = icsk.getRetainedEntries();
+ println("Intersection: " + entries);
+ final SketchIterator<DoubleSummary> iiter = icsk.iterator();
+ counter = 1;
+ while (iiter.next()) {
+ final int i = (int)iiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 2
+ assertEquals(i, 1);
+ }
+ }
+
+ @Test
+ public void example3() { //stateless: tuple1, tuple2, use dsso2
+ //Load source sketches
+ final UpdatableSketch<Double, DoubleSummary> tupleSk = tupleBldr.build();
+ final UpdateSketch thetaSk = thetaBldr.build();
+ for (int i = 1; i <= 12; i++) {
+ tupleSk.update(i, 1.0);
+ thetaSk.update(i + 3);
+ }
+
+ //Union
+ final Union<DoubleSummary> union = new Union<>(dsso2);
+ final CompactSketch<DoubleSummary> ucsk =
+ union.union(tupleSk, thetaSk, ufactory.newSummary().update(1.0));
+ int entries = ucsk.getRetainedEntries();
+ println("Union: " + entries);
+ final SketchIterator<DoubleSummary> uiter = ucsk.iterator();
+ int counter = 1;
+ int twos = 0;
+ int ones = 0;
+ while (uiter.next()) {
+ final int i = (int)uiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 2, 6 entries = 1
+ if (i == 1) { ones++; }
+ if (i == 2) { twos++; }
+ }
+ assertEquals(ones, 6);
+ assertEquals(twos, 9);
+
+ //Intersection
+ final Intersection<DoubleSummary> inter = new Intersection<>(dsso2);
+ final CompactSketch<DoubleSummary> icsk =
+ inter.intersect(tupleSk, thetaSk, ufactory.newSummary().update(1.0));
+ entries = icsk.getRetainedEntries();
+ println("Intersection: " + entries);
+ final SketchIterator<DoubleSummary> iiter = icsk.iterator();
+ counter = 1;
+ while (iiter.next()) {
+ final int i = (int)iiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 2
+ assertEquals(i, 1);
+ }
+ }
+
+ @Test
+ public void example4() { //stateful: tuple, theta, Mode=sum for both, use dsso0
+ //Load source sketches
+ final UpdatableSketch<Double, DoubleSummary> tupleSk = tupleBldr.build();
+ final UpdateSketch thetaSk = thetaBldr.build();
+ for (int i = 1; i <= 12; i++) {
+ tupleSk.update(i, 1.0);
+ thetaSk.update(i + 3);
+ }
+
+ //Union
+ final Union<DoubleSummary> union = new Union<>(dsso0);
+ union.union(tupleSk);
+ union.union(thetaSk, ufactory.newSummary().update(1.0));
+ final CompactSketch<DoubleSummary> ucsk = union.getResult();
+ int entries = ucsk.getRetainedEntries();
+ println("Union Stateful: tuple, theta: " + entries);
+ final SketchIterator<DoubleSummary> uiter = ucsk.iterator();
+ int counter = 1;
+ int twos = 0;
+ int ones = 0;
+ while (uiter.next()) {
+ final int i = (int)uiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 2, 6 entries = 1
+ if (i == 1) { ones++; }
+ if (i == 2) { twos++; }
+ }
+ assertEquals(ones, 6);
+ assertEquals(twos, 9);
+
+ //Intersection
+ final Intersection<DoubleSummary> inter = new Intersection<>(dsso0);
+ inter.intersect(tupleSk);
+ inter.intersect(thetaSk, ifactory.newSummary().update(1.0));
+ final CompactSketch<DoubleSummary> icsk = inter.getResult();
+ entries = icsk.getRetainedEntries();
+ println("Intersection Stateful: tuple, theta: " + entries);
+ final SketchIterator<DoubleSummary> iiter = icsk.iterator();
+ counter = 1;
+ while (iiter.next()) {
+ final int i = (int)iiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 1
+ assertEquals(i, 2);
+ }
+ }
+
+ @Test
+ public void example5() { //stateful, tuple, theta, Mode=sum for both, use dsso1
+ //Load source sketches
+ final UpdatableSketch<Double, DoubleSummary> tupleSk = tupleBldr.build();
+ final UpdateSketch thetaSk = thetaBldr.build();
+ for (int i = 1; i <= 12; i++) {
+ tupleSk.update(i, 1.0);
+ thetaSk.update(i + 3);
+ }
+
+ //Union
+ final Union<DoubleSummary> union = new Union<>(dsso1);
+ union.union(tupleSk);
+ union.union(thetaSk, ufactory.newSummary().update(1.0));
+ final CompactSketch<DoubleSummary> ucsk = union.getResult();
+ int entries = ucsk.getRetainedEntries();
+ println("Union Stateful: tuple, theta: " + entries);
+ final SketchIterator<DoubleSummary> uiter = ucsk.iterator();
+ int counter = 1;
+ int twos = 0;
+ int ones = 0;
+ while (uiter.next()) {
+ final int i = (int)uiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 2, 6 entries = 1
+ if (i == 1) { ones++; }
+ if (i == 2) { twos++; }
+ }
+ assertEquals(ones, 6);
+ assertEquals(twos, 9);
+
+ //Intersection
+ final Intersection<DoubleSummary> inter = new Intersection<>(dsso1);
+ inter.intersect(tupleSk);
+ inter.intersect(thetaSk, ifactory.newSummary().update(1.0));
+ final CompactSketch<DoubleSummary> icsk = inter.getResult();
+ entries = icsk.getRetainedEntries();
+ println("Intersection Stateful: tuple, theta: " + entries);
+ final SketchIterator<DoubleSummary> iiter = icsk.iterator();
+ counter = 1;
+ while (iiter.next()) {
+ final int i = (int)iiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 1
+ assertEquals(i, 2);
+ }
+ }
+
+
+ @Test
+ public void printlnTest() {
+ println("PRINTING: "+this.getClass().getName());
+ }
+
+ /**
+ * @param s value to print
+ */
+ static void println(final String s) {
+ //System.out.println(s); //enable/disable here
+ }
+
+}
diff --git a/src/test/java/org/apache/datasketches/tuple/TupleExamplesTest.java b/src/test/java/org/apache/datasketches/tuple/TupleExamplesTest.java
index c055297..e71226e 100644
--- a/src/test/java/org/apache/datasketches/tuple/TupleExamplesTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/TupleExamplesTest.java
@@ -29,7 +29,10 @@ import org.apache.datasketches.tuple.aninteger.IntegerSummaryFactory;
import org.apache.datasketches.tuple.aninteger.IntegerSummarySetOperations;
import org.testng.annotations.Test;
-
+/**
+ * Tests for Version 2.0.0
+ * @author Lee Rhodes
+ */
@SuppressWarnings("javadoc")
public class TupleExamplesTest {
private final IntegerSummary.Mode umode = Mode.Sum;
@@ -43,7 +46,7 @@ public class TupleExamplesTest {
@Test
- public void tuple2dot0Examples() {
+ public void example1() {
//Load source sketches
final UpdatableSketch<Integer, IntegerSummary> tupleSk = tupleBldr.build();
final UpdateSketch thetaSk = thetaBldr.build();
@@ -52,13 +55,13 @@ public class TupleExamplesTest {
thetaSk.update(i + 3);
}
- //Union
+ //Union stateful: tuple, theta
final Union<IntegerSummary> union = new Union<>(isso);
- union.update(tupleSk);
- union.update(thetaSk, ufactory.newSummary().update(1));
+ union.union(tupleSk);
+ union.union(thetaSk, ufactory.newSummary().update(1));
final CompactSketch<IntegerSummary> ucsk = union.getResult();
int entries = ucsk.getRetainedEntries();
- println("Union: " + entries);
+ println("Union Stateful: tuple, theta: " + entries);
final SketchIterator<IntegerSummary> uiter = ucsk.iterator();
int counter = 1;
int twos = 0;
@@ -72,13 +75,13 @@ public class TupleExamplesTest {
assertEquals(ones, 6);
assertEquals(twos, 9);
- //Intersection
+ //Intersection stateful: tuple, theta
final Intersection<IntegerSummary> inter = new Intersection<>(isso);
- inter.update(tupleSk);
- inter.update(thetaSk, ifactory.newSummary().update(1));
+ inter.intersect(tupleSk);
+ inter.intersect(thetaSk, ifactory.newSummary().update(1));
final CompactSketch<IntegerSummary> icsk = inter.getResult();
entries = icsk.getRetainedEntries();
- println("Intersection: " + entries);
+ println("Intersection Stateful: tuple, theta: " + entries);
final SketchIterator<IntegerSummary> iiter = icsk.iterator();
counter = 1;
while (iiter.next()) {
@@ -89,6 +92,93 @@ public class TupleExamplesTest {
}
@Test
+ public void example2() {
+ //Load source sketches
+ final UpdatableSketch<Integer, IntegerSummary> tupleSk1 = tupleBldr.build();
+ final UpdatableSketch<Integer, IntegerSummary> tupleSk2 = tupleBldr.build();
+
+ for (int i = 1; i <= 12; i++) {
+ tupleSk1.update(i, 1);
+ tupleSk2.update(i + 3, 1);
+ }
+
+ //Union, stateless: tuple1, tuple2
+ final Union<IntegerSummary> union = new Union<>(isso);
+ final CompactSketch<IntegerSummary> ucsk = union.union(tupleSk1, tupleSk2);
+ int entries = ucsk.getRetainedEntries();
+ println("Union: " + entries);
+ final SketchIterator<IntegerSummary> uiter = ucsk.iterator();
+ int counter = 1;
+ int twos = 0;
+ int ones = 0;
+ while (uiter.next()) {
+ final int i = uiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 2, 6 entries = 1
+ if (i == 1) { ones++; }
+ if (i == 2) { twos++; }
+ }
+ assertEquals(ones, 6);
+ assertEquals(twos, 9);
+
+ //Intersection stateless: tuple1, tuple2
+ final Intersection<IntegerSummary> inter = new Intersection<>(isso);
+ final CompactSketch<IntegerSummary> icsk = inter.intersect(tupleSk1, tupleSk2);
+ entries = icsk.getRetainedEntries();
+ println("Intersection: " + entries);
+ final SketchIterator<IntegerSummary> iiter = icsk.iterator();
+ counter = 1;
+ while (iiter.next()) {
+ final int i = iiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 2
+ assertEquals(i, 1);
+ }
+ }
+
+ @Test
+ public void example3() {
+ //Load source sketches
+ final UpdatableSketch<Integer, IntegerSummary> tupleSk = tupleBldr.build();
+ final UpdateSketch thetaSk = thetaBldr.build();
+ for (int i = 1; i <= 12; i++) {
+ tupleSk.update(i, 1);
+ thetaSk.update(i + 3);
+ }
+
+ //Union, stateless: tuple1, tuple2
+ final Union<IntegerSummary> union = new Union<>(isso);
+ final CompactSketch<IntegerSummary> ucsk =
+ union.union(tupleSk, thetaSk, ufactory.newSummary().update(1));
+ int entries = ucsk.getRetainedEntries();
+ println("Union: " + entries);
+ final SketchIterator<IntegerSummary> uiter = ucsk.iterator();
+ int counter = 1;
+ int twos = 0;
+ int ones = 0;
+ while (uiter.next()) {
+ final int i = uiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 2, 6 entries = 1
+ if (i == 1) { ones++; }
+ if (i == 2) { twos++; }
+ }
+ assertEquals(ones, 6);
+ assertEquals(twos, 9);
+
+ //Intersection stateless: tuple1, tuple2
+ final Intersection<IntegerSummary> inter = new Intersection<>(isso);
+ final CompactSketch<IntegerSummary> icsk =
+ inter.intersect(tupleSk, thetaSk, ufactory.newSummary().update(1));
+ entries = icsk.getRetainedEntries();
+ println("Intersection: " + entries);
+ final SketchIterator<IntegerSummary> iiter = icsk.iterator();
+ counter = 1;
+ while (iiter.next()) {
+ final int i = iiter.getSummary().getValue();
+ println(counter++ + ", " + i); //9 entries = 2
+ assertEquals(i, 1);
+ }
+ }
+
+ @Test
public void printlnTest() {
println("PRINTING: "+this.getClass().getName());
}
diff --git a/src/test/java/org/apache/datasketches/tuple/adouble/AdoubleIntersectionTest.java b/src/test/java/org/apache/datasketches/tuple/adouble/AdoubleIntersectionTest.java
index 4dc75f7..d6f67b9 100644
--- a/src/test/java/org/apache/datasketches/tuple/adouble/AdoubleIntersectionTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/adouble/AdoubleIntersectionTest.java
@@ -45,14 +45,14 @@ public class AdoubleIntersectionTest {
@Test
public void intersectionNotEmptyNoEntries() {
- UpdatableSketch<Double, DoubleSummary> sketch1 =
+ final UpdatableSketch<Double, DoubleSummary> sketch1 =
new UpdatableSketchBuilder<>
(new DoubleSummaryFactory(mode)).setSamplingProbability(0.01f).build();
sketch1.update("a", 1.0); // this happens to get rejected because of sampling with low probability
- Intersection<DoubleSummary> intersection =
+ final Intersection<DoubleSummary> intersection =
new Intersection<>(new DoubleSummarySetOperations(mode, mode));
- intersection.update(sketch1);
- CompactSketch<DoubleSummary> result = intersection.getResult();
+ intersection.intersect(sketch1);
+ final CompactSketch<DoubleSummary> result = intersection.getResult();
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertFalse(result.isEmpty());
Assert.assertEquals(result.getEstimate(), 0.0);
@@ -62,19 +62,19 @@ public class AdoubleIntersectionTest {
@Test
public void intersectionExactWithEmpty() {
- UpdatableSketch<Double, DoubleSummary> sketch1 =
+ final UpdatableSketch<Double, DoubleSummary> sketch1 =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).build();
sketch1.update(1, 1.0);
sketch1.update(2, 1.0);
sketch1.update(3, 1.0);
- Sketch<DoubleSummary> sketch2 = Sketches.createEmptySketch();
+ final Sketch<DoubleSummary> sketch2 = Sketches.createEmptySketch();
- Intersection<DoubleSummary> intersection =
+ final Intersection<DoubleSummary> intersection =
new Intersection<>(new DoubleSummarySetOperations(mode, mode));
- intersection.update(sketch1);
- intersection.update(sketch2);
- CompactSketch<DoubleSummary> result = intersection.getResult();
+ intersection.intersect(sketch1);
+ intersection.intersect(sketch2);
+ final CompactSketch<DoubleSummary> result = intersection.getResult();
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertTrue(result.isEmpty());
Assert.assertEquals(result.getEstimate(), 0.0);
@@ -92,24 +92,24 @@ public class AdoubleIntersectionTest {
sketch1.update(2, 1.0);
sketch1.update(2, 1.0);
- UpdatableSketch<Double, DoubleSummary> sketch2 =
+ final UpdatableSketch<Double, DoubleSummary> sketch2 =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).build();
sketch2.update(2, 1.0);
sketch2.update(2, 1.0);
sketch2.update(3, 1.0);
sketch2.update(3, 1.0);
- Intersection<DoubleSummary> intersection =
+ final Intersection<DoubleSummary> intersection =
new Intersection<>(new DoubleSummarySetOperations(mode, mode));
intersection.update(sketch1);
intersection.update(sketch2);
- CompactSketch<DoubleSummary> result = intersection.getResult();
+ final CompactSketch<DoubleSummary> result = intersection.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();
+ final SketchIterator<DoubleSummary> it = result.iterator();
Assert.assertTrue(it.next());
Assert.assertTrue(it.getHash() > 0);
Assert.assertTrue(it.getKey() > 0);
@@ -119,29 +119,29 @@ public class AdoubleIntersectionTest {
intersection.reset();
sketch1 = null;
try { intersection.update(sketch1); fail();}
- catch (SketchesArgumentException e) { }
+ catch (final SketchesArgumentException e) { }
}
@Test
public void intersectionDisjointEstimationMode() {
int key = 0;
- UpdatableSketch<Double, DoubleSummary> sketch1 =
+ final UpdatableSketch<Double, DoubleSummary> sketch1 =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).build();
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, 1.0);
}
- UpdatableSketch<Double, DoubleSummary> sketch2 =
+ final UpdatableSketch<Double, DoubleSummary> sketch2 =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).build();
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, 1.0);
}
- Intersection<DoubleSummary> intersection =
+ final Intersection<DoubleSummary> intersection =
new Intersection<>(new DoubleSummarySetOperations(mode, mode));
- intersection.update(sketch1);
- intersection.update(sketch2);
+ intersection.intersect(sketch1);
+ intersection.intersect(sketch2);
CompactSketch<DoubleSummary> result = intersection.getResult();
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertFalse(result.isEmpty());
@@ -150,7 +150,7 @@ public class AdoubleIntersectionTest {
Assert.assertTrue(result.getUpperBound(1) > 0);
// an intersection with no entries must survive more updates
- intersection.update(sketch1);
+ intersection.intersect(sketch1);
result = intersection.getResult();
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertFalse(result.isEmpty());
@@ -162,30 +162,30 @@ public class AdoubleIntersectionTest {
@Test
public void intersectionEstimationMode() {
int key = 0;
- UpdatableSketch<Double, DoubleSummary> sketch1 =
+ final UpdatableSketch<Double, DoubleSummary> sketch1 =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).build();
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, 1.0);
}
key -= 4096; // overlap half of the entries
- UpdatableSketch<Double, DoubleSummary> sketch2 =
+ final UpdatableSketch<Double, DoubleSummary> sketch2 =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).build();
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, 1.0);
}
- Intersection<DoubleSummary> intersection =
+ final Intersection<DoubleSummary> intersection =
new Intersection<>(new DoubleSummarySetOperations(mode, mode));
- intersection.update(sketch1);
- intersection.update(sketch2);
- CompactSketch<DoubleSummary> result = intersection.getResult();
+ intersection.intersect(sketch1);
+ intersection.intersect(sketch2);
+ final 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();
+ final SketchIterator<DoubleSummary> it = result.iterator();
while (it.next()) {
Assert.assertEquals(it.getSummary().getValue(), 2.0);
}
@@ -193,71 +193,71 @@ public class AdoubleIntersectionTest {
@Test
public void checkExactIntersectionWithTheta() {
- UpdateSketch thSkNull = null;
- UpdateSketch thSkEmpty = new UpdateSketchBuilder().build();
- UpdateSketch thSk10 = new UpdateSketchBuilder().build();
- UpdateSketch thSk15 = new UpdateSketchBuilder().build();
+ final UpdateSketch thSkNull = null;
+ final UpdateSketch thSkEmpty = new UpdateSketchBuilder().build();
+ final UpdateSketch thSk10 = new UpdateSketchBuilder().build();
+ final UpdateSketch thSk15 = new UpdateSketchBuilder().build();
for (int i = 0; i < 10; i++) { thSk10.update(i); }
for (int i = 0; i < 10; i++) { thSk15.update(i + 5); } //overlap = 5
DoubleSummary dsum = new DoubleSummaryFactory(mode).newSummary();
- Intersection<DoubleSummary> intersection =
+ final Intersection<DoubleSummary> intersection =
new Intersection<>(new DoubleSummarySetOperations(mode, mode));
CompactSketch<DoubleSummary> result;
try { intersection.getResult(); fail(); }
- catch (SketchesStateException e ) { } //OK.
+ catch (final SketchesStateException e ) { } //OK.
- try { intersection.update(thSkNull, dsum); fail(); }
- catch (SketchesArgumentException e) { } //OK
+ try { intersection.intersect(thSkNull, dsum); fail(); }
+ catch (final SketchesArgumentException e) { } //OK
- intersection.update(thSkEmpty, dsum);
+ intersection.intersect(thSkEmpty, dsum);
result = intersection.getResult();
Assert.assertTrue(result.isEmpty()); //Empty after empty first call
intersection.reset();
- intersection.update(thSk10, dsum);
+ intersection.intersect(thSk10, dsum);
result = intersection.getResult();
Assert.assertEquals(result.getEstimate(), 10.0); //Returns valid first call
intersection.reset();
- intersection.update(thSk10, dsum); // Valid first call
- intersection.update(thSkEmpty, dsum);
+ intersection.intersect(thSk10, dsum); // Valid first call
+ intersection.intersect(thSkEmpty, dsum);
result = intersection.getResult();
Assert.assertTrue(result.isEmpty()); //Returns Empty after empty second call
intersection.reset();
- intersection.update(thSk10, dsum);
- intersection.update(thSk15, dsum);
+ intersection.intersect(thSk10, dsum);
+ intersection.intersect(thSk15, dsum);
result = intersection.getResult();
Assert.assertEquals(result.getEstimate(), 5.0); //Returns intersection
intersection.reset();
dsum = null;
- try { intersection.update(thSk10, dsum); fail(); }
- catch (SketchesArgumentException e) { }
+ try { intersection.intersect(thSk10, dsum); fail(); }
+ catch (final SketchesArgumentException e) { }
}
@Test
public void checkExactIntersectionWithThetaDisjoint() {
- UpdateSketch thSkA = new UpdateSketchBuilder().setLogNominalEntries(10).build();
- UpdateSketch thSkB = new UpdateSketchBuilder().setLogNominalEntries(10).build();
+ final UpdateSketch thSkA = new UpdateSketchBuilder().setLogNominalEntries(10).build();
+ final UpdateSketch thSkB = new UpdateSketchBuilder().setLogNominalEntries(10).build();
int key = 0;
for (int i = 0; i < 32; i++) { thSkA.update(key++); }
for (int i = 0; i < 32; i++) { thSkB.update(key++); }
- DoubleSummary dsum = new DoubleSummaryFactory(mode).newSummary();
- Intersection<DoubleSummary> intersection =
+ final DoubleSummary dsum = new DoubleSummaryFactory(mode).newSummary();
+ final Intersection<DoubleSummary> intersection =
new Intersection<>(new DoubleSummarySetOperations(mode, mode));
CompactSketch<DoubleSummary> result;
- intersection.update(thSkA, dsum);
- intersection.update(thSkB, dsum);
+ intersection.intersect(thSkA, dsum);
+ intersection.intersect(thSkB, dsum);
result = intersection.getResult();
Assert.assertEquals(result.getRetainedEntries(), 0);
// an intersection with no entries must survive more updates
- intersection.update(thSkA, dsum);
+ intersection.intersect(thSkA, dsum);
result = intersection.getResult();
Assert.assertEquals(result.getRetainedEntries(), 0);
intersection.reset();
@@ -265,39 +265,39 @@ public class AdoubleIntersectionTest {
@Test
public void checkEstimatingIntersectionWithThetaOverlapping() {
- UpdateSketch thSkA = new UpdateSketchBuilder().setLogNominalEntries(4).build();
- UpdateSketch thSkB = new UpdateSketchBuilder().setLogNominalEntries(10).build();
+ final UpdateSketch thSkA = new UpdateSketchBuilder().setLogNominalEntries(4).build();
+ final UpdateSketch thSkB = new UpdateSketchBuilder().setLogNominalEntries(10).build();
for (int i = 0; i < 64; i++) { thSkA.update(i); } //dense mode, low theta
for (int i = 32; i < 96; i++) { thSkB.update(i); } //exact overlapping
- DoubleSummary dsum = new DoubleSummaryFactory(mode).newSummary();
- Intersection<DoubleSummary> intersection =
+ final DoubleSummary dsum = new DoubleSummaryFactory(mode).newSummary();
+ final Intersection<DoubleSummary> intersection =
new Intersection<>(new DoubleSummarySetOperations(mode, mode));
CompactSketch<DoubleSummary> result;
- intersection.update(thSkA, dsum);
- intersection.update(thSkB, dsum);
+ intersection.intersect(thSkA, dsum);
+ intersection.intersect(thSkB, dsum);
result = intersection.getResult();
Assert.assertEquals(result.getRetainedEntries(), 14);
thSkB.reset();
for (int i = 100; i < 164; i++) { thSkB.update(i); } //exact, disjoint
- intersection.update(thSkB, dsum); //remove existing entries
+ intersection.intersect(thSkB, dsum); //remove existing entries
result = intersection.getResult();
Assert.assertEquals(result.getRetainedEntries(), 0);
- intersection.update(thSkB, dsum);
+ intersection.intersect(thSkB, dsum);
result = intersection.getResult();
Assert.assertEquals(result.getRetainedEntries(), 0);
}
@Test
public void intersectionEmpty() {
- UpdatableSketch<Double, DoubleSummary> sketch =
+ final UpdatableSketch<Double, DoubleSummary> sketch =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).build();
- Intersection<DoubleSummary> intersection =
+ final Intersection<DoubleSummary> intersection =
new Intersection<>(new DoubleSummarySetOperations(mode, mode));
- intersection.update(sketch);
- CompactSketch<DoubleSummary> result = intersection.getResult();
+ intersection.intersect(sketch);
+ final CompactSketch<DoubleSummary> result = intersection.getResult();
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertTrue(result.isEmpty());
Assert.assertEquals(result.getEstimate(), 0.0);
diff --git a/src/test/java/org/apache/datasketches/tuple/adouble/AdoubleUnionTest.java b/src/test/java/org/apache/datasketches/tuple/adouble/AdoubleUnionTest.java
index 9aa89c6..de2721e 100644
--- a/src/test/java/org/apache/datasketches/tuple/adouble/AdoubleUnionTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/adouble/AdoubleUnionTest.java
@@ -42,14 +42,14 @@ public class AdoubleUnionTest {
@Test
public void unionEmptySampling() {
- UpdatableSketch<Double, DoubleSummary> sketch =
+ final UpdatableSketch<Double, DoubleSummary> sketch =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).setSamplingProbability(0.01f).build();
sketch.update(1, 1.0);
Assert.assertEquals(sketch.getRetainedEntries(), 0); // not retained due to low sampling probability
- Union<DoubleSummary> union = new Union<>(new DoubleSummarySetOperations(mode, mode));
- union.update(sketch);
- CompactSketch<DoubleSummary> result = union.getResult();
+ final Union<DoubleSummary> union = new Union<>(new DoubleSummarySetOperations(mode, mode));
+ union.union(sketch);
+ final CompactSketch<DoubleSummary> result = union.getResult();
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertFalse(result.isEmpty());
Assert.assertTrue(result.isEstimationMode());
@@ -58,14 +58,14 @@ public class AdoubleUnionTest {
@Test
public void unionExactMode() {
- UpdatableSketch<Double, DoubleSummary> sketch1 =
+ final UpdatableSketch<Double, DoubleSummary> sketch1 =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).build();
sketch1.update(1, 1.0);
sketch1.update(1, 1.0);
sketch1.update(1, 1.0);
sketch1.update(2, 1.0);
- UpdatableSketch<Double, DoubleSummary> sketch2 =
+ final UpdatableSketch<Double, DoubleSummary> sketch2 =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).build();
sketch2.update(2, 1.0);
sketch2.update(2, 1.0);
@@ -73,13 +73,13 @@ public class AdoubleUnionTest {
sketch2.update(3, 1.0);
sketch2.update(3, 1.0);
- Union<DoubleSummary> union = new Union<>(new DoubleSummarySetOperations(mode, mode));
- union.update(sketch1);
- union.update(sketch2);
+ final Union<DoubleSummary> union = new Union<>(new DoubleSummarySetOperations(mode, mode));
+ union.union(sketch1);
+ union.union(sketch2);
CompactSketch<DoubleSummary> result = union.getResult();
Assert.assertEquals(result.getEstimate(), 3.0);
- SketchIterator<DoubleSummary> it = result.iterator();
+ final SketchIterator<DoubleSummary> it = result.iterator();
Assert.assertTrue(it.next());
Assert.assertEquals(it.getSummary().getValue(), 3.0);
Assert.assertTrue(it.next());
@@ -102,23 +102,23 @@ public class AdoubleUnionTest {
@Test
public void unionEstimationMode() {
int key = 0;
- UpdatableSketch<Double, DoubleSummary> sketch1 =
+ final UpdatableSketch<Double, DoubleSummary> sketch1 =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).build();
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, 1.0);
}
key -= 4096; // overlap half of the entries
- UpdatableSketch<Double, DoubleSummary> sketch2 =
+ final UpdatableSketch<Double, DoubleSummary> sketch2 =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).build();
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, 1.0);
}
- Union<DoubleSummary> union = new Union<>(4096, new DoubleSummarySetOperations(mode, mode));
- union.update(sketch1);
- union.update(sketch2);
- CompactSketch<DoubleSummary> result = union.getResult();
+ final Union<DoubleSummary> union = new Union<>(4096, new DoubleSummarySetOperations(mode, mode));
+ union.union(sketch1);
+ union.union(sketch2);
+ final 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());
@@ -127,7 +127,7 @@ public class AdoubleUnionTest {
@Test
public void unionMixedMode() {
int key = 0;
- UpdatableSketch<Double, DoubleSummary> sketch1 =
+ final UpdatableSketch<Double, DoubleSummary> sketch1 =
new UpdatableSketchBuilder<>(new DoubleSummaryFactory(mode)).build();
for (int i = 0; i < 1000; i++) {
sketch1.update(key++, 1.0);
@@ -135,7 +135,7 @@ public class AdoubleUnionTest {
}
key -= 500; // overlap half of the entries
- UpdatableSketch<Double, DoubleSummary> sketch2 =
+ final UpdatableSketch<Double, DoubleSummary> sketch2 =
new UpdatableSketchBuilder<>
(new DoubleSummaryFactory(mode)).setSamplingProbability(0.2f).build();
for (int i = 0; i < 20000; i++) {
@@ -143,10 +143,10 @@ public class AdoubleUnionTest {
//System.out.println("theta2=" + sketch2.getTheta() + " " + sketch2.getThetaLong());
}
- Union<DoubleSummary> union = new Union<>(4096, new DoubleSummarySetOperations(mode, mode));
- union.update(sketch1);
- union.update(sketch2);
- CompactSketch<DoubleSummary> result = union.getResult();
+ final Union<DoubleSummary> union = new Union<>(4096, new DoubleSummarySetOperations(mode, mode));
+ union.union(sketch1);
+ union.union(sketch2);
+ final CompactSketch<DoubleSummary> result = union.getResult();
Assert.assertEquals(result.getEstimate(), 20500.0, 20500 * 0.01);
Assert.assertTrue(result.getLowerBound(1) <= result.getEstimate());
Assert.assertTrue(result.getUpperBound(1) > result.getEstimate());
@@ -154,20 +154,20 @@ public class AdoubleUnionTest {
@Test
public void checkUnionUpdateWithTheta() {
- Union<DoubleSummary> union = new Union<>(new DoubleSummarySetOperations(mode, mode));
+ final Union<DoubleSummary> union = new Union<>(new DoubleSummarySetOperations(mode, mode));
UpdateSketch usk = null;
DoubleSummary dsum = null;
- try { union.update(usk, dsum); fail(); }
- catch (SketchesArgumentException e) { }
+ try { union.union(usk, dsum); fail(); }
+ catch (final SketchesArgumentException e) { }
usk = new UpdateSketchBuilder().build();
- try { union.update(usk, dsum); fail(); }
- catch (SketchesArgumentException e) { }
+ try { union.union(usk, dsum); fail(); }
+ catch (final SketchesArgumentException e) { }
dsum = new DoubleSummaryFactory(mode).newSummary();
for (int i = 0; i < 10; i++) { usk.update(i); }
- union.update(usk, dsum);
+ union.union(usk, dsum);
Assert.assertEquals(union.getResult().getEstimate(), 10.0);
}
diff --git a/src/test/java/org/apache/datasketches/tuple/aninteger/EngagementTest.java b/src/test/java/org/apache/datasketches/tuple/aninteger/EngagementTest.java
index 631e688..7ac8c60 100644
--- a/src/test/java/org/apache/datasketches/tuple/aninteger/EngagementTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/aninteger/EngagementTest.java
@@ -39,18 +39,18 @@ public class EngagementTest {
@Test
public void computeEngagementHistogram() {
- int lgK = 8; //Using a larger sketch >= 9 will produce exact results for this little example
- int K = 1 << lgK;
- int days = 30;
+ final int lgK = 8; //Using a larger sketch >= 9 will produce exact results for this little example
+ final int K = 1 << lgK;
+ final int days = 30;
int v = 0;
- IntegerSketch[] skArr = new IntegerSketch[days];
+ final IntegerSketch[] skArr = new IntegerSketch[days];
for (int i = 0; i < days; i++) {
skArr[i] = new IntegerSketch(lgK, AlwaysOne);
}
for (int i = 0; i <= days; i++) { //31 generating indices for symmetry
- int numIds = numIDs(days, i);
- int numDays = numDays(days, i);
- int myV = v++;
+ final int numIds = numIDs(days, i);
+ final int numDays = numDays(days, i);
+ final int myV = v++;
for (int d = 0; d < numDays; d++) {
for (int id = 0; id < numIds; id++) {
skArr[d].update(myV + id, 1);
@@ -61,34 +61,34 @@ public class EngagementTest {
unionOps(K, Sum, skArr);
}
- private static int numIDs(int totalDays, int index) {
- double d = totalDays;
- double i = index;
- return (int)(round(exp((i * log(d)) / d)));
+ private static int numIDs(final int totalDays, final int index) {
+ final double d = totalDays;
+ final double i = index;
+ return (int)round(exp(i * log(d) / d));
}
- private static int numDays(int totalDays, int index) {
- double d = totalDays;
- double i = index;
- return (int)(round(exp(((d - i) * log(d)) / d)));
+ private static int numDays(final int totalDays, final int index) {
+ final double d = totalDays;
+ final double i = index;
+ return (int)round(exp((d - i) * log(d) / d));
}
- private static void unionOps(int K, IntegerSummary.Mode mode, IntegerSketch ... sketches) {
- IntegerSummarySetOperations setOps = new IntegerSummarySetOperations(mode, mode);
- Union<IntegerSummary> union = new Union<>(K, setOps);
- int len = sketches.length;
+ private static void unionOps(final int K, final IntegerSummary.Mode mode, final IntegerSketch ... sketches) {
+ final IntegerSummarySetOperations setOps = new IntegerSummarySetOperations(mode, mode);
+ final Union<IntegerSummary> union = new Union<>(K, setOps);
+ final int len = sketches.length;
- for (IntegerSketch isk : sketches) {
- union.update(isk);
+ for (final IntegerSketch isk : sketches) {
+ union.union(isk);
}
- CompactSketch<IntegerSummary> result = union.getResult();
- SketchIterator<IntegerSummary> itr = result.iterator();
+ final CompactSketch<IntegerSummary> result = union.getResult();
+ final SketchIterator<IntegerSummary> itr = result.iterator();
- int[] numDaysArr = new int[len + 1]; //zero index is ignored
+ final int[] numDaysArr = new int[len + 1]; //zero index is ignored
while (itr.next()) {
//For each unique visitor from the result sketch, get the # days visited
- int numDaysVisited = itr.getSummary().getValue();
+ final int numDaysVisited = itr.getSummary().getValue();
//increment the number of visitors that visited numDays
numDaysArr[numDaysVisited]++; //values range from 1 to 30
}
@@ -97,40 +97,40 @@ public class EngagementTest {
println("Number of Unique Visitors by Number of Days Visited");
printf("%12s%12s%12s%12s\n","Days Visited", "Estimate", "LB", "UB");
int sumVisits = 0;
- double theta = result.getTheta();
+ final double theta = result.getTheta();
for (int i = 0; i < numDaysArr.length; i++) {
- int visitorsAtDaysVisited = numDaysArr[i];
+ final int visitorsAtDaysVisited = numDaysArr[i];
if (visitorsAtDaysVisited == 0) { continue; }
sumVisits += visitorsAtDaysVisited * i;
- double estVisitorsAtDaysVisited = visitorsAtDaysVisited / theta;
- double lbVisitorsAtDaysVisited = result.getLowerBound(numStdDev, visitorsAtDaysVisited);
- double ubVisitorsAtDaysVisited = result.getUpperBound(numStdDev, visitorsAtDaysVisited);
+ final double estVisitorsAtDaysVisited = visitorsAtDaysVisited / theta;
+ final double lbVisitorsAtDaysVisited = result.getLowerBound(numStdDev, visitorsAtDaysVisited);
+ final double ubVisitorsAtDaysVisited = result.getUpperBound(numStdDev, visitorsAtDaysVisited);
printf("%12d%12.0f%12.0f%12.0f\n",
i, estVisitorsAtDaysVisited, lbVisitorsAtDaysVisited, ubVisitorsAtDaysVisited);
}
//The estimate and bounds of the total number of visitors comes directly from the sketch.
- double visitors = result.getEstimate();
- double lbVisitors = result.getLowerBound(numStdDev);
- double ubVisitors = result.getUpperBound(numStdDev);
+ final double visitors = result.getEstimate();
+ final double lbVisitors = result.getLowerBound(numStdDev);
+ final double ubVisitors = result.getUpperBound(numStdDev);
printf("\n%12s%12s%12s%12s\n","Totals", "Estimate", "LB", "UB");
printf("%12s%12.0f%12.0f%12.0f\n", "Visitors", visitors, lbVisitors, ubVisitors);
//The total number of visits, however, is a scaled metric and takes advantage of the fact that
//the retained entries in the sketch is a uniform random sample of all unique visitors, and
//the the rest of the unique users will likely behave in the same way.
- double estVisits = sumVisits / theta;
- double lbVisits = (estVisits * lbVisitors) / visitors;
- double ubVisits = (estVisits * ubVisitors) / visitors;
+ final double estVisits = sumVisits / theta;
+ final double lbVisits = estVisits * lbVisitors / visitors;
+ final double ubVisits = estVisits * ubVisitors / visitors;
printf("%12s%12.0f%12.0f%12.0f\n\n", "Visits", estVisits, lbVisits, ubVisits);
}
/**
* @param o object to print
*/
- private static void println(Object o) {
+ private static void println(final Object o) {
printf("%s\n", o.toString());
}
@@ -138,7 +138,7 @@ public class EngagementTest {
* @param fmt format
* @param args arguments
*/
- private static void printf(String fmt, Object ... args) {
+ private static void printf(final String fmt, final Object ... args) {
//System.out.printf(fmt, args); //Enable/Disable printing here
}
}
diff --git a/src/test/java/org/apache/datasketches/tuple/aninteger/IntegerSketchTest.java b/src/test/java/org/apache/datasketches/tuple/aninteger/IntegerSketchTest.java
index 422cdaf..d12339c 100644
--- a/src/test/java/org/apache/datasketches/tuple/aninteger/IntegerSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/aninteger/IntegerSketchTest.java
@@ -35,87 +35,87 @@ public class IntegerSketchTest {
@Test
public void serDeTest() {
- int lgK = 12;
- int K = 1 << lgK;
- IntegerSummary.Mode a1Mode = IntegerSummary.Mode.AlwaysOne;
- IntegerSketch a1Sk = new IntegerSketch(lgK, a1Mode);
- int m = 2 * K;
+ final int lgK = 12;
+ final int K = 1 << lgK;
+ final IntegerSummary.Mode a1Mode = IntegerSummary.Mode.AlwaysOne;
+ final IntegerSketch a1Sk = new IntegerSketch(lgK, a1Mode);
+ final int m = 2 * K;
for (int i = 0; i < m; i++) {
a1Sk.update(i, 1);
}
- double est1 = a1Sk.getEstimate();
- Memory mem = Memory.wrap(a1Sk.toByteArray());
- IntegerSketch a1Sk2 = new IntegerSketch(mem, a1Mode);
- double est2 = a1Sk2.getEstimate();
+ final double est1 = a1Sk.getEstimate();
+ final Memory mem = Memory.wrap(a1Sk.toByteArray());
+ final IntegerSketch a1Sk2 = new IntegerSketch(mem, a1Mode);
+ final double est2 = a1Sk2.getEstimate();
assertEquals(est1, est2);
}
@Test
public void intersectTest() {
- int lgK = 12;
- int K = 1 << lgK;
- IntegerSummary.Mode a1Mode = IntegerSummary.Mode.AlwaysOne;
- IntegerSketch a1Sk1 = new IntegerSketch(lgK, a1Mode);
- IntegerSketch a1Sk2 = new IntegerSketch(lgK, a1Mode);
- int m = 2 * K;
+ final int lgK = 12;
+ final int K = 1 << lgK;
+ final IntegerSummary.Mode a1Mode = IntegerSummary.Mode.AlwaysOne;
+ final IntegerSketch a1Sk1 = new IntegerSketch(lgK, a1Mode);
+ final IntegerSketch a1Sk2 = new IntegerSketch(lgK, a1Mode);
+ final int m = 2 * K;
for (int i = 0; i < m; i++) {
a1Sk1.update(i, 1);
- a1Sk2.update(i + (m/2), 1);
+ a1Sk2.update(i + m/2, 1);
}
- Intersection<IntegerSummary> inter =
+ final Intersection<IntegerSummary> inter =
new Intersection<>(new IntegerSummarySetOperations(a1Mode, a1Mode));
- inter.update(a1Sk1);
- inter.update(a1Sk2);
- CompactSketch<IntegerSummary> csk = inter.getResult();
+ inter.intersect(a1Sk1);
+ inter.intersect(a1Sk2);
+ final CompactSketch<IntegerSummary> csk = inter.getResult();
assertEquals(csk.getEstimate(), K * 1.0, K * .03);
}
@SuppressWarnings("deprecation")
@Test
public void aNotBTest() {
- int lgK = 4;
- int u = 5;
- IntegerSummary.Mode a1Mode = IntegerSummary.Mode.AlwaysOne;
- IntegerSketch a1Sk1 = new IntegerSketch(lgK, a1Mode);
- IntegerSketch a1Sk2 = null;//new IntegerSketch(lgK, a1Mode);
- AnotB<IntegerSummary> anotb = new AnotB<>();
+ final int lgK = 4;
+ final int u = 5;
+ final IntegerSummary.Mode a1Mode = IntegerSummary.Mode.AlwaysOne;
+ final IntegerSketch a1Sk1 = new IntegerSketch(lgK, a1Mode);
+ final IntegerSketch a1Sk2 = null;//new IntegerSketch(lgK, a1Mode);
+ final AnotB<IntegerSummary> anotb = new AnotB<>();
for (int i = 0; i < u; i++) {
a1Sk1.update(i, 1);
}
anotb.update(a1Sk1, a1Sk2);
- CompactSketch<IntegerSummary> cSk = anotb.getResult();
+ final CompactSketch<IntegerSummary> cSk = anotb.getResult();
assertEquals((int)cSk.getEstimate(), u);
}
@Test
public void checkMinMaxMode() {
- int lgK = 12;
- int K = 1 << lgK;
- IntegerSummary.Mode minMode = IntegerSummary.Mode.Min;
- IntegerSummary.Mode maxMode = IntegerSummary.Mode.Max;
- IntegerSketch a1Sk1 = new IntegerSketch(lgK, minMode);
- IntegerSketch a1Sk2 = new IntegerSketch(lgK, maxMode);
- int m = K / 2;
+ final int lgK = 12;
+ final int K = 1 << lgK;
+ final IntegerSummary.Mode minMode = IntegerSummary.Mode.Min;
+ final IntegerSummary.Mode maxMode = IntegerSummary.Mode.Max;
+ final IntegerSketch a1Sk1 = new IntegerSketch(lgK, minMode);
+ final IntegerSketch a1Sk2 = new IntegerSketch(lgK, maxMode);
+ final int m = K / 2;
for (int key = 0; key < m; key++) {
a1Sk1.update(key, 1);
a1Sk1.update(key, 0);
a1Sk1.update(key, 2);
- a1Sk2.update(key + (m/2), 1);
- a1Sk2.update(key + (m/2), 0);
- a1Sk2.update(key + (m/2), 2);
+ a1Sk2.update(key + m/2, 1);
+ a1Sk2.update(key + m/2, 0);
+ a1Sk2.update(key + m/2, 2);
}
- double est1 = a1Sk1.getEstimate();
- double est2 = a1Sk2.getEstimate();
+ final double est1 = a1Sk1.getEstimate();
+ final double est2 = a1Sk2.getEstimate();
assertEquals(est1, est2);
}
@Test
public void checkStringKey() {
- int lgK = 12;
- int K = 1 << lgK;
- IntegerSummary.Mode a1Mode = IntegerSummary.Mode.AlwaysOne;
- IntegerSketch a1Sk1 = new IntegerSketch(lgK, a1Mode);
- int m = K / 2;
+ final int lgK = 12;
+ final int K = 1 << lgK;
+ final IntegerSummary.Mode a1Mode = IntegerSummary.Mode.AlwaysOne;
+ final IntegerSketch a1Sk1 = new IntegerSketch(lgK, a1Mode);
+ final int m = K / 2;
for (int key = 0; key < m; key++) {
a1Sk1.update(Integer.toHexString(key), 1);
}
@@ -125,7 +125,7 @@ public class IntegerSketchTest {
/**
* @param o object to print
*/
- static void println(Object o) {
+ static void println(final Object o) {
//System.out.println(o.toString()); //Disable
}
@@ -133,7 +133,7 @@ public class IntegerSketchTest {
* @param fmt format
* @param args arguments
*/
- static void printf(String fmt, Object ... args) {
+ static void printf(final String fmt, final Object ... args) {
//System.out.printf(fmt, args); //Disable
}
}
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersectionTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersectionTest.java
index 67f0319..802ee7d 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersectionTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersectionTest.java
@@ -26,9 +26,11 @@ import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class ArrayOfDoublesIntersectionTest {
+
private static ArrayOfDoublesCombiner combiner = new ArrayOfDoublesCombiner() {
+
@Override
- public double[] combine(double[] a, double[] b) {
+ public double[] combine(final double[] a, final double[] b) {
for (int i = 0; i < a.length; i++) {
a[i] += b[i];
}
@@ -38,9 +40,9 @@ public class ArrayOfDoublesIntersectionTest {
@Test
public void nullInput() {
- ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
- intersection.update(null, null);
- ArrayOfDoublesCompactSketch result = intersection.getResult();
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
+ intersection.intersect(null, null);
+ final ArrayOfDoublesCompactSketch result = intersection.getResult();
Assert.assertTrue(result.isEmpty());
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertEquals(result.getEstimate(), 0.0);
@@ -51,10 +53,10 @@ public class ArrayOfDoublesIntersectionTest {
@Test
public void empty() {
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
- ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
- intersection.update(sketch1, null);
- ArrayOfDoublesCompactSketch result = intersection.getResult();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
+ intersection.intersect(sketch1, null);
+ final ArrayOfDoublesCompactSketch result = intersection.getResult();
Assert.assertTrue(result.isEmpty());
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertEquals(result.getEstimate(), 0.0);
@@ -65,11 +67,11 @@ public class ArrayOfDoublesIntersectionTest {
@Test
public void notEmptyNoEntries() {
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setSamplingProbability(0.01f).build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setSamplingProbability(0.01f).build();
sketch1.update("a", new double[] {1}); // this happens to get rejected because of sampling with low probability
- ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
- intersection.update(sketch1, null);
- ArrayOfDoublesCompactSketch result = intersection.getResult();
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
+ intersection.intersect(sketch1, null);
+ final ArrayOfDoublesCompactSketch result = intersection.getResult();
Assert.assertTrue(result.isEmpty());
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertEquals(result.getEstimate(), 0.0);
@@ -80,17 +82,17 @@ public class ArrayOfDoublesIntersectionTest {
@Test
public void heapExactWithEmpty() {
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
sketch1.update(1, new double[] {1});
sketch1.update(2, new double[] {1});
sketch1.update(3, new double[] {1});
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
- ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
- intersection.update(sketch1, null);
- intersection.update(sketch2, null);
- ArrayOfDoublesCompactSketch result = intersection.getResult();
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
+ intersection.intersect(sketch1, null);
+ intersection.intersect(sketch2, null);
+ final ArrayOfDoublesCompactSketch result = intersection.getResult();
Assert.assertTrue(result.isEmpty());
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertEquals(result.getEstimate(), 0.0);
@@ -100,20 +102,20 @@ public class ArrayOfDoublesIntersectionTest {
@Test
public void directExactWithEmpty() {
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder()
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder()
.build(WritableMemory.wrap(new byte[1000000]));
sketch1.update(1, new double[] {1});
sketch1.update(2, new double[] {1});
sketch1.update(3, new double[] {1});
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder()
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder()
.build(WritableMemory.wrap(new byte[1000000]));
- ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().
buildIntersection(WritableMemory.wrap(new byte[1000000]));
- intersection.update(sketch1, null);
- intersection.update(sketch2, null);
- ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.wrap(new byte[1000000]));
+ intersection.intersect(sketch1, null);
+ intersection.intersect(sketch2, null);
+ final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.wrap(new byte[1000000]));
Assert.assertTrue(result.isEmpty());
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertEquals(result.getEstimate(), 0.0);
@@ -123,34 +125,34 @@ public class ArrayOfDoublesIntersectionTest {
@Test
public void heapExactMode() {
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
sketch1.update(1, new double[] {1});
sketch1.update(1, new double[] {1});
sketch1.update(2, new double[] {1});
sketch1.update(2, new double[] {1});
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
sketch2.update(2, new double[] {1});
sketch2.update(2, new double[] {1});
sketch2.update(3, new double[] {1});
sketch2.update(3, new double[] {1});
- ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
- intersection.update(sketch1, combiner);
- intersection.update(sketch2, combiner);
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
+ intersection.intersect(sketch1, combiner);
+ intersection.intersect(sketch2, combiner);
ArrayOfDoublesCompactSketch result = intersection.getResult();
Assert.assertFalse(result.isEmpty());
Assert.assertEquals(result.getRetainedEntries(), 1);
Assert.assertEquals(result.getEstimate(), 1.0);
Assert.assertEquals(result.getLowerBound(1), 1.0);
Assert.assertEquals(result.getUpperBound(1), 1.0);
- double[][] values = result.getValues();
+ final double[][] values = result.getValues();
for (int i = 0; i < values.length; i++) {
Assert.assertEquals(values[i][0], 4.0);
}
intersection.reset();
- intersection.update(null, null);
+ intersection.intersect(null, null);
result = intersection.getResult();
Assert.assertTrue(result.isEmpty());
Assert.assertEquals(result.getRetainedEntries(), 0);
@@ -162,20 +164,20 @@ public class ArrayOfDoublesIntersectionTest {
@Test
public void heapDisjointEstimationMode() {
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
- ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
- intersection.update(sketch1, combiner);
- intersection.update(sketch2, combiner);
- ArrayOfDoublesCompactSketch result = intersection.getResult();
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
+ intersection.intersect(sketch1, combiner);
+ intersection.intersect(sketch2, combiner);
+ final ArrayOfDoublesCompactSketch result = intersection.getResult();
Assert.assertTrue(result.isEmpty());
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertEquals(result.getEstimate(), 0.0);
@@ -187,23 +189,23 @@ public class ArrayOfDoublesIntersectionTest {
@Test
public void directDisjointEstimationMode() {
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().
build(WritableMemory.wrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().
build(WritableMemory.wrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
- ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().
buildIntersection(WritableMemory.wrap(new byte[1000000]));
- intersection.update(sketch1, combiner);
- intersection.update(sketch2, combiner);
- ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.wrap(new byte[1000000]));
+ intersection.intersect(sketch1, combiner);
+ intersection.intersect(sketch2, combiner);
+ final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.wrap(new byte[1000000]));
Assert.assertTrue(result.isEmpty());
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertEquals(result.getEstimate(), 0.0);
@@ -215,26 +217,26 @@ public class ArrayOfDoublesIntersectionTest {
@Test
public void heapEstimationMode() {
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 4096; // overlap half of the entries
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
- ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
- intersection.update(sketch1, combiner);
- intersection.update(sketch2, combiner);
- ArrayOfDoublesCompactSketch result = intersection.getResult();
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection();
+ intersection.intersect(sketch1, combiner);
+ intersection.intersect(sketch2, combiner);
+ final ArrayOfDoublesCompactSketch result = intersection.getResult();
Assert.assertFalse(result.isEmpty());
Assert.assertEquals(result.getEstimate(), 4096.0, 4096 * 0.03); // crude estimate of RSE(95%) = 2 / sqrt(result.getRetainedEntries())
Assert.assertTrue(result.getLowerBound(1) <= result.getEstimate());
Assert.assertTrue(result.getUpperBound(1) > result.getEstimate());
- double[][] values = result.getValues();
+ final double[][] values = result.getValues();
for (int i = 0; i < values.length; i++) {
Assert.assertEquals(values[i][0], 2.0);
}
@@ -243,26 +245,26 @@ public class ArrayOfDoublesIntersectionTest {
@Test
public void directEstimationMode() {
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 4096; // overlap half of the entries
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
- ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection(WritableMemory.wrap(new byte[1000000]));
- intersection.update(sketch1, combiner);
- intersection.update(sketch2, combiner);
- ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection(WritableMemory.wrap(new byte[1000000]));
+ intersection.intersect(sketch1, combiner);
+ intersection.intersect(sketch2, combiner);
+ final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.wrap(new byte[1000000]));
Assert.assertFalse(result.isEmpty());
Assert.assertEquals(result.getEstimate(), 4096.0, 4096 * 0.03); // crude estimate of RSE(95%) = 2 / sqrt(result.getRetainedEntries())
Assert.assertTrue(result.getLowerBound(1) <= result.getEstimate());
Assert.assertTrue(result.getUpperBound(1) > result.getEstimate());
- double[][] values = result.getValues();
+ final double[][] values = result.getValues();
for (int i = 0; i < values.length; i++) {
Assert.assertEquals(values[i][0], 2.0);
}
@@ -270,30 +272,30 @@ public class ArrayOfDoublesIntersectionTest {
@Test
public void heapExactModeCustomSeed() {
- long seed = 1234567890;
+ final long seed = 1234567890;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed).build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed).build();
sketch1.update(1, new double[] {1});
sketch1.update(1, new double[] {1});
sketch1.update(2, new double[] {1});
sketch1.update(2, new double[] {1});
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed).build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed).build();
sketch2.update(2, new double[] {1});
sketch2.update(2, new double[] {1});
sketch2.update(3, new double[] {1});
sketch2.update(3, new double[] {1});
- ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().setSeed(seed).buildIntersection();
- intersection.update(sketch1, combiner);
- intersection.update(sketch2, combiner);
- ArrayOfDoublesCompactSketch result = intersection.getResult();
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().setSeed(seed).buildIntersection();
+ intersection.intersect(sketch1, combiner);
+ intersection.intersect(sketch2, combiner);
+ final ArrayOfDoublesCompactSketch result = intersection.getResult();
Assert.assertFalse(result.isEmpty());
Assert.assertEquals(result.getRetainedEntries(), 1);
Assert.assertEquals(result.getEstimate(), 1.0);
Assert.assertEquals(result.getLowerBound(1), 1.0);
Assert.assertEquals(result.getUpperBound(1), 1.0);
- double[][] values = result.getValues();
+ final double[][] values = result.getValues();
for (int i = 0; i < values.length; i++) {
Assert.assertEquals(values[i][0], 4.0);
}
@@ -301,8 +303,8 @@ public class ArrayOfDoublesIntersectionTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void incompatibleSeeds() {
- ArrayOfDoublesUpdatableSketch sketch = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(1).build();
- ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().setSeed(2).buildIntersection();
- intersection.update(sketch, combiner);
+ final ArrayOfDoublesUpdatableSketch sketch = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(1).build();
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().setSeed(2).buildIntersection();
+ intersection.intersect(sketch, combiner);
}
}
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java
index 089cc7c..29a2096 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java
@@ -34,23 +34,23 @@ public class ArrayOfDoublesUnionTest {
@Test
public void heapExactMode() {
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
sketch1.update(1, new double[] {1.0});
sketch1.update(1, new double[] {1.0});
sketch1.update(1, new double[] {1.0});
sketch1.update(2, new double[] {1.0});
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
sketch2.update(2, new double[] {1.0});
sketch2.update(2, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
- ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion();
- union.update(sketch1);
- union.update(sketch2);
- int maxBytes = ArrayOfDoublesUnion.getMaxBytes(
+ final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion();
+ union.union(sketch1);
+ union.union(sketch2);
+ final int maxBytes = ArrayOfDoublesUnion.getMaxBytes(
ArrayOfDoublesSetOperationBuilder.DEFAULT_NOMINAL_ENTRIES,
ArrayOfDoublesSetOperationBuilder.DEFAULT_NUMBER_OF_VALUES);
Assert.assertEquals(maxBytes, 131120); // 48 bytes preamble + 2 * nominal entries * (key size + value size)
@@ -61,8 +61,8 @@ public class ArrayOfDoublesUnionTest {
Assert.assertEquals(values[1][0], 3.0);
Assert.assertEquals(values[2][0], 3.0);
- WritableMemory wmem = WritableMemory.wrap(union.toByteArray());
- ArrayOfDoublesUnion wrappedUnion = ArrayOfDoublesSketches.wrapUnion(wmem);
+ final WritableMemory wmem = WritableMemory.wrap(union.toByteArray());
+ final ArrayOfDoublesUnion wrappedUnion = ArrayOfDoublesSketches.wrapUnion(wmem);
result = wrappedUnion.getResult();
Assert.assertEquals(result.getEstimate(), 3.0);
values = result.getValues();
@@ -84,20 +84,20 @@ public class ArrayOfDoublesUnionTest {
@Test
public void heapEstimationMode() {
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 4096; // overlap half of the entries
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
- ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion();
- union.update(sketch1);
- union.update(sketch2);
+ final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion();
+ union.union(sketch1);
+ union.union(sketch2);
ArrayOfDoublesCompactSketch result = union.getResult();
Assert.assertFalse(result.isEmpty());
Assert.assertTrue(result.isEstimationMode());
@@ -116,28 +116,28 @@ public class ArrayOfDoublesUnionTest {
@Test
public void heapEstimationModeFullOverlapTwoValuesAndDownsizing() {
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setNumberOfValues(2).build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setNumberOfValues(2).build();
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0, 2.0});
}
key = 0; // full overlap
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setNumberOfValues(2).build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setNumberOfValues(2).build();
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0, 2.0});
}
- ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().setNumberOfValues(2).setNominalEntries(1024).buildUnion();
- union.update(sketch1);
- union.update(sketch2);
- ArrayOfDoublesCompactSketch result = union.getResult();
+ final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().setNumberOfValues(2).setNominalEntries(1024).buildUnion();
+ union.union(sketch1);
+ union.union(sketch2);
+ final ArrayOfDoublesCompactSketch result = union.getResult();
Assert.assertFalse(result.isEmpty());
Assert.assertTrue(result.isEstimationMode());
Assert.assertEquals(result.getEstimate(), 8192.0, 8192 * 0.01);
Assert.assertEquals(result.getRetainedEntries(), 1024); // union was downsampled
- ArrayOfDoublesSketchIterator it = result.iterator();
- double[] expected = {2, 4};
+ final ArrayOfDoublesSketchIterator it = result.iterator();
+ final double[] expected = {2, 4};
while (it.next()) {
Assert.assertEquals(it.getValues(), expected, Arrays.toString(it.getValues()) + " != " + Arrays.toString(expected));
}
@@ -146,21 +146,21 @@ public class ArrayOfDoublesUnionTest {
@Test
public void heapMixedMode() {
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < 1000; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 500; // overlap half of the entries
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSamplingProbability(0.2f).build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSamplingProbability(0.2f).build();
for (int i = 0; i < 20000; i++) {
sketch2.update(key++, new double[] {1.0});
}
- ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion();
- union.update(sketch1);
- union.update(sketch2);
- ArrayOfDoublesCompactSketch result = union.getResult();
+ final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion();
+ union.union(sketch1);
+ union.union(sketch2);
+ final ArrayOfDoublesCompactSketch result = union.getResult();
Assert.assertFalse(result.isEmpty());
Assert.assertTrue(result.isEstimationMode());
Assert.assertEquals(result.getEstimate(), 20500.0, 20500 * 0.01);
@@ -169,22 +169,22 @@ public class ArrayOfDoublesUnionTest {
@Test
public void heapSerializeDeserialize() {
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 4096; // overlap half of the entries
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
- ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().buildUnion();
- union1.update(sketch1);
- union1.update(sketch2);
+ final ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().buildUnion();
+ union1.union(sketch1);
+ union1.union(sketch2);
- ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.heapify(Memory.wrap(union1.toByteArray()));
+ final ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.heapify(Memory.wrap(union1.toByteArray()));
ArrayOfDoublesCompactSketch result = union2.getResult();
Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
@@ -196,7 +196,7 @@ public class ArrayOfDoublesUnionTest {
Assert.assertEquals(result.getUpperBound(1), 0.0);
Assert.assertEquals(result.getLowerBound(1), 0.0);
Assert.assertEquals(result.getTheta(), 1.0);
- double[][] values = result.getValues();
+ final double[][] values = result.getValues();
for (int i = 0; i < values.length; i++) {
Assert.assertEquals(values[i][0], 2.0);
}
@@ -216,50 +216,50 @@ public class ArrayOfDoublesUnionTest {
@Test
public void heapSerializeDeserializeWithSeed() {
- long seed = 1;
+ final long seed = 1;
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed).build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed).build();
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 4096; // overlap half of the entries
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed).build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed).build();
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
- ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().setSeed(seed).buildUnion();
- union1.update(sketch1);
- union1.update(sketch2);
+ final ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().setSeed(seed).buildUnion();
+ union1.union(sketch1);
+ union1.union(sketch2);
- ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.heapify(Memory.wrap(union1.toByteArray()), seed);
- ArrayOfDoublesCompactSketch result = union2.getResult();
+ final ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.heapify(Memory.wrap(union1.toByteArray()), seed);
+ final ArrayOfDoublesCompactSketch result = union2.getResult();
Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
}
@Test
public void directSerializeDeserialize() {
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(
WritableMemory.wrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 4096; // overlap half of the entries
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(
WritableMemory.wrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
- ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().buildUnion(
+ final ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().buildUnion(
WritableMemory.wrap(new byte[1000000]));
- union1.update(sketch1);
- union1.update(sketch2);
+ union1.union(sketch1);
+ union1.union(sketch2);
- ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(union1.toByteArray()));
+ final ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(union1.toByteArray()));
ArrayOfDoublesCompactSketch result = union2.getResult(WritableMemory.wrap(new byte[1000000]));
Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
@@ -271,7 +271,7 @@ public class ArrayOfDoublesUnionTest {
Assert.assertEquals(result.getUpperBound(1), 0.0);
Assert.assertEquals(result.getLowerBound(1), 0.0);
Assert.assertEquals(result.getTheta(), 1.0);
- double[][] values = result.getValues();
+ final double[][] values = result.getValues();
for (int i = 0; i < values.length; i++) {
Assert.assertEquals(values[i][0], 2.0);
}
@@ -279,52 +279,52 @@ public class ArrayOfDoublesUnionTest {
@Test
public void directSerializeDeserializeWithSeed() {
- long seed = 1;
+ final long seed = 1;
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed)
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed)
.build(WritableMemory.wrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 4096; // overlap half of the entries
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed)
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed)
.build(WritableMemory.wrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
- ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().setSeed(seed)
+ final ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().setSeed(seed)
.buildUnion(WritableMemory.wrap(new byte[1000000]));
- union1.update(sketch1);
- union1.update(sketch2);
+ union1.union(sketch1);
+ union1.union(sketch2);
- ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(union1.toByteArray()), seed);
- ArrayOfDoublesCompactSketch result = union2.getResult(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(union1.toByteArray()), seed);
+ final ArrayOfDoublesCompactSketch result = union2.getResult(WritableMemory.wrap(new byte[1000000]));
Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
}
@Test
public void directExactMode() {
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
sketch1.update(1, new double[] {1.0});
sketch1.update(1, new double[] {1.0});
sketch1.update(1, new double[] {1.0});
sketch1.update(2, new double[] {1.0});
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
sketch2.update(2, new double[] {1.0});
sketch2.update(2, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
- ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
- union.update(sketch1);
- union.update(sketch2);
+ final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
+ union.union(sketch1);
+ union.union(sketch2);
ArrayOfDoublesCompactSketch result = union.getResult(WritableMemory.wrap(new byte[1000000]));
Assert.assertEquals(result.getEstimate(), 3.0);
- double[][] values = result.getValues();
+ final double[][] values = result.getValues();
Assert.assertEquals(values[0][0], 3.0);
Assert.assertEquals(values[1][0], 3.0);
Assert.assertEquals(values[2][0], 3.0);
@@ -342,20 +342,20 @@ public class ArrayOfDoublesUnionTest {
@Test
public void directEstimationMode() {
int key = 0;
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 4096; // overlap half of the entries
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
- ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
- union.update(sketch1);
- union.update(sketch2);
+ final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
+ union.union(sketch1);
+ union.union(sketch2);
ArrayOfDoublesCompactSketch result = union.getResult(WritableMemory.wrap(new byte[1000000]));
Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
@@ -371,29 +371,29 @@ public class ArrayOfDoublesUnionTest {
@Test
public void heapToDirect() {
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
sketch1.update(1, new double[] {1.0});
sketch1.update(1, new double[] {1.0});
sketch1.update(1, new double[] {1.0});
sketch1.update(2, new double[] {1.0});
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
sketch2.update(2, new double[] {1.0});
sketch2.update(2, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
- ArrayOfDoublesUnion heapUnion = new ArrayOfDoublesSetOperationBuilder().buildUnion();
- heapUnion.update(sketch1);
+ final ArrayOfDoublesUnion heapUnion = new ArrayOfDoublesSetOperationBuilder().buildUnion();
+ heapUnion.union(sketch1);
- ArrayOfDoublesUnion directUnion = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(heapUnion.toByteArray()));
- directUnion.update(sketch2);
+ final ArrayOfDoublesUnion directUnion = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(heapUnion.toByteArray()));
+ directUnion.union(sketch2);
- ArrayOfDoublesCompactSketch result = directUnion.getResult(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesCompactSketch result = directUnion.getResult(WritableMemory.wrap(new byte[1000000]));
Assert.assertFalse(result.isEmpty());
Assert.assertEquals(result.getEstimate(), 3.0);
- double[][] values = result.getValues();
+ final double[][] values = result.getValues();
Assert.assertEquals(values.length, 3);
Assert.assertEquals(values[0][0], 3.0);
Assert.assertEquals(values[1][0], 3.0);
@@ -402,29 +402,29 @@ public class ArrayOfDoublesUnionTest {
@Test
public void directToHeap() {
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
sketch1.update(1, new double[] {1.0});
sketch1.update(1, new double[] {1.0});
sketch1.update(1, new double[] {1.0});
sketch1.update(2, new double[] {1.0});
- ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
sketch2.update(2, new double[] {1.0});
sketch2.update(2, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
- ArrayOfDoublesUnion directUnion = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
- directUnion.update(sketch1);
+ final ArrayOfDoublesUnion directUnion = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
+ directUnion.union(sketch1);
- ArrayOfDoublesUnion heapUnion = ArrayOfDoublesUnion.heapify(Memory.wrap(directUnion.toByteArray()));
- heapUnion.update(sketch2);
+ final ArrayOfDoublesUnion heapUnion = ArrayOfDoublesUnion.heapify(Memory.wrap(directUnion.toByteArray()));
+ heapUnion.union(sketch2);
- ArrayOfDoublesCompactSketch result = heapUnion.getResult();
+ final ArrayOfDoublesCompactSketch result = heapUnion.getResult();
Assert.assertFalse(result.isEmpty());
Assert.assertEquals(result.getEstimate(), 3.0);
- double[][] values = result.getValues();
+ final double[][] values = result.getValues();
Assert.assertEquals(values.length, 3);
Assert.assertEquals(values[0][0], 3.0);
Assert.assertEquals(values[1][0], 3.0);
@@ -433,23 +433,23 @@ public class ArrayOfDoublesUnionTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void incompatibleSeeds() {
- ArrayOfDoublesUpdatableSketch sketch = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(1).build();
- ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().setSeed(2).buildUnion();
- union.update(sketch);
+ final ArrayOfDoublesUpdatableSketch sketch = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(1).build();
+ final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().setSeed(2).buildUnion();
+ union.union(sketch);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void incompatibleInputSketchFewerValues() {
- ArrayOfDoublesUpdatableSketch sketch = new ArrayOfDoublesUpdatableSketchBuilder().build();
- ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().setNumberOfValues(2).buildUnion();
- union.update(sketch);
+ final ArrayOfDoublesUpdatableSketch sketch = new ArrayOfDoublesUpdatableSketchBuilder().build();
+ final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().setNumberOfValues(2).buildUnion();
+ union.union(sketch);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void incompatibleInputSketchMoreValues() {
- ArrayOfDoublesUpdatableSketch sketch = new ArrayOfDoublesUpdatableSketchBuilder().setNumberOfValues(2).build();
- ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion();
- union.update(sketch);
+ final ArrayOfDoublesUpdatableSketch sketch = new ArrayOfDoublesUpdatableSketchBuilder().setNumberOfValues(2).build();
+ final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion();
+ union.union(sketch);
}
@Test
@@ -465,9 +465,9 @@ public class ArrayOfDoublesUnionTest {
sketch.trim(); // pretend this is a result from a union
// as Druid wraps memory
- ArrayOfDoublesSketches.wrapUnion(mem).update(sketch.compact(WritableMemory.wrap(new byte[1000000])));
+ ArrayOfDoublesSketches.wrapUnion(mem).union(sketch.compact(WritableMemory.wrap(new byte[1000000])));
- ArrayOfDoublesSketch result = ArrayOfDoublesUnion.wrap(mem).getResult();
+ final ArrayOfDoublesSketch result = ArrayOfDoublesUnion.wrap(mem).getResult();
Assert.assertEquals(result.getEstimate(), sketch.getEstimate());
Assert.assertEquals(result.isEstimationMode(), sketch.isEstimationMode());
}
@@ -485,7 +485,7 @@ public class ArrayOfDoublesUnionTest {
sketch1.update(key++, new double[] {1.0});
}
// as Druid wraps memory
- ArrayOfDoublesSketches.wrapUnion(mem).update(sketch1.compact(WritableMemory.wrap(new byte[1000000])));
+ ArrayOfDoublesSketches.wrapUnion(mem).union(sketch1.compact(WritableMemory.wrap(new byte[1000000])));
final int n2 = 1000000; // estimation mode
final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
@@ -493,7 +493,7 @@ public class ArrayOfDoublesUnionTest {
sketch2.update(key++, new double[] {1.0});
}
// as Druid wraps memory
- ArrayOfDoublesSketches.wrapUnion(mem).update(sketch2.compact(WritableMemory.wrap(new byte[1000000])));
+ ArrayOfDoublesSketches.wrapUnion(mem).union(sketch2.compact(WritableMemory.wrap(new byte[1000000])));
// build one sketch that must be the same as union
key = 0; // reset to have the same keys
@@ -504,7 +504,7 @@ public class ArrayOfDoublesUnionTest {
}
expected.trim(); // union result is trimmed, so we need to trim this sketch for valid comparison
- ArrayOfDoublesSketch result = ArrayOfDoublesUnion.wrap(mem).getResult();
+ final ArrayOfDoublesSketch result = ArrayOfDoublesUnion.wrap(mem).getResult();
Assert.assertEquals(result.getEstimate(), expected.getEstimate());
Assert.assertEquals(result.isEstimationMode(), expected.isEstimationMode());
Assert.assertEquals(result.getUpperBound(1), expected.getUpperBound(1));
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org