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 2022/04/06 19:43:32 UTC
[datasketches-java] branch DirectKllDoubleV2 created (now bc8fa6fa)
This is an automated email from the ASF dual-hosted git repository.
leerho pushed a change to branch DirectKllDoubleV2
in repository https://gitbox.apache.org/repos/asf/datasketches-java.git
at bc8fa6fa Renamed KllFloatsSketch to KllHeapFloatsSketch
This branch includes the following new commits:
new bc8fa6fa Renamed KllFloatsSketch to KllHeapFloatsSketch
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org
[datasketches-java] 01/01: Renamed KllFloatsSketch to KllHeapFloatsSketch
Posted by le...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
leerho pushed a commit to branch DirectKllDoubleV2
in repository https://gitbox.apache.org/repos/asf/datasketches-java.git
commit bc8fa6fa72b854983d946b74481cb5316b80f097
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Wed Apr 6 12:43:14 2022 -0700
Renamed KllFloatsSketch to KllHeapFloatsSketch
and KllDoublesSketch to KllHeapDoublesSketch
---
.../datasketches/kll/KllDirectDoublesSketch.java | 4 +-
.../datasketches/kll/KllDirectFloatsSketch.java | 4 +-
...oublesSketch.java => KllHeapDoublesSketch.java} | 134 ++++++++++++++++--
...lFloatsSketch.java => KllHeapFloatsSketch.java} | 136 ++++++++++++++++--
.../org/apache/datasketches/kll/KllHeapSketch.java | 153 ---------------------
.../org/apache/datasketches/kll/KllHelper.java | 2 +-
.../datasketches/quantiles/DoublesSketch.java | 8 +-
.../kll/KllDirectDoublesSketchIteratorTest.java | 2 +-
.../kll/KllDirectDoublesSketchTest.java | 28 ++--
.../kll/KllDirectFloatsSketchIteratorTest.java | 2 +-
.../kll/KllDirectFloatsSketchTest.java | 24 ++--
.../kll/KllDoublesSketchIteratorTest.java | 6 +-
.../datasketches/kll/KllDoublesSketchTest.java | 64 ++++-----
.../datasketches/kll/KllDoublesValidationTest.java | 2 +-
.../kll/KllFloatsSketchIteratorTest.java | 6 +-
.../datasketches/kll/KllFloatsSketchTest.java | 68 ++++-----
.../datasketches/kll/KllFloatsValidationTest.java | 2 +-
.../org/apache/datasketches/kll/KllHelperTest.java | 10 +-
.../datasketches/kll/KllMemoryValidateTest.java | 24 ++--
.../datasketches/kll/MiscDirectDoublesTest.java | 18 +--
.../datasketches/kll/MiscDirectFloatsTest.java | 18 +--
.../apache/datasketches/kll/MiscDoublesTest.java | 110 +++++++--------
.../apache/datasketches/kll/MiscFloatsTest.java | 110 +++++++--------
23 files changed, 507 insertions(+), 428 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
index 0c89ff3a..95980adb 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
@@ -71,8 +71,8 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
* @param mem the given Memory object.
* @return a KllDoublesSketch
*/
- public static KllDoublesSketch heapify(final Memory mem) {
- return KllDoublesSketch.heapify(mem);
+ public static KllHeapDoublesSketch heapify(final Memory mem) {
+ return KllHeapDoublesSketch.heapify(mem);
}
/**
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
index 54abe54d..ecd34327 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
@@ -71,8 +71,8 @@ public final class KllDirectFloatsSketch extends KllDirectSketch {
* @param mem the given Memory object.
* @return a KllFloatsSketch
*/
- public static KllFloatsSketch heapify(final Memory mem) {
- return KllFloatsSketch.heapify(mem);
+ public static KllHeapFloatsSketch heapify(final Memory mem) {
+ return KllHeapFloatsSketch.heapify(mem);
}
/**
diff --git a/src/main/java/org/apache/datasketches/kll/KllDoublesSketch.java b/src/main/java/org/apache/datasketches/kll/KllHeapDoublesSketch.java
similarity index 82%
rename from src/main/java/org/apache/datasketches/kll/KllDoublesSketch.java
rename to src/main/java/org/apache/datasketches/kll/KllHeapDoublesSketch.java
index c5aadebf..e2f84626 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllHeapDoublesSketch.java
@@ -26,6 +26,7 @@ import static org.apache.datasketches.kll.KllSketch.Error.MUST_NOT_CALL;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
/**
* This class implements an on-heap doubles KllSketch.
@@ -35,7 +36,7 @@ import org.apache.datasketches.memory.Memory;
*
* @author Lee Rhodes, Kevin Lang
*/
-public final class KllDoublesSketch extends KllHeapSketch {
+public final class KllHeapDoublesSketch extends KllSketch {
private double[] doubleItems_;
private double minDoubleValue_;
private double maxDoubleValue_;
@@ -45,8 +46,10 @@ public final class KllDoublesSketch extends KllHeapSketch {
* @param mem Memory object that contains data serialized by this sketch.
* @param memVal the MemoryCheck object
*/
- private KllDoublesSketch(final Memory mem, final KllMemoryValidate memVal) {
- super(memVal.k, memVal.m, SketchType.DOUBLES_SKETCH);
+ private KllHeapDoublesSketch(final Memory mem, final KllMemoryValidate memVal) {
+ super(SketchType.DOUBLES_SKETCH,null, null );
+ k = memVal.k;
+ m = memVal.m;
KllHelper.buildHeapKllSketchFromMemory(this, memVal);
}
@@ -54,7 +57,7 @@ public final class KllDoublesSketch extends KllHeapSketch {
* Heap constructor with the default <em>k = 200</em>.
* This will have a rank error of about 1.65%.
*/
- public KllDoublesSketch() {
+ public KllHeapDoublesSketch() {
this(KllSketch.DEFAULT_K, KllSketch.DEFAULT_M);
}
@@ -64,7 +67,7 @@ public final class KllDoublesSketch extends KllHeapSketch {
* 1.65%. Higher values of K will have smaller error but the sketch will be larger (and slower).
* @param k parameter that controls size of the sketch and accuracy of estimates
*/
- public KllDoublesSketch(final int k) {
+ public KllHeapDoublesSketch(final int k) {
this(k, KllSketch.DEFAULT_M);
}
@@ -79,8 +82,17 @@ public final class KllDoublesSketch extends KllHeapSketch {
* The DEFAULT_M, which is 8 is recommended. Other values of <em>m</em> should be considered
* experimental as they have not been as well characterized.
*/
- KllDoublesSketch(final int k, final int m) {
- super(k, m, SketchType.DOUBLES_SKETCH);
+ KllHeapDoublesSketch(final int k, final int m) {
+ super(SketchType.DOUBLES_SKETCH, null, null);
+ KllHelper.checkM(m);
+ KllHelper.checkK(k, m);
+ this.k = k;
+ this.m = m;
+ n_ = 0;
+ minK_ = k;
+ numLevels_ = 1;
+ levels_ = new int[] {k, k};
+ isLevelZeroSorted_ = false;
doubleItems_ = new double[k];
minDoubleValue_ = Double.NaN;
maxDoubleValue_ = Double.NaN;
@@ -93,10 +105,10 @@ public final class KllDoublesSketch extends KllHeapSketch {
* <a href="{@docRoot}/resources/dictionary.html#mem">See Memory</a>
* @return a heap-based sketch based on the given Memory.
*/
- public static KllDoublesSketch heapify(final Memory mem) {
+ public static KllHeapDoublesSketch heapify(final Memory mem) {
final KllMemoryValidate memChk = new KllMemoryValidate(mem);
if (!memChk.doublesSketch) { Error.kllSketchThrow(SRC_MUST_BE_DOUBLE); }
- return new KllDoublesSketch(mem, memChk);
+ return new KllHeapDoublesSketch(mem, memChk);
}
/**
@@ -353,4 +365,108 @@ public final class KllDoublesSketch extends KllHeapSketch {
@Override //Dummy
void setMinFloatValue(final float value) { kllSketchThrow(MUST_NOT_CALL); }
+ //************************************************************************************************
+ private final int k; // configured value of K.
+ private final int m; // configured value of M.
+ private long n_; // number of items input into this sketch.
+ private int minK_; // dynamic minK for error estimation after merging with different k.
+ private int numLevels_; // one-based number of current levels.
+ private int[] levels_; // array of index offsets into the items[]. Size = numLevels + 1.
+ private boolean isLevelZeroSorted_;
+
+ @Override
+ public int getK() {
+ return k;
+ }
+
+ @Override
+ public long getN() {
+ return n_;
+ }
+
+ @Override
+ int[] getLevelsArray() {
+ return levels_;
+ }
+
+ @Override
+ int getLevelsArrayAt(final int index) { return levels_[index]; }
+
+ @Override
+ int getM() {
+ return m;
+ }
+
+ @Override
+ int getMinK() {
+ return minK_;
+ }
+
+ @Override
+ int getNumLevels() {
+ return numLevels_;
+ }
+
+ @Override
+ void incN() {
+ n_++;
+ }
+
+ @Override
+ void incNumLevels() {
+ numLevels_++;
+ }
+
+ @Override
+ boolean isLevelZeroSorted() {
+ return isLevelZeroSorted_;
+ }
+
+ @Override
+ void setItemsArrayUpdatable(final WritableMemory itemsMem) { } //dummy
+
+ @Override
+ void setLevelsArray(final int[] levelsArr) {
+ levels_ = levelsArr;
+ }
+
+ @Override
+ void setLevelsArrayAt(final int index, final int value) { levels_[index] = value; }
+
+ @Override
+ void setLevelsArrayAtMinusEq(final int index, final int minusEq) {
+ levels_[index] -= minusEq;
+ }
+
+ @Override
+ void setLevelsArrayAtPlusEq(final int index, final int plusEq) {
+ levels_[index] += plusEq;
+ }
+
+ @Override
+ void setLevelsArrayUpdatable(final WritableMemory levelsMem) { } //dummy
+
+ @Override
+ void setLevelZeroSorted(final boolean sorted) {
+ this.isLevelZeroSorted_ = sorted;
+ }
+
+ @Override
+ void setMinK(final int minK) {
+ minK_ = minK;
+ }
+
+ @Override
+ void setMinMaxArrayUpdatable(final WritableMemory minMaxMem) { } //dummy
+
+ @Override
+ void setN(final long n) {
+ n_ = n;
+ }
+
+ @Override
+ void setNumLevels(final int numLevels) {
+ numLevels_ = numLevels;
+ }
+
}
diff --git a/src/main/java/org/apache/datasketches/kll/KllFloatsSketch.java b/src/main/java/org/apache/datasketches/kll/KllHeapFloatsSketch.java
similarity index 82%
rename from src/main/java/org/apache/datasketches/kll/KllFloatsSketch.java
rename to src/main/java/org/apache/datasketches/kll/KllHeapFloatsSketch.java
index 2ef1c3de..030ad4e5 100644
--- a/src/main/java/org/apache/datasketches/kll/KllFloatsSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllHeapFloatsSketch.java
@@ -26,6 +26,7 @@ import static org.apache.datasketches.kll.KllSketch.Error.MUST_NOT_CALL;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
/**
* This class implements an on-heap floats KllSketch.
@@ -35,7 +36,7 @@ import org.apache.datasketches.memory.Memory;
*
* @author Lee Rhodes, Kevin Lang
*/
-public final class KllFloatsSketch extends KllHeapSketch {
+public final class KllHeapFloatsSketch extends KllSketch {
private float[] floatItems_;
private float minFloatValue_;
private float maxFloatValue_;
@@ -45,8 +46,10 @@ public final class KllFloatsSketch extends KllHeapSketch {
* @param mem Memory object that contains data serialized by this sketch.
* @param memVal the MemoryCheck object
*/
- private KllFloatsSketch(final Memory mem, final KllMemoryValidate memVal) {
- super(memVal.k, memVal.m, SketchType.FLOATS_SKETCH);
+ private KllHeapFloatsSketch(final Memory mem, final KllMemoryValidate memVal) {
+ super(SketchType.FLOATS_SKETCH, null, null);
+ k = memVal.k;
+ m = memVal.m;
KllHelper.buildHeapKllSketchFromMemory(this, memVal);
}
@@ -54,7 +57,7 @@ public final class KllFloatsSketch extends KllHeapSketch {
* Heap constructor with the default <em>k = 200</em>.
* This will have a rank error of about 1.65%.
*/
- public KllFloatsSketch() {
+ public KllHeapFloatsSketch() {
this(KllSketch.DEFAULT_K, KllSketch.DEFAULT_M);
}
@@ -64,7 +67,7 @@ public final class KllFloatsSketch extends KllHeapSketch {
* 1.65%. Higher values of K will have smaller error but the sketch will be larger (and slower).
* @param k parameter that controls size of the sketch and accuracy of estimates
*/
- public KllFloatsSketch(final int k) {
+ public KllHeapFloatsSketch(final int k) {
this(k, KllSketch.DEFAULT_M);
}
@@ -79,8 +82,17 @@ public final class KllFloatsSketch extends KllHeapSketch {
* The DEFAULT_M, which is 8 is recommended. Other values of <em>m</em> should be considered
* experimental as they have not been as well characterized.
*/
- KllFloatsSketch(final int k, final int m) {
- super(k, m, SketchType.FLOATS_SKETCH);
+ KllHeapFloatsSketch(final int k, final int m) {
+ super(SketchType.FLOATS_SKETCH, null, null);
+ KllHelper.checkM(m);
+ KllHelper.checkK(k, m);
+ this.k = k;
+ this.m = m;
+ n_ = 0;
+ minK_ = k;
+ numLevels_ = 1;
+ levels_ = new int[] {k, k};
+ isLevelZeroSorted_ = false;
floatItems_ = new float[k];
minFloatValue_ = Float.NaN;
maxFloatValue_ = Float.NaN;
@@ -93,10 +105,10 @@ public final class KllFloatsSketch extends KllHeapSketch {
* <a href="{@docRoot}/resources/dictionary.html#mem">See Memory</a>
* @return a heap-based sketch based on the given Memory.
*/
- public static KllFloatsSketch heapify(final Memory mem) {
+ public static KllHeapFloatsSketch heapify(final Memory mem) {
final KllMemoryValidate memVal = new KllMemoryValidate(mem);
if (memVal.doublesSketch) { Error.kllSketchThrow(SRC_MUST_BE_FLOAT); }
- return new KllFloatsSketch(mem, memVal);
+ return new KllHeapFloatsSketch(mem, memVal);
}
/**
@@ -278,7 +290,7 @@ public final class KllFloatsSketch extends KllHeapSketch {
* Merges another sketch into this one.
* @param other sketch to merge into this one
*/
- public void merge(final KllFloatsSketch other) {
+ public void merge(final KllHeapFloatsSketch other) {
if (!other.isFloatsSketch()) { kllSketchThrow(SRC_MUST_BE_FLOAT); }
KllFloatsHelper.mergeFloatImpl(this, other);
}
@@ -353,4 +365,108 @@ public final class KllFloatsSketch extends KllHeapSketch {
@Override //Used internally
void setMinFloatValue(final float value) { minFloatValue_ = value; }
+ //************************************************************************************************
+ private final int k; // configured value of K.
+ private final int m; // configured value of M.
+ private long n_; // number of items input into this sketch.
+ private int minK_; // dynamic minK for error estimation after merging with different k.
+ private int numLevels_; // one-based number of current levels.
+ private int[] levels_; // array of index offsets into the items[]. Size = numLevels + 1.
+ private boolean isLevelZeroSorted_;
+
+ @Override
+ public int getK() {
+ return k;
+ }
+
+ @Override
+ public long getN() {
+ return n_;
+ }
+
+ @Override
+ int[] getLevelsArray() {
+ return levels_;
+ }
+
+ @Override
+ int getLevelsArrayAt(final int index) { return levels_[index]; }
+
+ @Override
+ int getM() {
+ return m;
+ }
+
+ @Override
+ int getMinK() {
+ return minK_;
+ }
+
+ @Override
+ int getNumLevels() {
+ return numLevels_;
+ }
+
+ @Override
+ void incN() {
+ n_++;
+ }
+
+ @Override
+ void incNumLevels() {
+ numLevels_++;
+ }
+
+ @Override
+ boolean isLevelZeroSorted() {
+ return isLevelZeroSorted_;
+ }
+
+ @Override
+ void setItemsArrayUpdatable(final WritableMemory itemsMem) { } //dummy
+
+ @Override
+ void setLevelsArray(final int[] levelsArr) {
+ levels_ = levelsArr;
+ }
+
+ @Override
+ void setLevelsArrayAt(final int index, final int value) { levels_[index] = value; }
+
+ @Override
+ void setLevelsArrayAtMinusEq(final int index, final int minusEq) {
+ levels_[index] -= minusEq;
+ }
+
+ @Override
+ void setLevelsArrayAtPlusEq(final int index, final int plusEq) {
+ levels_[index] += plusEq;
+ }
+
+ @Override
+ void setLevelsArrayUpdatable(final WritableMemory levelsMem) { } //dummy
+
+ @Override
+ void setLevelZeroSorted(final boolean sorted) {
+ this.isLevelZeroSorted_ = sorted;
+ }
+
+ @Override
+ void setMinK(final int minK) {
+ minK_ = minK;
+ }
+
+ @Override
+ void setMinMaxArrayUpdatable(final WritableMemory minMaxMem) { } //dummy
+
+ @Override
+ void setN(final long n) {
+ n_ = n;
+ }
+
+ @Override
+ void setNumLevels(final int numLevels) {
+ numLevels_ = numLevels;
+ }
+
}
diff --git a/src/main/java/org/apache/datasketches/kll/KllHeapSketch.java b/src/main/java/org/apache/datasketches/kll/KllHeapSketch.java
deleted file mode 100644
index f50cc213..00000000
--- a/src/main/java/org/apache/datasketches/kll/KllHeapSketch.java
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
- * 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.kll;
-
-import org.apache.datasketches.memory.WritableMemory;
-
-/**
- * This class implements all the methods for the heap sketches that are independent
- * of the sketch type (float or double).
- *
- * @author lrhodes
- */
-abstract class KllHeapSketch extends KllSketch {
- private final int k; // configured value of K.
- private final int m; // configured value of M.
- private long n_; // number of items input into this sketch.
- private int minK_; // dynamic minK for error estimation after merging with different k.
- private int numLevels_; // one-based number of current levels.
- private int[] levels_; // array of index offsets into the items[]. Size = numLevels + 1.
- private boolean isLevelZeroSorted_;
-
- /**
- * Heap constructor.
- * @param k user configured size of sketch. Range [m, 2^16]
- * @param m user configured minimum level width
- * @param sketchType either DOUBLE_SKETCH or FLOAT_SKETCH
- */
- KllHeapSketch(final int k, final int m, final SketchType sketchType) {
- super(sketchType, null, null);
- KllHelper.checkM(m);
- KllHelper.checkK(k, m);
- this.k = k;
- this.m = m;
- n_ = 0;
- minK_ = k;
- numLevels_ = 1;
- levels_ = new int[] {k, k};
- isLevelZeroSorted_ = false;
- }
-
- @Override
- public int getK() {
- return k;
- }
-
- @Override
- public long getN() {
- return n_;
- }
-
- @Override
- int[] getLevelsArray() {
- return levels_;
- }
-
- @Override
- int getLevelsArrayAt(final int index) { return levels_[index]; }
-
- @Override
- int getM() {
- return m;
- }
-
- @Override
- int getMinK() {
- return minK_;
- }
-
- @Override
- int getNumLevels() {
- return numLevels_;
- }
-
- @Override
- void incN() {
- n_++;
- }
-
- @Override
- void incNumLevels() {
- numLevels_++;
- }
-
- @Override
- boolean isLevelZeroSorted() {
- return isLevelZeroSorted_;
- }
-
- @Override
- void setItemsArrayUpdatable(final WritableMemory itemsMem) { } //dummy
-
- @Override
- void setLevelsArray(final int[] levelsArr) {
- levels_ = levelsArr;
- }
-
- @Override
- void setLevelsArrayAt(final int index, final int value) { levels_[index] = value; }
-
- @Override
- void setLevelsArrayAtMinusEq(final int index, final int minusEq) {
- levels_[index] -= minusEq;
- }
-
- @Override
- void setLevelsArrayAtPlusEq(final int index, final int plusEq) {
- levels_[index] += plusEq;
- }
-
- @Override
- void setLevelsArrayUpdatable(final WritableMemory levelsMem) { } //dummy
-
- @Override
- void setLevelZeroSorted(final boolean sorted) {
- this.isLevelZeroSorted_ = sorted;
- }
-
- @Override
- void setMinK(final int minK) {
- minK_ = minK;
- }
-
- @Override
- void setMinMaxArrayUpdatable(final WritableMemory minMaxMem) { } //dummy
-
- @Override
- void setN(final long n) {
- n_ = n;
- }
-
- @Override
- void setNumLevels(final int numLevels) {
- numLevels_ = numLevels;
- }
-
-}
diff --git a/src/main/java/org/apache/datasketches/kll/KllHelper.java b/src/main/java/org/apache/datasketches/kll/KllHelper.java
index 93ad2ce8..be7cb92a 100644
--- a/src/main/java/org/apache/datasketches/kll/KllHelper.java
+++ b/src/main/java/org/apache/datasketches/kll/KllHelper.java
@@ -487,7 +487,7 @@ final class KllHelper {
* Otherwise, it is the "single-sided" normalized rank error for all the other queries.
* @return if pmf is true, the normalized rank error for the getPMF() function.
* Otherwise, it is the "single-sided" normalized rank error for all the other queries.
- * @see KllDoublesSketch
+ * @see KllHeapDoublesSketch
*/
// constants were derived as the best fit to 99 percentile empirically measured max error in
// thousands of trials
diff --git a/src/main/java/org/apache/datasketches/quantiles/DoublesSketch.java b/src/main/java/org/apache/datasketches/quantiles/DoublesSketch.java
index 9f720704..79c6c8a7 100644
--- a/src/main/java/org/apache/datasketches/quantiles/DoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/quantiles/DoublesSketch.java
@@ -28,7 +28,7 @@ import java.util.Random;
import org.apache.datasketches.Family;
import org.apache.datasketches.SketchesArgumentException;
-import org.apache.datasketches.kll.KllFloatsSketch;
+import org.apache.datasketches.kll.KllSketch;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableMemory;
@@ -439,12 +439,12 @@ public abstract class DoublesSketch {
/**
* Gets the normalized rank error given k and pmf.
* Static method version of the {@link #getNormalizedRankError(boolean)}.
- * @param k the configuation parameter
+ * @param k the configuration parameter
* @param pmf if true, returns the "double-sided" normalized rank error for the getPMF() function.
* Otherwise, it is the "single-sided" normalized rank error for all the other queries.
* @return if pmf is true, the normalized rank error for the getPMF() function.
* Otherwise, it is the "single-sided" normalized rank error for all the other queries.
- * @see KllFloatsSketch
+ * @see KllSketch
*/
public static double getNormalizedRankError(final int k, final boolean pmf) {
return Util.getNormalizedRankError(k, pmf);
@@ -458,7 +458,7 @@ public abstract class DoublesSketch {
* returns the value of <em>k</em> assuming the input epsilon is the desired "single-sided"
* epsilon for all the other queries.
* @return the value of <i>k</i> given a value of epsilon.
- * @see KllFloatsSketch
+ * @see KllSketch
*/
public static int getKFromEpsilon(final double epsilon, final boolean pmf) {
return Util.getKFromEpsilon(epsilon, pmf);
diff --git a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchIteratorTest.java b/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchIteratorTest.java
index 4c703334..df66d57a 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchIteratorTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchIteratorTest.java
@@ -65,7 +65,7 @@ public class KllDirectDoublesSketchIteratorTest {
}
private static KllDirectDoublesSketch getDDSketch(final int k, final int n) {
- KllDoublesSketch sk = new KllDoublesSketch(k);
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch(k);
for (int i = 1; i <= n; i++) { sk.update(i); }
byte[] byteArr = sk.toUpdatableByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
diff --git a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
index e07d7d3c..9665ea82 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
@@ -313,7 +313,7 @@ public class KllDirectDoublesSketchTest {
public void serializeDeserializeEmptyViaCompactHeapify() {
final KllDirectDoublesSketch sketch1 = getDDSketch(200, 0);
final byte[] bytes = sketch1.toByteArray();
- final KllDoublesSketch sketch2 = KllDoublesSketch.heapify(Memory.wrap(bytes));
+ final KllHeapDoublesSketch sketch2 = KllHeapDoublesSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertTrue(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), sketch1.getNumRetained());
@@ -345,7 +345,7 @@ public class KllDirectDoublesSketchTest {
final KllDirectDoublesSketch sketch1 = getDDSketch(200, 0);
sketch1.update(1);
final byte[] bytes = sketch1.toByteArray();
- final KllDoublesSketch sketch2 = KllDoublesSketch.heapify(Memory.wrap(bytes));
+ final KllHeapDoublesSketch sketch2 = KllHeapDoublesSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), 1);
@@ -381,7 +381,7 @@ public class KllDirectDoublesSketchTest {
sketch1.update(i);
}
final byte[] bytes = sketch1.toByteArray();
- final KllDoublesSketch sketch2 = KllDoublesSketch.heapify(Memory.wrap(bytes));
+ final KllHeapDoublesSketch sketch2 = KllHeapDoublesSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), sketch1.getNumRetained());
@@ -445,8 +445,8 @@ public class KllDirectDoublesSketchTest {
int k = 20;
int n1 = 21;
int n2 = 43;
- KllDoublesSketch sk1 = new KllDoublesSketch(k);
- KllDoublesSketch sk2 = new KllDoublesSketch(k);
+ KllHeapDoublesSketch sk1 = new KllHeapDoublesSketch(k);
+ KllHeapDoublesSketch sk2 = new KllHeapDoublesSketch(k);
for (int i = 1; i <= n1; i++) {
sk1.update(i);
}
@@ -472,12 +472,12 @@ public class KllDirectDoublesSketchTest {
public void checkSketchInitializeDirectDoubleUpdatableMem() {
int k = 20; //don't change this
KllDirectDoublesSketch sk;
- KllDoublesSketch sk2;
+ KllHeapDoublesSketch sk2;
byte[] compBytes;
WritableMemory wmem;
println("#### CASE: DOUBLE FULL DIRECT FROM UPDATABLE");
- sk2 = new KllDoublesSketch(k);
+ sk2 = new KllHeapDoublesSketch(k);
for (int i = 1; i <= k + 1; i++) { sk2.update(i); }
//println(sk2.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
@@ -498,7 +498,7 @@ public class KllDirectDoublesSketchTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: DOUBLE EMPTY HEAPIFIED FROM UPDATABLE");
- sk2 = new KllDoublesSketch(k);
+ sk2 = new KllHeapDoublesSketch(k);
//println(sk.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
@@ -518,7 +518,7 @@ public class KllDirectDoublesSketchTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: DOUBLE SINGLE HEAPIFIED FROM UPDATABLE");
- sk2 = new KllDoublesSketch(k);
+ sk2 = new KllHeapDoublesSketch(k);
sk2.update(1);
//println(sk.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
@@ -552,7 +552,7 @@ public class KllDirectDoublesSketchTest {
assertFalse(sketch.isFloatsSketch());
final WritableMemory wmem = sketch.getWritableMemory();
- final KllDoublesSketch sk = KllDoublesSketch.heapify(wmem);
+ final KllHeapDoublesSketch sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), 200);
assertEquals(sk.getN(), 200);
assertFalse(sk.isEmpty());
@@ -586,7 +586,7 @@ public class KllDirectDoublesSketchTest {
WritableMemory dstMem = WritableMemory.allocate(6000);
KllDirectDoublesSketch sk = KllDirectDoublesSketch.newInstance(20, dstMem, memReqSvr);
for (int i = 1; i <= 100; i++) { sk.update(i); }
- KllDoublesSketch sk2 = KllDirectDoublesSketch.heapify(dstMem);
+ KllHeapDoublesSketch sk2 = KllDirectDoublesSketch.heapify(dstMem);
assertEquals(sk2.getMinValue(), 1.0);
assertEquals(sk2.getMaxValue(), 100.0);
}
@@ -596,7 +596,7 @@ public class KllDirectDoublesSketchTest {
WritableMemory dstMem = WritableMemory.allocate(6000);
KllDirectDoublesSketch sk = KllDirectDoublesSketch.newInstance(20, dstMem, memReqSvr);
for (int i = 1; i <= 21; i++) { sk.update(i); }
- KllDoublesSketch sk2 = new KllDoublesSketch(20);
+ KllHeapDoublesSketch sk2 = new KllHeapDoublesSketch(20);
for (int i = 1; i <= 21; i++ ) { sk2.update(i + 100); }
sk.merge(sk2);
}
@@ -606,7 +606,7 @@ public class KllDirectDoublesSketchTest {
WritableMemory dstMem = WritableMemory.allocate(6000);
KllDirectDoublesSketch sk = KllDirectDoublesSketch.newInstance(20, dstMem, memReqSvr);
for (int i = 1; i <= 21; i++) { sk.update(i); }
- KllDoublesSketch sk2 = new KllDoublesSketch(20);
+ KllHeapDoublesSketch sk2 = new KllHeapDoublesSketch(20);
for (int i = 1; i <= 21; i++ ) { sk2.update(i + 100); }
sk2.merge(sk);
}
@@ -620,7 +620,7 @@ public class KllDirectDoublesSketchTest {
// }
private static KllDirectDoublesSketch getDDSketch(final int k, final int n) {
- KllDoublesSketch sk = new KllDoublesSketch(k);
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch(k);
for (int i = 1; i <= n; i++) { sk.update(i); }
byte[] byteArr = sk.toUpdatableByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
diff --git a/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchIteratorTest.java b/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchIteratorTest.java
index 9b54a7a2..bd29fe77 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchIteratorTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchIteratorTest.java
@@ -65,7 +65,7 @@ public class KllDirectFloatsSketchIteratorTest {
}
private static KllDirectFloatsSketch getDFSketch(final int k, final int n) {
- KllFloatsSketch sk = new KllFloatsSketch(k);
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch(k);
for (int i = 1; i <= n; i++) { sk.update(i); }
byte[] byteArr = sk.toUpdatableByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
diff --git a/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java
index 02500438..7f174ecb 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java
@@ -313,7 +313,7 @@ public class KllDirectFloatsSketchTest {
public void serializeDeserializeEmptyViaCompactHeapify() {
final KllDirectFloatsSketch sketch1 = getDFSketch(200, 0);
final byte[] bytes = sketch1.toByteArray();
- final KllFloatsSketch sketch2 = KllFloatsSketch.heapify(Memory.wrap(bytes));
+ final KllHeapFloatsSketch sketch2 = KllHeapFloatsSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertTrue(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), sketch1.getNumRetained());
@@ -345,7 +345,7 @@ public class KllDirectFloatsSketchTest {
final KllDirectFloatsSketch sketch1 = getDFSketch(200, 0);
sketch1.update(1);
final byte[] bytes = sketch1.toByteArray();
- final KllFloatsSketch sketch2 = KllFloatsSketch.heapify(Memory.wrap(bytes));
+ final KllHeapFloatsSketch sketch2 = KllHeapFloatsSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), 1);
@@ -379,7 +379,7 @@ public class KllDirectFloatsSketchTest {
final int n = 1000;
for (int i = 0; i < n; i++) { sketch1.update(i); }
final byte[] bytes = sketch1.toByteArray();
- final KllFloatsSketch sketch2 = KllFloatsSketch.heapify(Memory.wrap(bytes));
+ final KllHeapFloatsSketch sketch2 = KllHeapFloatsSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), sketch1.getNumRetained());
@@ -443,8 +443,8 @@ public class KllDirectFloatsSketchTest {
int k = 20;
int n1 = 21;
int n2 = 43;
- KllFloatsSketch sk1 = new KllFloatsSketch(k);
- KllFloatsSketch sk2 = new KllFloatsSketch(k);
+ KllHeapFloatsSketch sk1 = new KllHeapFloatsSketch(k);
+ KllHeapFloatsSketch sk2 = new KllHeapFloatsSketch(k);
for (int i = 1; i <= n1; i++) {
sk1.update(i);
}
@@ -470,12 +470,12 @@ public class KllDirectFloatsSketchTest {
public void checkSketchInitializeDirectDoubleUpdatableMem() {
int k = 20; //don't change this
KllDirectFloatsSketch sk;
- KllFloatsSketch sk2;
+ KllHeapFloatsSketch sk2;
byte[] compBytes;
WritableMemory wmem;
println("#### CASE: DOUBLE FULL DIRECT FROM UPDATABLE");
- sk2 = new KllFloatsSketch(k);
+ sk2 = new KllHeapFloatsSketch(k);
for (int i = 1; i <= k + 1; i++) { sk2.update(i); }
//println(sk2.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
@@ -496,7 +496,7 @@ public class KllDirectFloatsSketchTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: DOUBLE EMPTY HEAPIFIED FROM UPDATABLE");
- sk2 = new KllFloatsSketch(k);
+ sk2 = new KllHeapFloatsSketch(k);
//println(sk.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
@@ -516,7 +516,7 @@ public class KllDirectFloatsSketchTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: DOUBLE SINGLE HEAPIFIED FROM UPDATABLE");
- sk2 = new KllFloatsSketch(k);
+ sk2 = new KllHeapFloatsSketch(k);
sk2.update(1);
//println(sk.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
@@ -550,7 +550,7 @@ public class KllDirectFloatsSketchTest {
assertFalse(sketch.isDoublesSketch());
final WritableMemory wmem = sketch.getWritableMemory();
- final KllFloatsSketch sk = KllFloatsSketch.heapify(wmem);
+ final KllHeapFloatsSketch sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), 200);
assertEquals(sk.getN(), 200);
assertFalse(sk.isEmpty());
@@ -584,13 +584,13 @@ public class KllDirectFloatsSketchTest {
WritableMemory dstMem = WritableMemory.allocate(6000);
KllDirectFloatsSketch sk = KllDirectFloatsSketch.newInstance(20, dstMem, memReqSvr);
for (int i = 1; i <= 100; i++) { sk.update(i); }
- KllFloatsSketch sk2 = KllDirectFloatsSketch.heapify(dstMem);
+ KllHeapFloatsSketch sk2 = KllDirectFloatsSketch.heapify(dstMem);
assertEquals(sk2.getMinValue(), 1.0);
assertEquals(sk2.getMaxValue(), 100.0);
}
private static KllDirectFloatsSketch getDFSketch(final int k, final int n) {
- KllFloatsSketch sk = new KllFloatsSketch(k);
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch(k);
for (int i = 1; i <= n; i++) { sk.update(i); }
byte[] byteArr = sk.toUpdatableByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
diff --git a/src/test/java/org/apache/datasketches/kll/KllDoublesSketchIteratorTest.java b/src/test/java/org/apache/datasketches/kll/KllDoublesSketchIteratorTest.java
index 64a99503..d3d23176 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDoublesSketchIteratorTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDoublesSketchIteratorTest.java
@@ -26,14 +26,14 @@ public class KllDoublesSketchIteratorTest {
@Test
public void emptySketch() {
- KllDoublesSketch sketch = new KllDoublesSketch();
+ KllHeapDoublesSketch sketch = new KllHeapDoublesSketch();
KllDoublesSketchIterator it = sketch.iterator();
Assert.assertFalse(it.next());
}
@Test
public void oneItemSketch() {
- KllDoublesSketch sketch = new KllDoublesSketch();
+ KllHeapDoublesSketch sketch = new KllHeapDoublesSketch();
sketch.update(0);
KllDoublesSketchIterator it = sketch.iterator();
Assert.assertTrue(it.next());
@@ -45,7 +45,7 @@ public class KllDoublesSketchIteratorTest {
@Test
public void bigSketches() {
for (int n = 1000; n < 100000; n += 2000) {
- KllDoublesSketch sketch = new KllDoublesSketch();
+ KllHeapDoublesSketch sketch = new KllHeapDoublesSketch();
for (int i = 0; i < n; i++) {
sketch.update(i);
}
diff --git a/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java
index b149d3c1..113a38a8 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java
@@ -39,7 +39,7 @@ public class KllDoublesSketchTest {
@Test
public void empty() {
- final KllDoublesSketch sketch = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch = new KllHeapDoublesSketch();
sketch.update(Double.NaN); // this must not change anything
assertTrue(sketch.isEmpty());
assertEquals(sketch.getN(), 0);
@@ -56,21 +56,21 @@ public class KllDoublesSketchTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void getQuantileInvalidArg() {
- final KllDoublesSketch sketch = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch = new KllHeapDoublesSketch();
sketch.update(1);
sketch.getQuantile(-1.0);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void getQuantilesInvalidArg() {
- final KllDoublesSketch sketch = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch = new KllHeapDoublesSketch();
sketch.update(1);
sketch.getQuantiles(new double[] {2.0});
}
@Test
public void oneItem() {
- final KllDoublesSketch sketch = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch = new KllHeapDoublesSketch();
sketch.update(1);
assertFalse(sketch.isEmpty());
assertEquals(sketch.getN(), 1);
@@ -84,7 +84,7 @@ public class KllDoublesSketchTest {
@Test
public void manyItemsEstimationMode() {
- final KllDoublesSketch sketch = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch = new KllHeapDoublesSketch();
final int n = 1_000_000;
for (int i = 0; i < n; i++) {
@@ -130,7 +130,7 @@ public class KllDoublesSketchTest {
@Test
public void getRankGetCdfGetPmfConsistency() {
- final KllDoublesSketch sketch = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch = new KllHeapDoublesSketch();
final int n = 1000;
final double[] values = new double[n];
for (int i = 0; i < n; i++) {
@@ -153,8 +153,8 @@ public class KllDoublesSketchTest {
@Test
public void merge() {
- final KllDoublesSketch sketch1 = new KllDoublesSketch();
- final KllDoublesSketch sketch2 = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch1 = new KllHeapDoublesSketch();
+ final KllHeapDoublesSketch sketch2 = new KllHeapDoublesSketch();
final int n = 10000;
for (int i = 0; i < n; i++) {
sketch1.update(i * 1.0);
@@ -178,8 +178,8 @@ public class KllDoublesSketchTest {
@Test
public void mergeLowerK() {
- final KllDoublesSketch sketch1 = new KllDoublesSketch(256);
- final KllDoublesSketch sketch2 = new KllDoublesSketch(128);
+ final KllHeapDoublesSketch sketch1 = new KllHeapDoublesSketch(256);
+ final KllHeapDoublesSketch sketch2 = new KllHeapDoublesSketch(128);
final int n = 10000;
for (int i = 0; i < n; i++) {
sketch1.update(i);
@@ -209,8 +209,8 @@ public class KllDoublesSketchTest {
@Test
public void mergeEmptyLowerK() {
- final KllDoublesSketch sketch1 = new KllDoublesSketch(256);
- final KllDoublesSketch sketch2 = new KllDoublesSketch(128);
+ final KllHeapDoublesSketch sketch1 = new KllHeapDoublesSketch(256);
+ final KllHeapDoublesSketch sketch2 = new KllHeapDoublesSketch(128);
final int n = 10000;
for (int i = 0; i < n; i++) {
sketch1.update(i);
@@ -238,8 +238,8 @@ public class KllDoublesSketchTest {
@Test
public void mergeExactModeLowerK() {
- final KllDoublesSketch sketch1 = new KllDoublesSketch(256);
- final KllDoublesSketch sketch2 = new KllDoublesSketch(128);
+ final KllHeapDoublesSketch sketch1 = new KllHeapDoublesSketch(256);
+ final KllHeapDoublesSketch sketch2 = new KllHeapDoublesSketch(128);
final int n = 10000;
for (int i = 0; i < n; i++) {
sketch1.update(i);
@@ -254,8 +254,8 @@ public class KllDoublesSketchTest {
@Test
public void mergeMinMinValueFromOther() {
- final KllDoublesSketch sketch1 = new KllDoublesSketch();
- final KllDoublesSketch sketch2 = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch1 = new KllHeapDoublesSketch();
+ final KllHeapDoublesSketch sketch2 = new KllHeapDoublesSketch();
sketch1.update(1);
sketch2.update(2);
sketch2.merge(sketch1);
@@ -264,11 +264,11 @@ public class KllDoublesSketchTest {
@Test
public void mergeMinAndMaxFromOther() {
- final KllDoublesSketch sketch1 = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch1 = new KllHeapDoublesSketch();
for (int i = 1; i <= 1_000_000; i++) {
sketch1.update(i);
}
- final KllDoublesSketch sketch2 = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch2 = new KllHeapDoublesSketch();
sketch2.merge(sketch1);
assertEquals(sketch2.getMinValue(), 1);
assertEquals(sketch2.getMaxValue(), 1_000_000);
@@ -277,18 +277,18 @@ public class KllDoublesSketchTest {
@SuppressWarnings("unused")
@Test(expectedExceptions = SketchesArgumentException.class)
public void kTooSmall() {
- new KllDoublesSketch(KllSketch.DEFAULT_M - 1);
+ new KllHeapDoublesSketch(KllSketch.DEFAULT_M - 1);
}
@SuppressWarnings("unused")
@Test(expectedExceptions = SketchesArgumentException.class)
public void kTooLarge() {
- new KllDoublesSketch(KllSketch.MAX_K + 1);
+ new KllHeapDoublesSketch(KllSketch.MAX_K + 1);
}
@Test
public void minK() {
- final KllDoublesSketch sketch = new KllDoublesSketch(KllSketch.DEFAULT_M);
+ final KllHeapDoublesSketch sketch = new KllHeapDoublesSketch(KllSketch.DEFAULT_M);
for (int i = 0; i < 1000; i++) {
sketch.update(i);
}
@@ -298,7 +298,7 @@ public class KllDoublesSketchTest {
@Test
public void maxK() {
- final KllDoublesSketch sketch = new KllDoublesSketch(KllSketch.MAX_K);
+ final KllHeapDoublesSketch sketch = new KllHeapDoublesSketch(KllSketch.MAX_K);
for (int i = 0; i < 1000; i++) {
sketch.update(i);
}
@@ -308,9 +308,9 @@ public class KllDoublesSketchTest {
@Test
public void serializeDeserializeEmpty() {
- final KllDoublesSketch sketch1 = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch1 = new KllHeapDoublesSketch();
final byte[] bytes = sketch1.toByteArray();
- final KllDoublesSketch sketch2 = KllDoublesSketch.heapify(Memory.wrap(bytes));
+ final KllHeapDoublesSketch sketch2 = KllHeapDoublesSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertTrue(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), sketch1.getNumRetained());
@@ -323,10 +323,10 @@ public class KllDoublesSketchTest {
@Test
public void serializeDeserializeOneItem() {
- final KllDoublesSketch sketch1 = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch1 = new KllHeapDoublesSketch();
sketch1.update(1);
final byte[] bytes = sketch1.toByteArray();
- final KllDoublesSketch sketch2 = KllDoublesSketch.heapify(Memory.wrap(bytes));
+ final KllHeapDoublesSketch sketch2 = KllHeapDoublesSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), 1);
@@ -349,13 +349,13 @@ public class KllDoublesSketchTest {
@Test
public void serializeDeserialize() {
- final KllDoublesSketch sketch1 = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch1 = new KllHeapDoublesSketch();
final int n = 1000;
for (int i = 0; i < n; i++) {
sketch1.update(i);
}
final byte[] bytes = sketch1.toByteArray();
- final KllDoublesSketch sketch2 = KllDoublesSketch.heapify(Memory.wrap(bytes));
+ final KllHeapDoublesSketch sketch2 = KllHeapDoublesSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), sketch1.getNumRetained());
@@ -368,21 +368,21 @@ public class KllDoublesSketchTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void outOfOrderSplitPoints() {
- final KllDoublesSketch sketch = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch = new KllHeapDoublesSketch();
sketch.update(0);
sketch.getCDF(new double[] {1, 0});
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void nanSplitPoint() {
- final KllDoublesSketch sketch = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch = new KllHeapDoublesSketch();
sketch.update(0);
sketch.getCDF(new double[] {Double.NaN});
}
@Test
public void getQuantiles() {
- final KllDoublesSketch sketch = new KllDoublesSketch();
+ final KllHeapDoublesSketch sketch = new KllHeapDoublesSketch();
sketch.update(1);
sketch.update(2);
sketch.update(3);
@@ -396,7 +396,7 @@ public class KllDoublesSketchTest {
@Test
public void checkReset() {
- KllDoublesSketch sk = new KllDoublesSketch(20);
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch(20);
for (int i = 1; i <= 100; i++) { sk.update(i); }
long n1 = sk.getN();
double min1 = sk.getMinValue();
diff --git a/src/test/java/org/apache/datasketches/kll/KllDoublesValidationTest.java b/src/test/java/org/apache/datasketches/kll/KllDoublesValidationTest.java
index 61d33f44..e6d1221c 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDoublesValidationTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDoublesValidationTest.java
@@ -211,7 +211,7 @@ public class KllDoublesValidationTest {
int n = (int) correctResultsWithReset[(7 * testI) + 2];
int stride = (int) correctResultsWithReset[(7 * testI) + 3];
int[] inputArray = makeInputArray(n, stride);
- KllDoublesSketch sketch = new KllDoublesSketch(k);
+ KllHeapDoublesSketch sketch = new KllHeapDoublesSketch(k);
for (int i = 0; i < n; i++) {
sketch.update(inputArray[i]);
}
diff --git a/src/test/java/org/apache/datasketches/kll/KllFloatsSketchIteratorTest.java b/src/test/java/org/apache/datasketches/kll/KllFloatsSketchIteratorTest.java
index 33d829fc..d55af856 100644
--- a/src/test/java/org/apache/datasketches/kll/KllFloatsSketchIteratorTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllFloatsSketchIteratorTest.java
@@ -26,14 +26,14 @@ public class KllFloatsSketchIteratorTest {
@Test
public void emptySketch() {
- KllFloatsSketch sketch = new KllFloatsSketch();
+ KllHeapFloatsSketch sketch = new KllHeapFloatsSketch();
KllFloatsSketchIterator it = sketch.iterator();
Assert.assertFalse(it.next());
}
@Test
public void oneItemSketch() {
- KllFloatsSketch sketch = new KllFloatsSketch();
+ KllHeapFloatsSketch sketch = new KllHeapFloatsSketch();
sketch.update(0);
KllFloatsSketchIterator it = sketch.iterator();
Assert.assertTrue(it.next());
@@ -45,7 +45,7 @@ public class KllFloatsSketchIteratorTest {
@Test
public void bigSketches() {
for (int n = 1000; n < 100000; n += 2000) {
- KllFloatsSketch sketch = new KllFloatsSketch();
+ KllHeapFloatsSketch sketch = new KllHeapFloatsSketch();
for (int i = 0; i < n; i++) {
sketch.update(i);
}
diff --git a/src/test/java/org/apache/datasketches/kll/KllFloatsSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllFloatsSketchTest.java
index e1a35f58..17c3da60 100644
--- a/src/test/java/org/apache/datasketches/kll/KllFloatsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllFloatsSketchTest.java
@@ -40,7 +40,7 @@ public class KllFloatsSketchTest {
@Test
public void empty() {
- final KllFloatsSketch sketch = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch = new KllHeapFloatsSketch();
sketch.update(Float.NaN); // this must not change anything
assertTrue(sketch.isEmpty());
assertEquals(sketch.getN(), 0);
@@ -57,21 +57,21 @@ public class KllFloatsSketchTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void getQuantileInvalidArg() {
- final KllFloatsSketch sketch = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch = new KllHeapFloatsSketch();
sketch.update(1);
sketch.getQuantile(-1.0);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void getQuantilesInvalidArg() {
- final KllFloatsSketch sketch = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch = new KllHeapFloatsSketch();
sketch.update(1);
sketch.getQuantiles(new double[] {2.0});
}
@Test
public void oneItem() {
- final KllFloatsSketch sketch = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch = new KllHeapFloatsSketch();
sketch.update(1);
assertFalse(sketch.isEmpty());
assertEquals(sketch.getN(), 1);
@@ -85,7 +85,7 @@ public class KllFloatsSketchTest {
@Test
public void manyItemsEstimationMode() {
- final KllFloatsSketch sketch = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch = new KllHeapFloatsSketch();
final int n = 1_000_000;
for (int i = 0; i < n; i++) {
@@ -131,7 +131,7 @@ public class KllFloatsSketchTest {
@Test
public void getRankGetCdfGetPmfConsistency() {
- final KllFloatsSketch sketch = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch = new KllHeapFloatsSketch();
final int n = 1000;
final float[] values = new float[n];
for (int i = 0; i < n; i++) {
@@ -154,8 +154,8 @@ public class KllFloatsSketchTest {
@Test
public void merge() {
- final KllFloatsSketch sketch1 = new KllFloatsSketch();
- final KllFloatsSketch sketch2 = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch1 = new KllHeapFloatsSketch();
+ final KllHeapFloatsSketch sketch2 = new KllHeapFloatsSketch();
final int n = 10000;
for (int i = 0; i < n; i++) {
sketch1.update(i * 1.0f);
@@ -179,8 +179,8 @@ public class KllFloatsSketchTest {
@Test
public void mergeLowerK() {
- final KllFloatsSketch sketch1 = new KllFloatsSketch(256);
- final KllFloatsSketch sketch2 = new KllFloatsSketch(128);
+ final KllHeapFloatsSketch sketch1 = new KllHeapFloatsSketch(256);
+ final KllHeapFloatsSketch sketch2 = new KllHeapFloatsSketch(128);
final int n = 10000;
for (int i = 0; i < n; i++) {
sketch1.update(i);
@@ -210,8 +210,8 @@ public class KllFloatsSketchTest {
@Test
public void mergeEmptyLowerK() {
- final KllFloatsSketch sketch1 = new KllFloatsSketch(256);
- final KllFloatsSketch sketch2 = new KllFloatsSketch(128);
+ final KllHeapFloatsSketch sketch1 = new KllHeapFloatsSketch(256);
+ final KllHeapFloatsSketch sketch2 = new KllHeapFloatsSketch(128);
final int n = 10000;
for (int i = 0; i < n; i++) {
sketch1.update(i);
@@ -239,8 +239,8 @@ public class KllFloatsSketchTest {
@Test
public void mergeExactModeLowerK() {
- final KllFloatsSketch sketch1 = new KllFloatsSketch(256);
- final KllFloatsSketch sketch2 = new KllFloatsSketch(128);
+ final KllHeapFloatsSketch sketch1 = new KllHeapFloatsSketch(256);
+ final KllHeapFloatsSketch sketch2 = new KllHeapFloatsSketch(128);
final int n = 10000;
for (int i = 0; i < n; i++) {
sketch1.update(i);
@@ -255,8 +255,8 @@ public class KllFloatsSketchTest {
@Test
public void mergeMinMinValueFromOther() {
- final KllFloatsSketch sketch1 = new KllFloatsSketch();
- final KllFloatsSketch sketch2 = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch1 = new KllHeapFloatsSketch();
+ final KllHeapFloatsSketch sketch2 = new KllHeapFloatsSketch();
sketch1.update(1);
sketch2.update(2);
sketch2.merge(sketch1);
@@ -265,11 +265,11 @@ public class KllFloatsSketchTest {
@Test
public void mergeMinAndMaxFromOther() {
- final KllFloatsSketch sketch1 = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch1 = new KllHeapFloatsSketch();
for (int i = 1; i <= 1_000_000; i++) {
sketch1.update(i);
}
- final KllFloatsSketch sketch2 = new KllFloatsSketch(10);
+ final KllHeapFloatsSketch sketch2 = new KllHeapFloatsSketch(10);
sketch2.merge(sketch1);
assertEquals(sketch2.getMinValue(), 1F);
assertEquals(sketch2.getMaxValue(), 1_000_000F);
@@ -278,18 +278,18 @@ public class KllFloatsSketchTest {
@SuppressWarnings("unused")
@Test(expectedExceptions = SketchesArgumentException.class)
public void kTooSmall() {
- new KllFloatsSketch(KllSketch.DEFAULT_M - 1);
+ new KllHeapFloatsSketch(KllSketch.DEFAULT_M - 1);
}
@SuppressWarnings("unused")
@Test(expectedExceptions = SketchesArgumentException.class)
public void kTooLarge() {
- new KllFloatsSketch(KllSketch.MAX_K + 1);
+ new KllHeapFloatsSketch(KllSketch.MAX_K + 1);
}
@Test
public void minK() {
- final KllFloatsSketch sketch = new KllFloatsSketch(KllSketch.DEFAULT_M);
+ final KllHeapFloatsSketch sketch = new KllHeapFloatsSketch(KllSketch.DEFAULT_M);
for (int i = 0; i < 1000; i++) {
sketch.update(i);
}
@@ -299,7 +299,7 @@ public class KllFloatsSketchTest {
@Test
public void maxK() {
- final KllFloatsSketch sketch = new KllFloatsSketch(KllSketch.MAX_K);
+ final KllHeapFloatsSketch sketch = new KllHeapFloatsSketch(KllSketch.MAX_K);
for (int i = 0; i < 1000; i++) {
sketch.update(i);
}
@@ -309,9 +309,9 @@ public class KllFloatsSketchTest {
@Test
public void serializeDeserializeEmpty() {
- final KllFloatsSketch sketch1 = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch1 = new KllHeapFloatsSketch();
final byte[] bytes = sketch1.toByteArray();
- final KllFloatsSketch sketch2 = KllFloatsSketch.heapify(Memory.wrap(bytes));
+ final KllHeapFloatsSketch sketch2 = KllHeapFloatsSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertTrue(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), sketch1.getNumRetained());
@@ -324,10 +324,10 @@ public class KllFloatsSketchTest {
@Test
public void serializeDeserializeOneItem() {
- final KllFloatsSketch sketch1 = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch1 = new KllHeapFloatsSketch();
sketch1.update(1);
final byte[] bytes = sketch1.toByteArray();
- final KllFloatsSketch sketch2 = KllFloatsSketch.heapify(Memory.wrap(bytes));
+ final KllHeapFloatsSketch sketch2 = KllHeapFloatsSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), 1);
@@ -341,7 +341,7 @@ public class KllFloatsSketchTest {
@Test
public void deserializeOneItemV1() throws Exception {
final byte[] bytes = getResourceBytes("kll_sketch_float_one_item_v1.sk");
- final KllFloatsSketch sketch = KllFloatsSketch.heapify(Memory.wrap(bytes));
+ final KllHeapFloatsSketch sketch = KllHeapFloatsSketch.heapify(Memory.wrap(bytes));
assertFalse(sketch.isEmpty());
assertFalse(sketch.isEstimationMode());
assertEquals(sketch.getN(), 1);
@@ -350,13 +350,13 @@ public class KllFloatsSketchTest {
@Test
public void serializeDeserialize() {
- final KllFloatsSketch sketch1 = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch1 = new KllHeapFloatsSketch();
final int n = 1000;
for (int i = 0; i < n; i++) {
sketch1.update(i);
}
final byte[] bytes = sketch1.toByteArray();
- final KllFloatsSketch sketch2 = KllFloatsSketch.heapify(Memory.wrap(bytes));
+ final KllHeapFloatsSketch sketch2 = KllHeapFloatsSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), sketch1.getNumRetained());
@@ -369,21 +369,21 @@ public class KllFloatsSketchTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void outOfOrderSplitPoints() {
- final KllFloatsSketch sketch = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch = new KllHeapFloatsSketch();
sketch.update(0);
sketch.getCDF(new float[] {1, 0});
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void nanSplitPoint() {
- final KllFloatsSketch sketch = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch = new KllHeapFloatsSketch();
sketch.update(0);
sketch.getCDF(new float[] {Float.NaN});
}
@Test
public void getQuantiles() {
- final KllFloatsSketch sketch = new KllFloatsSketch();
+ final KllHeapFloatsSketch sketch = new KllHeapFloatsSketch();
sketch.update(1);
sketch.update(2);
sketch.update(3);
@@ -402,7 +402,7 @@ public class KllFloatsSketchTest {
final int n = 200;
int bytes = KllSketch.getMaxSerializedSizeBytes(k, n); //assumed float before
assertEquals(bytes, 832);
- KllFloatsSketch sk = new KllFloatsSketch(k);
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch(k);
for (int i = 1; i <= n; i++) { sk.update(i); }
final byte[] byteArr = sk.toByteArray();
assertEquals(byteArr.length, 832);
@@ -412,7 +412,7 @@ public class KllFloatsSketchTest {
@Test
public void checkReset() {
- KllFloatsSketch sk = new KllFloatsSketch(20);
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch(20);
for (int i = 1; i <= 100; i++) { sk.update(i); }
long n1 = sk.getN();
float min1 = sk.getMinValue();
diff --git a/src/test/java/org/apache/datasketches/kll/KllFloatsValidationTest.java b/src/test/java/org/apache/datasketches/kll/KllFloatsValidationTest.java
index 9d3227c5..a7cea783 100644
--- a/src/test/java/org/apache/datasketches/kll/KllFloatsValidationTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllFloatsValidationTest.java
@@ -212,7 +212,7 @@ public class KllFloatsValidationTest {
int n = (int) correctResultsWithReset[(7 * testI) + 2];
int stride = (int) correctResultsWithReset[(7 * testI) + 3];
int[] inputArray = makeInputArray(n, stride);
- KllFloatsSketch sketch = new KllFloatsSketch(k);
+ KllHeapFloatsSketch sketch = new KllHeapFloatsSketch(k);
for (int i = 0; i < n; i++) {
sketch.update(inputArray[i]);
}
diff --git a/src/test/java/org/apache/datasketches/kll/KllHelperTest.java b/src/test/java/org/apache/datasketches/kll/KllHelperTest.java
index 791bdd5c..e713440d 100644
--- a/src/test/java/org/apache/datasketches/kll/KllHelperTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllHelperTest.java
@@ -86,10 +86,10 @@ public class KllHelperTest {
@Test
public void checkUpdatableSerDe() {
- KllDoublesSketch sk = new KllDoublesSketch(200);
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch(200);
for (int i = 1; i <= 533; i++) { sk.update(i); }
int retained = sk.getNumRetained();
- int numLevels = ((KllHeapSketch)sk).getNumLevels();
+ int numLevels = ((KllSketch)sk).getNumLevels();
println("NumLevels: " + numLevels);
println("NumRetained: " + retained);
@@ -102,10 +102,10 @@ public class KllHelperTest {
println("upBytes1: " + upBytes1);
Memory mem;
- KllDoublesSketch sk2;
+ KllHeapDoublesSketch sk2;
mem = Memory.wrap(compByteArr1);
- sk2 = KllDoublesSketch.heapify(mem);
+ sk2 = KllHeapDoublesSketch.heapify(mem);
byte[] compByteArr2 = sk2.toByteArray();
int compBytes2 = compByteArr2.length;
println("compBytes2: " + compBytes2);
@@ -113,7 +113,7 @@ public class KllHelperTest {
assertEquals(sk2.getNumRetained(), retained);
mem = Memory.wrap(compByteArr2);
- sk2 = KllDoublesSketch.heapify(mem);
+ sk2 = KllHeapDoublesSketch.heapify(mem);
byte[] upByteArr2 = sk2.toUpdatableByteArray();
int upBytes2 = upByteArr2.length;
println("upBytes2: " + upBytes2);
diff --git a/src/test/java/org/apache/datasketches/kll/KllMemoryValidateTest.java b/src/test/java/org/apache/datasketches/kll/KllMemoryValidateTest.java
index 32495415..c26f8779 100644
--- a/src/test/java/org/apache/datasketches/kll/KllMemoryValidateTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllMemoryValidateTest.java
@@ -31,7 +31,7 @@ public class KllMemoryValidateTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkInvalidFamily() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryFamilyID(wmem, Family.KLL.getID() - 1);
@@ -40,7 +40,7 @@ public class KllMemoryValidateTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkInvalidSerVer() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemorySerVer(wmem, SERIAL_VERSION_EMPTY_FULL - 1);
@@ -49,7 +49,7 @@ public class KllMemoryValidateTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkInvalidEmptyAndSingle() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryFlags(wmem, EMPTY_BIT_MASK | SINGLE_ITEM_BIT_MASK);
@@ -58,7 +58,7 @@ public class KllMemoryValidateTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkInvalidUpdatableAndSerVer() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryFlags(wmem, UPDATABLE_BIT_MASK);
@@ -68,7 +68,7 @@ public class KllMemoryValidateTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkInvalidSingleAndPreInts() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
sk.update(1);
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
@@ -78,7 +78,7 @@ public class KllMemoryValidateTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkInvalidSingleAndSerVer() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
sk.update(1);
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
@@ -88,7 +88,7 @@ public class KllMemoryValidateTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkInvalidEmptyDoublesAndPreIntsFull() {
- KllDoublesSketch sk = new KllDoublesSketch();
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch();
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryPreInts(wmem, PREAMBLE_INTS_FULL);
@@ -97,7 +97,7 @@ public class KllMemoryValidateTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkInvalidSingleDoubleCompactAndSerVer() {
- KllDoublesSketch sk = new KllDoublesSketch();
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch();
sk.update(1);
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
@@ -107,7 +107,7 @@ public class KllMemoryValidateTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkInvalidDoubleUpdatableAndPreInts() {
- KllDoublesSketch sk = new KllDoublesSketch();
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch();
byte[] byteArr = sk.toUpdatableByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryPreInts(wmem, PREAMBLE_INTS_EMPTY_SINGLE);
@@ -116,7 +116,7 @@ public class KllMemoryValidateTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkInvalidFloatFullAndPreInts() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
sk.update(1); sk.update(2);
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
@@ -126,7 +126,7 @@ public class KllMemoryValidateTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkInvalidFloatUpdatableFullAndPreInts() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
sk.update(1); sk.update(2);
byte[] byteArr = sk.toUpdatableByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
@@ -136,7 +136,7 @@ public class KllMemoryValidateTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkInvalidDoubleCompactSingleAndPreInts() {
- KllDoublesSketch sk = new KllDoublesSketch();
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch();
sk.update(1);
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
diff --git a/src/test/java/org/apache/datasketches/kll/MiscDirectDoublesTest.java b/src/test/java/org/apache/datasketches/kll/MiscDirectDoublesTest.java
index eedf5e44..e7523deb 100644
--- a/src/test/java/org/apache/datasketches/kll/MiscDirectDoublesTest.java
+++ b/src/test/java/org/apache/datasketches/kll/MiscDirectDoublesTest.java
@@ -163,7 +163,7 @@ public class MiscDirectDoublesTest {
@Test
public void checkSketchInitializeDoubleHeapifyCompactMem() {
int k = 20; //don't change this
- KllDoublesSketch sk;
+ KllHeapDoublesSketch sk;
KllDirectDoublesSketch sk2;
byte[] compBytes;
WritableMemory wmem;
@@ -175,7 +175,7 @@ public class MiscDirectDoublesTest {
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
assertEquals(sk.getNumRetained(), 11);
@@ -195,7 +195,7 @@ public class MiscDirectDoublesTest {
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
assertEquals(sk.getNumRetained(), 0);
@@ -216,7 +216,7 @@ public class MiscDirectDoublesTest {
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
assertEquals(sk.getNumRetained(), 1);
@@ -234,7 +234,7 @@ public class MiscDirectDoublesTest {
@Test
public void checkSketchInitializeDoubleHeapifyUpdatableMem() {
int k = 20; //don't change this
- KllDoublesSketch sk;
+ KllHeapDoublesSketch sk;
KllDirectDoublesSketch sk2;
byte[] compBytes;
WritableMemory wmem;
@@ -246,7 +246,7 @@ public class MiscDirectDoublesTest {
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
assertEquals(sk.getNumRetained(), 11);
@@ -266,7 +266,7 @@ public class MiscDirectDoublesTest {
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
assertEquals(sk.getNumRetained(), 0);
@@ -287,7 +287,7 @@ public class MiscDirectDoublesTest {
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
assertEquals(sk.getNumRetained(), 1);
@@ -417,7 +417,7 @@ public class MiscDirectDoublesTest {
}
private static KllDirectDoublesSketch getDDSketch(final int k, final int n) {
- KllDoublesSketch sk = new KllDoublesSketch(k);
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch(k);
for (int i = 1; i <= n; i++) { sk.update(i); }
byte[] byteArr = sk.toUpdatableByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
diff --git a/src/test/java/org/apache/datasketches/kll/MiscDirectFloatsTest.java b/src/test/java/org/apache/datasketches/kll/MiscDirectFloatsTest.java
index 597ebe5d..809ffe1a 100644
--- a/src/test/java/org/apache/datasketches/kll/MiscDirectFloatsTest.java
+++ b/src/test/java/org/apache/datasketches/kll/MiscDirectFloatsTest.java
@@ -163,7 +163,7 @@ public class MiscDirectFloatsTest {
@Test
public void checkSketchInitializeFloatHeapifyCompactMem() {
int k = 20; //don't change this
- KllFloatsSketch sk;
+ KllHeapFloatsSketch sk;
KllDirectFloatsSketch sk2;
byte[] compBytes;
WritableMemory wmem;
@@ -175,7 +175,7 @@ public class MiscDirectFloatsTest {
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllFloatsSketch.heapify(wmem);
+ sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
assertEquals(sk.getNumRetained(), 11);
@@ -195,7 +195,7 @@ public class MiscDirectFloatsTest {
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllFloatsSketch.heapify(wmem);
+ sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
assertEquals(sk.getNumRetained(), 0);
@@ -216,7 +216,7 @@ public class MiscDirectFloatsTest {
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllFloatsSketch.heapify(wmem);
+ sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
assertEquals(sk.getNumRetained(), 1);
@@ -234,7 +234,7 @@ public class MiscDirectFloatsTest {
@Test
public void checkSketchInitializeFloatHeapifyUpdatableMem() {
int k = 20; //don't change this
- KllFloatsSketch sk;
+ KllHeapFloatsSketch sk;
KllDirectFloatsSketch sk2;
byte[] compBytes;
WritableMemory wmem;
@@ -246,7 +246,7 @@ public class MiscDirectFloatsTest {
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllFloatsSketch.heapify(wmem);
+ sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
assertEquals(sk.getNumRetained(), 11);
@@ -266,7 +266,7 @@ public class MiscDirectFloatsTest {
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllFloatsSketch.heapify(wmem);
+ sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
assertEquals(sk.getNumRetained(), 0);
@@ -287,7 +287,7 @@ public class MiscDirectFloatsTest {
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllFloatsSketch.heapify(wmem);
+ sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
assertEquals(sk.getNumRetained(), 1);
@@ -417,7 +417,7 @@ public class MiscDirectFloatsTest {
}
private static KllDirectFloatsSketch getDFSketch(final int k, final int n) {
- KllFloatsSketch sk = new KllFloatsSketch(k);
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch(k);
for (int i = 1; i <= n; i++) { sk.update(i); }
byte[] byteArr = sk.toUpdatableByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
diff --git a/src/test/java/org/apache/datasketches/kll/MiscDoublesTest.java b/src/test/java/org/apache/datasketches/kll/MiscDoublesTest.java
index 276f5277..ed43f225 100644
--- a/src/test/java/org/apache/datasketches/kll/MiscDoublesTest.java
+++ b/src/test/java/org/apache/datasketches/kll/MiscDoublesTest.java
@@ -38,7 +38,7 @@ public class MiscDoublesTest {
@Test
public void checkBounds() {
- final KllDoublesSketch kll = new KllDoublesSketch(); //default k = 200
+ final KllHeapDoublesSketch kll = new KllHeapDoublesSketch(); //default k = 200
for (int i = 0; i < 1000; i++) {
kll.update(i);
}
@@ -55,49 +55,49 @@ public class MiscDoublesTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkHeapifyExceptions1() {
- KllDoublesSketch sk = new KllDoublesSketch();
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch();
WritableMemory wmem = WritableMemory.writableWrap(sk.toByteArray());
wmem.putByte(6, (byte)3); //corrupt with odd M
- KllDoublesSketch.heapify(wmem);
+ KllHeapDoublesSketch.heapify(wmem);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkHeapifyExceptions2() {
- KllDoublesSketch sk = new KllDoublesSketch();
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch();
WritableMemory wmem = WritableMemory.writableWrap(sk.toByteArray());
wmem.putByte(0, (byte)1); //corrupt preamble ints, should be 2
- KllDoublesSketch.heapify(wmem);
+ KllHeapDoublesSketch.heapify(wmem);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkHeapifyExceptions3() {
- KllDoublesSketch sk = new KllDoublesSketch();
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch();
sk.update(1.0f);
sk.update(2.0f);
WritableMemory wmem = WritableMemory.writableWrap(sk.toByteArray());
wmem.putByte(0, (byte)1); //corrupt preamble ints, should be 5
- KllDoublesSketch.heapify(wmem);
+ KllHeapDoublesSketch.heapify(wmem);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkHeapifyExceptions4() {
- KllDoublesSketch sk = new KllDoublesSketch();
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch();
WritableMemory wmem = WritableMemory.writableWrap(sk.toByteArray());
wmem.putByte(1, (byte)0); //corrupt SerVer, should be 1 or 2
- KllDoublesSketch.heapify(wmem);
+ KllHeapDoublesSketch.heapify(wmem);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkHeapifyExceptions5() {
- KllDoublesSketch sk = new KllDoublesSketch();
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch();
WritableMemory wmem = WritableMemory.writableWrap(sk.toByteArray());
wmem.putByte(2, (byte)0); //corrupt FamilyID, should be 15
- KllDoublesSketch.heapify(wmem);
+ KllHeapDoublesSketch.heapify(wmem);
}
@Test
public void checkMisc() {
- KllDoublesSketch sk = new KllDoublesSketch(8);
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch(8);
assertTrue(Objects.isNull(sk.getQuantiles(10)));
sk.toString(true, true);
for (int i = 0; i < 20; i++) { sk.update(i); }
@@ -112,12 +112,12 @@ public class MiscDoublesTest {
//@Test //enable static println(..) for visual checking
public void visualCheckToString() {
- final KllDoublesSketch sketch = new KllDoublesSketch(20);
+ final KllHeapDoublesSketch sketch = new KllHeapDoublesSketch(20);
for (int i = 0; i < 10; i++) { sketch.update(i + 1); }
final String s1 = sketch.toString(true, true);
println(s1);
- final KllDoublesSketch sketch2 = new KllDoublesSketch(20);
+ final KllHeapDoublesSketch sketch2 = new KllHeapDoublesSketch(20);
for (int i = 0; i < 400; i++) { sketch2.update(i + 1); }
println("\n" + sketch2.toString(true, true));
@@ -128,7 +128,7 @@ public class MiscDoublesTest {
@Test
public void viewCompactions() {
- KllDoublesSketch sk = new KllDoublesSketch(20);
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch(20);
show(sk, 20);
show(sk, 21); //compaction 1
show(sk, 43);
@@ -144,7 +144,7 @@ public class MiscDoublesTest {
show(sk, 108);
}
- private static void show(final KllDoublesSketch sk, int limit) {
+ private static void show(final KllHeapDoublesSketch sk, int limit) {
int i = (int) sk.getN();
for ( ; i < limit; i++) { sk.update(i + 1); }
println(sk.toString(true, true));
@@ -152,7 +152,7 @@ public class MiscDoublesTest {
@Test
public void checkGrowLevels() {
- KllDoublesSketch sk = new KllDoublesSketch(20);
+ KllHeapDoublesSketch sk = new KllHeapDoublesSketch(20);
for (int i = 1; i <= 21; i++) { sk.update(i); }
assertEquals(sk.getNumLevels(), 2);
assertEquals(sk.getDoubleItemsArray().length, 33);
@@ -162,10 +162,10 @@ public class MiscDoublesTest {
@Test
public void checkSketchInitializeDoubleHeap() {
int k = 20; //don't change this
- KllDoublesSketch sk;
+ KllHeapDoublesSketch sk;
println("#### CASE: DOUBLE FULL HEAP");
- sk = new KllDoublesSketch(k);
+ sk = new KllHeapDoublesSketch(k);
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
//println(sk.toString(true, true));
assertEquals(sk.getK(), k);
@@ -182,7 +182,7 @@ public class MiscDoublesTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: DOUBLE HEAP EMPTY");
- sk = new KllDoublesSketch(k);
+ sk = new KllHeapDoublesSketch(k);
//println(sk.toString(true, true));
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
@@ -198,7 +198,7 @@ public class MiscDoublesTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: DOUBLE HEAP SINGLE");
- sk = new KllDoublesSketch(k);
+ sk = new KllHeapDoublesSketch(k);
sk.update(1);
//println(sk.toString(true, true));
assertEquals(sk.getK(), k);
@@ -218,19 +218,19 @@ public class MiscDoublesTest {
@Test
public void checkSketchInitializeDoubleHeapifyCompactMem() {
int k = 20; //don't change this
- KllDoublesSketch sk;
- KllDoublesSketch sk2;
+ KllHeapDoublesSketch sk;
+ KllHeapDoublesSketch sk2;
byte[] compBytes;
WritableMemory wmem;
println("#### CASE: DOUBLE FULL HEAPIFIED FROM COMPACT");
- sk2 = new KllDoublesSketch(k);
+ sk2 = new KllHeapDoublesSketch(k);
for (int i = 1; i <= k + 1; i++) { sk2.update(i); }
//println(sk.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
assertEquals(sk.getNumRetained(), 11);
@@ -245,12 +245,12 @@ public class MiscDoublesTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: DOUBLE EMPTY HEAPIFIED FROM COMPACT");
- sk2 = new KllDoublesSketch(k);
+ sk2 = new KllHeapDoublesSketch(k);
//println(sk.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
assertEquals(sk.getNumRetained(), 0);
@@ -265,13 +265,13 @@ public class MiscDoublesTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: DOUBLE SINGLE HEAPIFIED FROM COMPACT");
- sk2 = new KllDoublesSketch(k);
+ sk2 = new KllHeapDoublesSketch(k);
sk2.update(1);
println(sk2.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
assertEquals(sk.getNumRetained(), 1);
@@ -289,19 +289,19 @@ public class MiscDoublesTest {
@Test
public void checkSketchInitializeDoubleHeapifyUpdatableMem() {
int k = 20; //don't change this
- KllDoublesSketch sk;
- KllDoublesSketch sk2;
+ KllHeapDoublesSketch sk;
+ KllHeapDoublesSketch sk2;
byte[] compBytes;
WritableMemory wmem;
println("#### CASE: DOUBLE FULL HEAPIFIED FROM UPDATABLE");
- sk2 = new KllDoublesSketch(k);
+ sk2 = new KllHeapDoublesSketch(k);
for (int i = 1; i <= k + 1; i++) { sk2.update(i); }
//println(sk2.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
assertEquals(sk.getNumRetained(), 11);
@@ -316,12 +316,12 @@ public class MiscDoublesTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: DOUBLE EMPTY HEAPIFIED FROM UPDATABLE");
- sk2 = new KllDoublesSketch(k);
+ sk2 = new KllHeapDoublesSketch(k);
//println(sk.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
assertEquals(sk.getNumRetained(), 0);
@@ -336,13 +336,13 @@ public class MiscDoublesTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: DOUBLE SINGLE HEAPIFIED FROM UPDATABLE");
- sk2 = new KllDoublesSketch(k);
+ sk2 = new KllHeapDoublesSketch(k);
sk2.update(1);
//println(sk.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllHeapDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
assertEquals(sk.getNumRetained(), 1);
@@ -360,22 +360,22 @@ public class MiscDoublesTest {
@Test
public void checkMemoryToStringDoubleCompact() {
int k = 20; // don't change this
- KllDoublesSketch sk;
- KllDoublesSketch sk2;
+ KllHeapDoublesSketch sk;
+ KllHeapDoublesSketch sk2;
byte[] compBytes;
byte[] compBytes2;
WritableMemory wmem;
String s;
println("#### CASE: DOUBLE FULL COMPACT");
- sk = new KllDoublesSketch(k);
+ sk = new KllHeapDoublesSketch(k);
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
compBytes = sk.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = KllDoublesSketch.heapify(wmem);
+ sk2 = KllHeapDoublesSketch.heapify(wmem);
compBytes2 = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -384,13 +384,13 @@ public class MiscDoublesTest {
assertEquals(compBytes, compBytes2);
println("#### CASE: DOUBLE EMPTY COMPACT");
- sk = new KllDoublesSketch(20);
+ sk = new KllHeapDoublesSketch(20);
compBytes = sk.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = KllDoublesSketch.heapify(wmem);
+ sk2 = KllHeapDoublesSketch.heapify(wmem);
compBytes2 = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -399,14 +399,14 @@ public class MiscDoublesTest {
assertEquals(compBytes, compBytes2);
println("#### CASE: DOUBLE SINGLE COMPACT");
- sk = new KllDoublesSketch(20);
+ sk = new KllHeapDoublesSketch(20);
sk.update(1);
compBytes = sk.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = KllDoublesSketch.heapify(wmem);
+ sk2 = KllHeapDoublesSketch.heapify(wmem);
compBytes2 = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -418,22 +418,22 @@ public class MiscDoublesTest {
@Test
public void checkMemoryToStringDoubleUpdatable() {
int k = 20; //don't change this
- KllDoublesSketch sk;
- KllDoublesSketch sk2;
+ KllHeapDoublesSketch sk;
+ KllHeapDoublesSketch sk2;
byte[] upBytes;
byte[] upBytes2;
WritableMemory wmem;
String s;
println("#### CASE: DOUBLE FULL UPDATABLE");
- sk = new KllDoublesSketch(20);
+ sk = new KllHeapDoublesSketch(20);
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
upBytes = sk.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = KllDoublesSketch.heapify(wmem);
+ sk2 = KllHeapDoublesSketch.heapify(wmem);
upBytes2 = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -442,13 +442,13 @@ public class MiscDoublesTest {
assertEquals(upBytes, upBytes2);
println("#### CASE: DOUBLE EMPTY UPDATABLE");
- sk = new KllDoublesSketch(k);
+ sk = new KllHeapDoublesSketch(k);
upBytes = sk.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = KllDoublesSketch.heapify(wmem);
+ sk2 = KllHeapDoublesSketch.heapify(wmem);
upBytes2 = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -457,14 +457,14 @@ public class MiscDoublesTest {
assertEquals(upBytes, upBytes2);
println("#### CASE: DOUBLE SINGLE UPDATABL");
- sk = new KllDoublesSketch(k);
+ sk = new KllHeapDoublesSketch(k);
sk.update(1);
upBytes = sk.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = KllDoublesSketch.heapify(wmem);
+ sk2 = KllHeapDoublesSketch.heapify(wmem);
upBytes2 = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -478,8 +478,8 @@ public class MiscDoublesTest {
int k = 20;
int n1 = 21;
int n2 = 21;
- KllDoublesSketch sk1 = new KllDoublesSketch(k);
- KllDoublesSketch sk2 = new KllDoublesSketch(k);
+ KllHeapDoublesSketch sk1 = new KllHeapDoublesSketch(k);
+ KllHeapDoublesSketch sk2 = new KllHeapDoublesSketch(k);
for (int i = 1; i <= n1; i++) {
sk1.update(i);
}
diff --git a/src/test/java/org/apache/datasketches/kll/MiscFloatsTest.java b/src/test/java/org/apache/datasketches/kll/MiscFloatsTest.java
index a53199a2..78f0a525 100644
--- a/src/test/java/org/apache/datasketches/kll/MiscFloatsTest.java
+++ b/src/test/java/org/apache/datasketches/kll/MiscFloatsTest.java
@@ -38,7 +38,7 @@ public class MiscFloatsTest {
@Test
public void checkBounds() {
- final KllFloatsSketch kll = new KllFloatsSketch(); //default k = 200
+ final KllHeapFloatsSketch kll = new KllHeapFloatsSketch(); //default k = 200
for (int i = 0; i < 1000; i++) {
kll.update(i);
}
@@ -55,49 +55,49 @@ public class MiscFloatsTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkHeapifyExceptions1() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
WritableMemory wmem = WritableMemory.writableWrap(sk.toByteArray());
wmem.putByte(6, (byte)3); //corrupt with odd M
- KllFloatsSketch.heapify(wmem);
+ KllHeapFloatsSketch.heapify(wmem);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkHeapifyExceptions2() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
WritableMemory wmem = WritableMemory.writableWrap(sk.toByteArray());
wmem.putByte(0, (byte)1); //corrupt preamble ints, should be 2
- KllFloatsSketch.heapify(wmem);
+ KllHeapFloatsSketch.heapify(wmem);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkHeapifyExceptions3() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
sk.update(1.0f);
sk.update(2.0f);
WritableMemory wmem = WritableMemory.writableWrap(sk.toByteArray());
wmem.putByte(0, (byte)1); //corrupt preamble ints, should be 5
- KllFloatsSketch.heapify(wmem);
+ KllHeapFloatsSketch.heapify(wmem);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkHeapifyExceptions4() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
WritableMemory wmem = WritableMemory.writableWrap(sk.toByteArray());
wmem.putByte(1, (byte)0); //corrupt SerVer, should be 1 or 2
- KllFloatsSketch.heapify(wmem);
+ KllHeapFloatsSketch.heapify(wmem);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkHeapifyExceptions5() {
- KllFloatsSketch sk = new KllFloatsSketch();
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch();
WritableMemory wmem = WritableMemory.writableWrap(sk.toByteArray());
wmem.putByte(2, (byte)0); //corrupt FamilyID, should be 15
- KllFloatsSketch.heapify(wmem);
+ KllHeapFloatsSketch.heapify(wmem);
}
@Test
public void checkMisc() {
- KllFloatsSketch sk = new KllFloatsSketch(8);
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch(8);
assertTrue(Objects.isNull(sk.getQuantiles(10)));
sk.toString(true, true);
for (int i = 0; i < 20; i++) { sk.update(i); }
@@ -112,12 +112,12 @@ public class MiscFloatsTest {
//@Test //enable static println(..) for visual checking
public void visualCheckToString() {
- final KllFloatsSketch sketch = new KllFloatsSketch(20);
+ final KllHeapFloatsSketch sketch = new KllHeapFloatsSketch(20);
for (int i = 0; i < 10; i++) { sketch.update(i + 1); }
final String s1 = sketch.toString(true, true);
println(s1);
- final KllFloatsSketch sketch2 = new KllFloatsSketch(20);
+ final KllHeapFloatsSketch sketch2 = new KllHeapFloatsSketch(20);
for (int i = 0; i < 400; i++) { sketch2.update(i + 1); }
println("\n" + sketch2.toString(true, true));
@@ -128,7 +128,7 @@ public class MiscFloatsTest {
@Test
public void viewCompactions() {
- KllFloatsSketch sk = new KllFloatsSketch(20);
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch(20);
show(sk, 20);
show(sk, 21); //compaction 1
show(sk, 43);
@@ -144,7 +144,7 @@ public class MiscFloatsTest {
show(sk, 108);
}
- private static void show(final KllFloatsSketch sk, int limit) {
+ private static void show(final KllHeapFloatsSketch sk, int limit) {
int i = (int) sk.getN();
for ( ; i < limit; i++) { sk.update(i + 1); }
println(sk.toString(true, true));
@@ -152,7 +152,7 @@ public class MiscFloatsTest {
@Test
public void checkGrowLevels() {
- KllFloatsSketch sk = new KllFloatsSketch(20);
+ KllHeapFloatsSketch sk = new KllHeapFloatsSketch(20);
for (int i = 1; i <= 21; i++) { sk.update(i); }
assertEquals(sk.getNumLevels(), 2);
assertEquals(sk.getFloatItemsArray().length, 33);
@@ -162,10 +162,10 @@ public class MiscFloatsTest {
@Test
public void checkSketchInitializeFloatHeap() {
int k = 20; //don't change this
- KllFloatsSketch sk;
+ KllHeapFloatsSketch sk;
println("#### CASE: FLOAT FULL HEAP");
- sk = new KllFloatsSketch(k);
+ sk = new KllHeapFloatsSketch(k);
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
//println(sk.toString(true, true));
assertEquals(sk.getK(), k);
@@ -182,7 +182,7 @@ public class MiscFloatsTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: FLOAT HEAP EMPTY");
- sk = new KllFloatsSketch(k);
+ sk = new KllHeapFloatsSketch(k);
//println(sk.toString(true, true));
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
@@ -198,7 +198,7 @@ public class MiscFloatsTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: FLOAT HEAP SINGLE");
- sk = new KllFloatsSketch(k);
+ sk = new KllHeapFloatsSketch(k);
sk.update(1);
//println(sk.toString(true, true));
assertEquals(sk.getK(), k);
@@ -218,19 +218,19 @@ public class MiscFloatsTest {
@Test
public void checkSketchInitializeFloatHeapifyCompactMem() {
int k = 20; //don't change this
- KllFloatsSketch sk;
- KllFloatsSketch sk2;
+ KllHeapFloatsSketch sk;
+ KllHeapFloatsSketch sk2;
byte[] compBytes;
WritableMemory wmem;
println("#### CASE: FLOAT FULL HEAPIFIED FROM COMPACT");
- sk2 = new KllFloatsSketch(k);
+ sk2 = new KllHeapFloatsSketch(k);
for (int i = 1; i <= k + 1; i++) { sk2.update(i); }
println(sk2.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = KllFloatsSketch.heapify(wmem);
+ sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
assertEquals(sk.getNumRetained(), 11);
@@ -245,12 +245,12 @@ public class MiscFloatsTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: FLOAT EMPTY HEAPIFIED FROM COMPACT");
- sk2 = new KllFloatsSketch(k);
+ sk2 = new KllHeapFloatsSketch(k);
//println(sk.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = KllFloatsSketch.heapify(wmem);
+ sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
assertEquals(sk.getNumRetained(), 0);
@@ -265,13 +265,13 @@ public class MiscFloatsTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: FLOAT SINGLE HEAPIFIED FROM COMPACT");
- sk2 = new KllFloatsSketch(k);
+ sk2 = new KllHeapFloatsSketch(k);
sk2.update(1);
//println(sk2.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = KllFloatsSketch.heapify(wmem);
+ sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
assertEquals(sk.getNumRetained(), 1);
@@ -289,19 +289,19 @@ public class MiscFloatsTest {
@Test
public void checkSketchInitializeFloatHeapifyUpdatableMem() {
int k = 20; //don't change this
- KllFloatsSketch sk;
- KllFloatsSketch sk2;
+ KllHeapFloatsSketch sk;
+ KllHeapFloatsSketch sk2;
byte[] compBytes;
WritableMemory wmem;
println("#### CASE: FLOAT FULL HEAPIFIED FROM UPDATABLE");
- sk2 = new KllFloatsSketch(k);
+ sk2 = new KllHeapFloatsSketch(k);
for (int i = 1; i <= k + 1; i++) { sk2.update(i); }
//println(sk2.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = KllFloatsSketch.heapify(wmem);
+ sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
assertEquals(sk.getNumRetained(), 11);
@@ -316,12 +316,12 @@ public class MiscFloatsTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: FLOAT EMPTY HEAPIFIED FROM UPDATABLE");
- sk2 = new KllFloatsSketch(k);
+ sk2 = new KllHeapFloatsSketch(k);
//println(sk.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = KllFloatsSketch.heapify(wmem);
+ sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
assertEquals(sk.getNumRetained(), 0);
@@ -336,13 +336,13 @@ public class MiscFloatsTest {
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: FLOAT SINGLE HEAPIFIED FROM UPDATABLE");
- sk2 = new KllFloatsSketch(k);
+ sk2 = new KllHeapFloatsSketch(k);
sk2.update(1);
//println(sk.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = KllFloatsSketch.heapify(wmem);
+ sk = KllHeapFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
assertEquals(sk.getNumRetained(), 1);
@@ -360,22 +360,22 @@ public class MiscFloatsTest {
@Test
public void checkMemoryToStringFloatCompact() {
int k = 20; //don't change this
- KllFloatsSketch sk;
- KllFloatsSketch sk2;
+ KllHeapFloatsSketch sk;
+ KllHeapFloatsSketch sk2;
byte[] compBytes;
byte[] compBytes2;
WritableMemory wmem;
String s;
println("#### CASE: FLOAT FULL COMPACT");
- sk = new KllFloatsSketch(k);
+ sk = new KllHeapFloatsSketch(k);
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
compBytes = sk.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = KllFloatsSketch.heapify(wmem);
+ sk2 = KllHeapFloatsSketch.heapify(wmem);
compBytes2 = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -384,13 +384,13 @@ public class MiscFloatsTest {
assertEquals(compBytes, compBytes2);
println("#### CASE: FLOAT EMPTY COMPACT");
- sk = new KllFloatsSketch(k);
+ sk = new KllHeapFloatsSketch(k);
compBytes = sk.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = KllFloatsSketch.heapify(wmem);
+ sk2 = KllHeapFloatsSketch.heapify(wmem);
compBytes2 = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -399,14 +399,14 @@ public class MiscFloatsTest {
assertEquals(compBytes, compBytes2);
println("#### CASE: FLOAT SINGLE COMPACT");
- sk = new KllFloatsSketch(k);
+ sk = new KllHeapFloatsSketch(k);
sk.update(1);
compBytes = sk.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = KllFloatsSketch.heapify(wmem);
+ sk2 = KllHeapFloatsSketch.heapify(wmem);
compBytes2 = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -418,22 +418,22 @@ public class MiscFloatsTest {
@Test
public void checkMemoryToStringFloatUpdatable() {
int k = 20; //don't change this
- KllFloatsSketch sk;
- KllFloatsSketch sk2;
+ KllHeapFloatsSketch sk;
+ KllHeapFloatsSketch sk2;
byte[] upBytes;
byte[] upBytes2;
WritableMemory wmem;
String s;
println("#### CASE: FLOAT FULL UPDATABLE");
- sk = new KllFloatsSketch(20);
+ sk = new KllHeapFloatsSketch(20);
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
upBytes = sk.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = KllFloatsSketch.heapify(wmem);
+ sk2 = KllHeapFloatsSketch.heapify(wmem);
upBytes2 = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -442,13 +442,13 @@ public class MiscFloatsTest {
assertEquals(upBytes, upBytes2);
println("#### CASE: FLOAT EMPTY UPDATABLE");
- sk = new KllFloatsSketch(k);
+ sk = new KllHeapFloatsSketch(k);
upBytes = sk.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = KllFloatsSketch.heapify(wmem);
+ sk2 = KllHeapFloatsSketch.heapify(wmem);
upBytes2 = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -457,14 +457,14 @@ public class MiscFloatsTest {
assertEquals(upBytes, upBytes2);
println("#### CASE: FLOAT SINGLE UPDATABLE");
- sk = new KllFloatsSketch(k);
+ sk = new KllHeapFloatsSketch(k);
sk.update(1);
upBytes = sk.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = KllFloatsSketch.heapify(wmem);
+ sk2 = KllHeapFloatsSketch.heapify(wmem);
upBytes2 = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -479,8 +479,8 @@ public class MiscFloatsTest {
int m = 4;
int n1 = 21;
int n2 = 43;
- KllFloatsSketch sk1 = new KllFloatsSketch(k, m);
- KllFloatsSketch sk2 = new KllFloatsSketch(k, m);
+ KllHeapFloatsSketch sk1 = new KllHeapFloatsSketch(k, m);
+ KllHeapFloatsSketch sk2 = new KllHeapFloatsSketch(k, m);
for (int i = 1; i <= n1; i++) {
sk1.update(i);
}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org