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/03/26 02:26:14 UTC
[datasketches-java] 12/12: Iteration 11, ready for review.
This is an automated email from the ASF dual-hosted git repository.
leerho pushed a commit to branch DirectKllDouble
in repository https://gitbox.apache.org/repos/asf/datasketches-java.git
commit 5e3dd401fa7f90b0213e48b825849b6b04faf237
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Fri Mar 25 19:24:56 2022 -0700
Iteration 11, ready for review.
---
.../datasketches/kll/KllDirectDoublesSketch.java | 2 -
...ublesSketch.java => KllDirectFloatsSketch.java} | 60 +++---
.../org/apache/datasketches/kll/KllSketch.java | 40 +++-
.../org/apache/datasketches/kll/package-info.java | 28 ++-
.../kll/KllDirectDoublesSketchIteratorTest.java | 78 ++++++++
.../kll/KllDirectDoublesSketchTest.java | 36 ++--
.../kll/KllDirectFloatsSketchIteratorTest.java | 78 ++++++++
...tchTest.java => KllDirectFloatsSketchTest.java} | 191 ++++++++++---------
.../datasketches/kll/KllDoublesSketchTest.java | 34 ++--
.../datasketches/kll/MiscDirectDoublesTest.java | 21 +--
...tDoublesTest.java => MiscDirectFloatsTest.java} | 203 ++++++++++-----------
11 files changed, 467 insertions(+), 304 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
index 99da030..45adf4a 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
@@ -44,8 +44,6 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
super(SketchType.DOUBLES_SKETCH, wmem, memReqSvr);
}
- //public int getNumRetained()
-
/**
* Returns an approximation to the Cumulative Distribution Function (CDF), which is the
* cumulative analog of the PMF, of the input stream given a set of splitPoint (values).
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
similarity index 84%
copy from src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
copy to src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
index 99da030..9eb52f3 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
@@ -26,26 +26,24 @@ import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableMemory;
/**
- * This class implements an off-heap doubles KllSketch via a WritableMemory instance of the sketch.
+ * This class implements an off-heap floats KllSketch via a WritableMemory instance of the sketch.
*
* <p>Please refer to the documentation in the package-info:<br>
* {@link org.apache.datasketches.kll}</p>
*
* @author Lee Rhodes, Kevin Lang
*/
-public final class KllDirectDoublesSketch extends KllDirectSketch {
+public class KllDirectFloatsSketch extends KllDirectSketch {
/**
*
* @param wmem the current WritableMemory
* @param memReqSvr the given MemoryRequestServer to request a larger WritableMemory
*/
- public KllDirectDoublesSketch(final WritableMemory wmem, final MemoryRequestServer memReqSvr) {
- super(SketchType.DOUBLES_SKETCH, wmem, memReqSvr);
+ public KllDirectFloatsSketch(final WritableMemory wmem, final MemoryRequestServer memReqSvr) {
+ super(SketchType.FLOATS_SKETCH, wmem, memReqSvr);
}
- //public int getNumRetained()
-
/**
* Returns an approximation to the Cumulative Distribution Function (CDF), which is the
* cumulative analog of the PMF, of the input stream given a set of splitPoint (values).
@@ -55,7 +53,7 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
*
* <p>If the sketch is empty this returns null.</p>
*
- * @param splitPoints an array of <i>m</i> unique, monotonically increasing double values
+ * @param splitPoints an array of <i>m</i> unique, monotonically increasing float values
* that divide the real number line into <i>m+1</i> consecutive disjoint intervals.
* The definition of an "interval" is inclusive of the left splitPoint (or minimum value) and
* exclusive of the right splitPoint, with the exception that the last interval will include
@@ -67,8 +65,8 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
* CDF array is the sum of the returned values in positions 0 through j of the returned PMF
* array.
*/
- public double[] getCDF(final double[] splitPoints) {
- return getDoublesPmfOrCdf(splitPoints, true);
+ public double[] getCDF(final float[] splitPoints) {
+ return getFloatsPmfOrCdf(splitPoints, true);
}
/**
@@ -77,8 +75,8 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
*
* @return the max value of the stream
*/
- public double getMaxValue() {
- return getMaxDoubleValue();
+ public float getMaxValue() {
+ return getMaxFloatValue();
}
/**
@@ -87,8 +85,8 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
*
* @return the min value of the stream
*/
- public double getMinValue() {
- return getMinDoubleValue();
+ public float getMinValue() {
+ return getMinFloatValue();
}
/**
@@ -100,7 +98,7 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
*
* <p>If the sketch is empty this returns null.</p>
*
- * @param splitPoints an array of <i>m</i> unique, monotonically increasing double values
+ * @param splitPoints an array of <i>m</i> unique, monotonically increasing float values
* that divide the real number line into <i>m+1</i> consecutive disjoint intervals.
* The definition of an "interval" is inclusive of the left splitPoint (or minimum value) and
* exclusive of the right splitPoint, with the exception that the last interval will include
@@ -112,8 +110,8 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
* The definition of an "interval" is inclusive of the left splitPoint and exclusive of the right
* splitPoint, with the exception that the last interval will include maximum value.
*/
- public double[] getPMF(final double[] splitPoints) {
- return getDoublesPmfOrCdf(splitPoints, false);
+ public double[] getPMF(final float[] splitPoints) {
+ return getFloatsPmfOrCdf(splitPoints, false);
}
/**
@@ -134,8 +132,8 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
*
* @return the approximation to the value at the given fraction
*/
- public double getQuantile(final double fraction) {
- return getDoublesQuantile(fraction);
+ public float getQuantile(final double fraction) {
+ return getFloatsQuantile(fraction);
}
/**
@@ -145,7 +143,7 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
* @return the lower bound of the value interval in which the true quantile of the given rank
* exists with a confidence of at least 99%. Returns NaN if the sketch is empty.
*/
- public double getQuantileLowerBound(final double fraction) {
+ public float getQuantileLowerBound(final double fraction) {
return getQuantile(max(0, fraction - KllHelper.getNormalizedRankError(getDyMinK(), false)));
}
@@ -167,8 +165,8 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
* @return array of approximations to the given fractions in the same order as given fractions
* array.
*/
- public double[] getQuantiles(final double[] fractions) {
- return getDoublesQuantiles(fractions);
+ public float[] getQuantiles(final double[] fractions) {
+ return getFloatsQuantiles(fractions);
}
/**
@@ -185,7 +183,7 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
* @return array of approximations to the given fractions in the same order as given fractions
* array.
*/
- public double[] getQuantiles(final int numEvenlySpaced) {
+ public float[] getQuantiles(final int numEvenlySpaced) {
if (isEmpty()) { return null; }
return getQuantiles(org.apache.datasketches.Util.evenlySpaced(0.0, 1.0, numEvenlySpaced));
}
@@ -197,7 +195,7 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
* @return the upper bound of the value interval in which the true quantile of the given rank
* exists with a confidence of at least 99%. Returns NaN if the sketch is empty.
*/
- public double getQuantileUpperBound(final double fraction) {
+ public float getQuantileUpperBound(final double fraction) {
return getQuantile(min(1.0, fraction + KllHelper.getNormalizedRankError(getDyMinK(), false)));
}
@@ -213,15 +211,15 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
* @param value to be ranked
* @return an approximate rank of the given value
*/
- public double getRank(final double value) {
- return getDoubleRank(value);
+ public double getRank(final float value) {
+ return getFloatRank(value);
}
/**
* @return the iterator for this class
*/
- public KllDoublesSketchIterator iterator() {
- return new KllDoublesSketchIterator(getDoubleItemsArray(), getLevelsArray(), getNumLevels());
+ public KllFloatsSketchIterator iterator() {
+ return new KllFloatsSketchIterator(getFloatItemsArray(), getLevelsArray(), getNumLevels());
}
/**
@@ -230,8 +228,8 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
*/
public void merge(final KllSketch other) {
if (!other.isDirect()) { kllSketchThrow(32); }
- if (!other.isDoublesSketch()) { kllSketchThrow(33); }
- mergeDoubleImpl(other);
+ if (!other.isFloatsSketch()) { kllSketchThrow(34); }
+ mergeFloatImpl(other);
}
@Override
@@ -244,8 +242,8 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
return toStringImpl(withLevels, withData);
}
- public void update(final double value) {
- updateDouble(value);
+ public void update(final float value) {
+ updateFloat(value);
}
}
diff --git a/src/main/java/org/apache/datasketches/kll/KllSketch.java b/src/main/java/org/apache/datasketches/kll/KllSketch.java
index fb4252c..aeb67d2 100644
--- a/src/main/java/org/apache/datasketches/kll/KllSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllSketch.java
@@ -729,8 +729,8 @@ public enum SketchType { FLOATS_SKETCH, DOUBLES_SKETCH }
//Update min, max values
final double otherMin = other.getMinDoubleValue();
final double otherMax = other.getMaxDoubleValue();
- if (Double.isNaN(myMin) || otherMin <= myMin) { setMinDoubleValue(otherMin); }
- if (Double.isNaN(myMax) || otherMax >= myMax) { setMaxDoubleValue(otherMax); }
+ setMinDoubleValue(resolveDoubleMinValue(myMin, otherMin));
+ setMaxDoubleValue(resolveDoubleMaxValue(myMax, otherMax));
//Update numLevels, levelsArray, items
setNumLevels(myNewNumLevels);
@@ -739,6 +739,21 @@ public enum SketchType { FLOATS_SKETCH, DOUBLES_SKETCH }
assert KllHelper.sumTheSampleWeights(getNumLevels(), getLevelsArray()) == getN();
}
+ private static double resolveDoubleMinValue(final double myMin, final double otherMin) {
+ if (Double.isNaN(myMin) && Double.isNaN(otherMin)) { return Double.NaN; }
+ if (Double.isNaN(myMin)) { return otherMin; }
+ if (Double.isNaN(otherMin)) { return myMin; }
+ return min(myMin, otherMin);
+ }
+
+ private static double resolveDoubleMaxValue(final double myMax, final double otherMax) {
+ if (Double.isNaN(myMax) && Double.isNaN(otherMax)) { return Double.NaN; }
+ if (Double.isNaN(myMax)) { return otherMax; }
+ if (Double.isNaN(otherMax)) { return myMax; }
+ return max(myMax, otherMax);
+ }
+
+
final void mergeFloatImpl(final KllSketch other) {
if (other.isEmpty()) { return; }
final long finalN = getN() + other.getN();
@@ -825,8 +840,8 @@ public enum SketchType { FLOATS_SKETCH, DOUBLES_SKETCH }
//Update min, max values
final float otherMin = other.getMinFloatValue();
final float otherMax = other.getMaxFloatValue();
- if (Float.isNaN(myMin) || otherMin < myMin) { setMinFloatValue(otherMin); }
- if (Float.isNaN(myMax) || otherMax > myMax) { setMaxFloatValue(otherMax); }
+ setMinFloatValue(resolveFloatMinValue(myMin, otherMin));
+ setMaxFloatValue(resolveFloatMaxValue(myMax, otherMax));
//Update numLevels, levelsArray, items
setNumLevels(myNewNumLevels);
@@ -835,6 +850,21 @@ public enum SketchType { FLOATS_SKETCH, DOUBLES_SKETCH }
assert KllHelper.sumTheSampleWeights(getNumLevels(), getLevelsArray()) == getN();
}
+ private static float resolveFloatMinValue(final float myMin, final float otherMin) {
+ if (Float.isNaN(myMin) && Float.isNaN(otherMin)) { return Float.NaN; }
+ if (Float.isNaN(myMin)) { return otherMin; }
+ if (Float.isNaN(otherMin)) { return myMin; }
+ return min(myMin, otherMin);
+ }
+
+ private static float resolveFloatMaxValue(final float myMax, final float otherMax) {
+ if (Float.isNaN(myMax) && Float.isNaN(otherMax)) { return Float.NaN; }
+ if (Float.isNaN(myMax)) { return otherMax; }
+ if (Float.isNaN(otherMax)) { return myMax; }
+ return max(myMax, otherMax);
+ }
+
+
abstract void setDoubleItemsArray(double[] floatItems);
abstract void setDoubleItemsArrayAt(int index, double value);
@@ -1381,7 +1411,7 @@ public enum SketchType { FLOATS_SKETCH, DOUBLES_SKETCH }
} else {
if (direct) {
myFloatItemsArr = getFloatItemsArray();
- System.arraycopy(myDoubleItemsArr, myLevelsArr[0], myDoubleItemsArr, myLevelsArr[0] + halfAdjPop, amount);
+ System.arraycopy(myFloatItemsArr, myLevelsArr[0], myFloatItemsArr, myLevelsArr[0] + halfAdjPop, amount);
setFloatItemsArray(myFloatItemsArr);
} else {
System.arraycopy(myFloatItemsArr, myLevelsArr[0], myFloatItemsArr, myLevelsArr[0] + halfAdjPop, amount);
diff --git a/src/main/java/org/apache/datasketches/kll/package-info.java b/src/main/java/org/apache/datasketches/kll/package-info.java
index 141c25f..6dcc6c2 100644
--- a/src/main/java/org/apache/datasketches/kll/package-info.java
+++ b/src/main/java/org/apache/datasketches/kll/package-info.java
@@ -35,16 +35,17 @@
*
* <p>The <i>normalized rank</i> (<i>rank</i>) of any specific value is defined as its
* <i>absolute rank</i> divided by <i>N</i>.
- * Thus, the <i>normalized rank</i> is a value between zero and one.
+ * Thus, the <i>normalized rank</i> is a value in the interval [0.0, 1.0), exclusive.
* In the documentation and Javadocs for this sketch <i>absolute rank</i> is never used so any
* reference to just <i>rank</i> should be interpreted to mean <i>normalized rank</i>.
*
* <p>This sketch is configured with a parameter <i>k</i>, which affects the size of the sketch
* and its estimation error.
*
- * <p>The estimation error is commonly called <i>epsilon</i> (or <i>eps</i>) and is a fraction
- * between zero and one. Larger values of <i>k</i> result in smaller values of epsilon.
- * Epsilon is always with respect to the rank and cannot be applied to the
+ * <p>In the research literature, the estimation error is commonly called <i>epsilon</i>
+ * (or <i>eps</i>) and is a fraction between zero and one.
+ * Larger values of <i>k</i> result in smaller values of epsilon.
+ * The epsilon error is always with respect to the rank and cannot be applied to the
* corresponding values.
*
* <p>The relationship between the normalized rank and the corresponding values can be viewed
@@ -147,6 +148,25 @@
* <li>Then <i>v<sub>lo</sub> ≤ v ≤ v<sub>hi</sub></i>, with 99% confidence.</li>
* </ul>
*
+ * <p>The current implementations of the KLL sketch in the DataSketches Java library component include:</p>
+ *
+ * <ul>
+ * <li><b>KllFloatsSketch</b>: This operates on the Java heap and uses the java <i>float</i> primitive for the
+ * smallest possible size. It can be serialized to a compact, immutable form or to an updatable form suitable for
+ * use by the Kll Direct sketches.</li>
+ * <li><b>KllDoublesSketch</b>: This operates on the Java heap and uses the java <i>double</i> primitive for a much
+ * larger range of numeric values, and is larger as a result. It can be serialized to a compact, immutable form or
+ * to an updatable form suitable for use by the Kll Direct sketches.</li>
+ * <li><b>KllDirectFloatsSketch</b>: This is intended to operate off-heap and performs all of its operations in one
+ * contiguous chunk of memory. It uses the java <i>float</i> primitive for the smallest possible size off-heap.</li>
+ * <li><b>KllDirectDoublesSketch</b>: This is intended to operate off-heap and performs all of its operations in one
+ * contiguous chunk of memory. It uses the java <i>double</i> primitive for a much larger range of numeric values,
+ * and is larger as a result.</li>
+ * </ul>
+ *
+ * <p>Please visit our website: <a href="https://datasketches.apache.org">DataSketches Home Page</a> for more
+ * information.</p>
+ *
* @author Kevin Lang
* @author Alexander Saydakov
* @author Lee Rhodes
diff --git a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchIteratorTest.java b/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchIteratorTest.java
new file mode 100644
index 0000000..bb325a4
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchIteratorTest.java
@@ -0,0 +1,78 @@
+/*
+ * 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.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+public class KllDirectDoublesSketchIteratorTest {
+ private static final DefaultMemoryRequestServer memReqSvr = new DefaultMemoryRequestServer();
+
+ @Test
+ public void emptySketch() {
+ final KllDirectDoublesSketch sketch = getDDSketch(200, 0);
+ KllDoublesSketchIterator it = sketch.iterator();
+ Assert.assertFalse(it.next());
+ }
+
+ @Test
+ public void oneItemSketch() {
+ final KllDirectDoublesSketch sketch = getDDSketch(200, 0);
+ sketch.update(0);
+ KllDoublesSketchIterator it = sketch.iterator();
+ Assert.assertTrue(it.next());
+ Assert.assertEquals(it.getValue(), 0f);
+ Assert.assertEquals(it.getWeight(), 1);
+ Assert.assertFalse(it.next());
+ }
+
+ @Test
+ public void bigSketches() {
+ for (int n = 1000; n < 100000; n += 2000) {
+ final KllDirectDoublesSketch sketch = getDDSketch(200, 0);
+ for (int i = 0; i < n; i++) {
+ sketch.update(i);
+ }
+ KllDoublesSketchIterator it = sketch.iterator();
+ int count = 0;
+ int weight = 0;
+ while (it.next()) {
+ count++;
+ weight += it.getWeight();
+ }
+ Assert.assertEquals(count, sketch.getNumRetained());
+ Assert.assertEquals(weight, n);
+ }
+ }
+
+ private static KllDirectDoublesSketch getDDSketch(final int k, final int n) {
+ KllDoublesSketch sk = new KllDoublesSketch(k);
+ for (int i = 1; i <= n; i++) { sk.update(i); }
+ byte[] byteArr = sk.toUpdatableByteArray();
+ WritableMemory wmem = WritableMemory.writableWrap(byteArr);
+
+ KllDirectDoublesSketch ddsk = new KllDirectDoublesSketch(wmem, memReqSvr);
+ return ddsk;
+ }
+
+}
+
diff --git a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
index 572b3b1..a12a50c 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
@@ -84,9 +84,9 @@ public class KllDirectDoublesSketchTest {
assertEquals(sketch.getNumRetained(), 1);
assertEquals(sketch.getRank(1), 0.0);
assertEquals(sketch.getRank(2), 1.0);
- assertEquals(sketch.getMinValue(), 1f);
- assertEquals(sketch.getMaxValue(), 1f);
- assertEquals(sketch.getQuantile(0.5), 1f);
+ assertEquals(sketch.getMinValue(), 1.0);
+ assertEquals(sketch.getMaxValue(), 1.0);
+ assertEquals(sketch.getQuantile(0.5), 1.0);
}
@Test
@@ -209,8 +209,8 @@ public class KllDirectDoublesSketchTest {
assertFalse(sketch1.isEmpty());
assertEquals(sketch1.getN(), 2 * n);
- assertEquals(sketch1.getMinValue(), 0f);
- assertEquals(sketch1.getMaxValue(), 2f * n - 1f);
+ assertEquals(sketch1.getMinValue(), 0);
+ assertEquals(sketch1.getMaxValue(), 2.0 * n - 1.0);
assertEquals(sketch1.getQuantile(0.5), n, n * PMF_EPS_FOR_K_128);
}
@@ -230,17 +230,17 @@ public class KllDirectDoublesSketchTest {
assertFalse(sketch1.isEmpty());
assertEquals(sketch1.getN(), n);
- assertEquals(sketch1.getMinValue(), 0f);
- assertEquals(sketch1.getMaxValue(), n - 1f);
- assertEquals(sketch1.getQuantile(0.5), n / 2f, n / 2 * PMF_EPS_FOR_K_256);
+ assertEquals(sketch1.getMinValue(), 0);
+ assertEquals(sketch1.getMaxValue(), n - 1.0);
+ assertEquals(sketch1.getQuantile(0.5), n / 2.0, n / 2 * PMF_EPS_FOR_K_256);
//merge the other way
sketch2.merge(sketch1);
assertFalse(sketch1.isEmpty());
assertEquals(sketch1.getN(), n);
- assertEquals(sketch1.getMinValue(), 0f);
- assertEquals(sketch1.getMaxValue(), n - 1f);
- assertEquals(sketch1.getQuantile(0.5), n / 2f, n / 2 * PMF_EPS_FOR_K_256);
+ assertEquals(sketch1.getMinValue(), 0);
+ assertEquals(sketch1.getMaxValue(), n - 1.0);
+ assertEquals(sketch1.getQuantile(0.5), n / 2.0, n / 2 * PMF_EPS_FOR_K_256);
}
@Test
@@ -266,7 +266,7 @@ public class KllDirectDoublesSketchTest {
sketch1.update(1);
sketch2.update(2);
sketch2.merge(sketch1);
- assertEquals(sketch2.getMinValue(), 1.0F);
+ assertEquals(sketch2.getMinValue(), 1.0);
}
@Test
@@ -277,8 +277,8 @@ public class KllDirectDoublesSketchTest {
sketch1.update(i);
}
sketch2.merge(sketch1);
- assertEquals(sketch2.getMinValue(), 1F);
- assertEquals(sketch2.getMaxValue(), 1_000_000F);
+ assertEquals(sketch2.getMinValue(), 1);
+ assertEquals(sketch2.getMaxValue(), 1_000_000);
}
@SuppressWarnings("unused")
@@ -436,12 +436,12 @@ public class KllDirectDoublesSketchTest {
final double[] quantiles1 = sketch.getQuantiles(new double[] {0, 0.5, 1});
final double[] quantiles2 = sketch.getQuantiles(3);
assertEquals(quantiles1, quantiles2);
- assertEquals(quantiles1[0], 1f);
- assertEquals(quantiles1[1], 2f);
- assertEquals(quantiles1[2], 3f);
+ assertEquals(quantiles1[0], 1.0);
+ assertEquals(quantiles1[1], 2.0);
+ assertEquals(quantiles1[2], 3.0);
}
- //@Test
+ @Test
public void checkSimpleMergeDirect() { //used for troubleshooting
int k = 20;
int n1 = 21;
diff --git a/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchIteratorTest.java b/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchIteratorTest.java
new file mode 100644
index 0000000..60ea42c
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchIteratorTest.java
@@ -0,0 +1,78 @@
+/*
+ * 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.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+public class KllDirectFloatsSketchIteratorTest {
+ private static final DefaultMemoryRequestServer memReqSvr = new DefaultMemoryRequestServer();
+
+ @Test
+ public void emptySketch() {
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 0);
+ KllFloatsSketchIterator it = sketch.iterator();
+ Assert.assertFalse(it.next());
+ }
+
+ @Test
+ public void oneItemSketch() {
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 0);
+ sketch.update(0);
+ KllFloatsSketchIterator it = sketch.iterator();
+ Assert.assertTrue(it.next());
+ Assert.assertEquals(it.getValue(), 0f);
+ Assert.assertEquals(it.getWeight(), 1);
+ Assert.assertFalse(it.next());
+ }
+
+ @Test
+ public void bigSketches() {
+ for (int n = 1000; n < 100000; n += 2000) {
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 0);
+ for (int i = 0; i < n; i++) {
+ sketch.update(i);
+ }
+ KllFloatsSketchIterator it = sketch.iterator();
+ int count = 0;
+ int weight = 0;
+ while (it.next()) {
+ count++;
+ weight += it.getWeight();
+ }
+ Assert.assertEquals(count, sketch.getNumRetained());
+ Assert.assertEquals(weight, n);
+ }
+ }
+
+ private static KllDirectFloatsSketch getDFSketch(final int k, final int n) {
+ KllFloatsSketch sk = new KllFloatsSketch(k);
+ for (int i = 1; i <= n; i++) { sk.update(i); }
+ byte[] byteArr = sk.toUpdatableByteArray();
+ WritableMemory wmem = WritableMemory.writableWrap(byteArr);
+
+ KllDirectFloatsSketch dfsk = new KllDirectFloatsSketch(wmem, memReqSvr);
+ return dfsk;
+ }
+
+}
+
diff --git a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java
similarity index 76%
copy from src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
copy to src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java
index 572b3b1..f7ce555 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java
@@ -34,9 +34,7 @@ import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
-
-@SuppressWarnings("javadoc")
-public class KllDirectDoublesSketchTest {
+public class KllDirectFloatsSketchTest {
private static final double PMF_EPS_FOR_K_8 = 0.35; // PMF rank error (epsilon) for k=8
private static final double PMF_EPS_FOR_K_128 = 0.025; // PMF rank error (epsilon) for k=128
@@ -46,38 +44,38 @@ public class KllDirectDoublesSketchTest {
@Test
public void empty() {
- final KllDirectDoublesSketch sketch = getDDSketch(200, 0);
- sketch.update(Double.NaN); // this must not change anything
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 0);
+ sketch.update(Float.NaN); // this must not change anything
assertTrue(sketch.isEmpty());
assertEquals(sketch.getN(), 0);
assertEquals(sketch.getNumRetained(), 0);
assertTrue(Double.isNaN(sketch.getRank(0)));
- assertTrue(Double.isNaN(sketch.getMinValue()));
- assertTrue(Double.isNaN(sketch.getMaxValue()));
- assertTrue(Double.isNaN(sketch.getQuantile(0.5)));
+ assertTrue(Float.isNaN(sketch.getMinValue()));
+ assertTrue(Float.isNaN(sketch.getMaxValue()));
+ assertTrue(Float.isNaN(sketch.getQuantile(0.5)));
assertNull(sketch.getQuantiles(new double[] {0}));
- assertNull(sketch.getPMF(new double[] {0}));
+ assertNull(sketch.getPMF(new float[] {0}));
assertNotNull(sketch.toString(true, true));
assertNotNull(sketch.toString());
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void getQuantileInvalidArg() {
- final KllDirectDoublesSketch sketch = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 0);
sketch.update(1);
sketch.getQuantile(-1.0);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void getQuantilesInvalidArg() {
- final KllDirectDoublesSketch sketch = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 0);
sketch.update(1);
sketch.getQuantiles(new double[] {2.0});
}
@Test
public void oneItem() {
- final KllDirectDoublesSketch sketch = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 0);
sketch.update(1);
assertFalse(sketch.isEmpty());
assertEquals(sketch.getN(), 1);
@@ -91,7 +89,7 @@ public class KllDirectDoublesSketchTest {
@Test
public void manyItemsEstimationMode() {
- final KllDirectDoublesSketch sketch = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 0);
final int n = 1_000_000;
for (int i = 0; i < n; i++) {
@@ -106,7 +104,7 @@ public class KllDirectDoublesSketchTest {
}
// test getPMF
- final double[] pmf = sketch.getPMF(new double[] {n / 2}); // split at median
+ final double[] pmf = sketch.getPMF(new float[] {n / 2}); // split at median
assertEquals(pmf.length, 2);
assertEquals(pmf[0], 0.5, PMF_EPS_FOR_K_256);
assertEquals(pmf[1], 0.5, PMF_EPS_FOR_K_256);
@@ -123,8 +121,8 @@ public class KllDirectDoublesSketchTest {
fractions[i] = (double) i / 1000;
reverseFractions[1000 - i] = fractions[i];
}
- final double[] quantiles = sketch.getQuantiles(fractions);
- final double[] reverseQuantiles = sketch.getQuantiles(reverseFractions);
+ final float[] quantiles = sketch.getQuantiles(fractions);
+ final float[] reverseQuantiles = sketch.getQuantiles(reverseFractions);
double previousQuantile = 0;
for (int i = 0; i <= 1000; i++) {
final double quantile = sketch.getQuantile(fractions[i]);
@@ -137,9 +135,9 @@ public class KllDirectDoublesSketchTest {
@Test
public void getRankGetCdfGetPmfConsistency() {
- final KllDirectDoublesSketch sketch = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 0);
final int n = 1000;
- final double[] values = new double[n];
+ final float[] values = new float[n];
for (int i = 0; i < n; i++) {
sketch.update(i);
values[i] = i;
@@ -160,12 +158,12 @@ public class KllDirectDoublesSketchTest {
@Test
public void merge() {
- final KllDirectDoublesSketch sketch1 = getDDSketch(200, 0);
- final KllDirectDoublesSketch sketch2 = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(200, 0);
+ final KllDirectFloatsSketch sketch2 = getDFSketch(200, 0);
final int n = 10_000;
for (int i = 0; i < n; i++) {
- sketch1.update(i * 1.0);
- sketch2.update((2 * n - i - 1) * 1.0);
+ sketch1.update(i * 1.0F);
+ sketch2.update((2 * n - i - 1) * 1.0F);
}
assertEquals(sketch1.getMinValue(), 0.0);
@@ -179,14 +177,14 @@ public class KllDirectDoublesSketchTest {
assertFalse(sketch1.isEmpty());
assertEquals(sketch1.getN(), 2L * n);
assertEquals(sketch1.getMinValue(), 0.0);
- assertEquals(sketch1.getMaxValue(), (2 * n - 1) * 1.0);
- assertEquals(sketch1.getQuantile(0.5), n * 1.0, n * PMF_EPS_FOR_K_256);
+ assertEquals(sketch1.getMaxValue(), (2 * n - 1) * 1.0F);
+ assertEquals(sketch1.getQuantile(0.5), n * 1.0F, n * PMF_EPS_FOR_K_256);
}
@Test
public void mergeLowerK() {
- final KllDirectDoublesSketch sketch1 = getDDSketch(256, 0);
- final KllDirectDoublesSketch sketch2 = getDDSketch(128, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(256, 0);
+ final KllDirectFloatsSketch sketch2 = getDFSketch(128, 0);
final int n = 10_000;
for (int i = 0; i < n; i++) {
sketch1.update(i);
@@ -216,8 +214,8 @@ public class KllDirectDoublesSketchTest {
@Test
public void mergeEmptyLowerK() {
- final KllDirectDoublesSketch sketch1 = getDDSketch(256, 0);
- final KllDirectDoublesSketch sketch2 = getDDSketch(128, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(256, 0);
+ final KllDirectFloatsSketch sketch2 = getDFSketch(128, 0);
final int n = 10000;
for (int i = 0; i < n; i++) {
sketch1.update(i);
@@ -245,8 +243,8 @@ public class KllDirectDoublesSketchTest {
@Test
public void mergeExactModeLowerK() {
- final KllDirectDoublesSketch sketch1 = getDDSketch(256, 0);
- final KllDirectDoublesSketch sketch2 = getDDSketch(128, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(256, 0);
+ final KllDirectFloatsSketch sketch2 = getDFSketch(128, 0);
final int n = 10000;
for (int i = 0; i < n; i++) {
sketch1.update(i);
@@ -261,8 +259,8 @@ public class KllDirectDoublesSketchTest {
@Test
public void mergeMinMinValueFromOther() {
- final KllDirectDoublesSketch sketch1 = getDDSketch(200, 0);
- final KllDirectDoublesSketch sketch2 = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(200, 0);
+ final KllDirectFloatsSketch sketch2 = getDFSketch(200, 0);
sketch1.update(1);
sketch2.update(2);
sketch2.merge(sketch1);
@@ -271,31 +269,32 @@ public class KllDirectDoublesSketchTest {
@Test
public void mergeMinAndMaxFromOther() {
- final KllDirectDoublesSketch sketch1 = getDDSketch(200, 0);
- final KllDirectDoublesSketch sketch2 = getDDSketch(200, 0);
- for (int i = 1; i <= 1_000_000; i++) {
+ final KllDirectFloatsSketch sketch1 = getDFSketch(8, 0); //was 200
+ final KllDirectFloatsSketch sketch2 = getDFSketch(8, 0); //was 200
+ for (int i = 1; i <= 9; i++) { //was 1_000_000
sketch1.update(i);
}
+ //System.out.println(sketch1.toString(true, true));
sketch2.merge(sketch1);
assertEquals(sketch2.getMinValue(), 1F);
- assertEquals(sketch2.getMaxValue(), 1_000_000F);
+ assertEquals(sketch2.getMaxValue(), 9F); //was 1_000_000
}
@SuppressWarnings("unused")
@Test(expectedExceptions = SketchesArgumentException.class)
public void kTooSmall() {
- final KllDirectDoublesSketch sketch1 = getDDSketch(MIN_K - 1, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(MIN_K - 1, 0);
}
@SuppressWarnings("unused")
@Test(expectedExceptions = SketchesArgumentException.class)
public void kTooLarge() {
- final KllDirectDoublesSketch sketch1 = getDDSketch(MAX_K + 1, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(MAX_K + 1, 0);
}
@Test
public void minK() {
- final KllDirectDoublesSketch sketch = getDDSketch(MIN_K, 0);
+ final KllDirectFloatsSketch sketch = getDFSketch(MIN_K, 0);
for (int i = 0; i < 1000; i++) {
sketch.update(i);
}
@@ -305,7 +304,7 @@ public class KllDirectDoublesSketchTest {
@Test
public void maxK() {
- final KllDirectDoublesSketch sketch = getDDSketch(MAX_K, 0);
+ final KllDirectFloatsSketch sketch = getDFSketch(MAX_K, 0);
for (int i = 0; i < 1000; i++) {
sketch.update(i);
}
@@ -315,9 +314,9 @@ public class KllDirectDoublesSketchTest {
@Test
public void serializeDeserializeEmpty() { //compact serialize then heapify using KllDoublesSketch
- final KllDirectDoublesSketch sketch1 = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(200, 0);
final byte[] bytes = sketch1.toByteArray();
- final KllDoublesSketch sketch2 = KllDoublesSketch.heapify(Memory.wrap(bytes));
+ final KllFloatsSketch sketch2 = KllFloatsSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertTrue(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), sketch1.getNumRetained());
@@ -330,9 +329,9 @@ public class KllDirectDoublesSketchTest {
@Test
public void serializeDeserializeEmpty2() { //updatable serialize then new (loaded) KllDirectDoublesSketch
- final KllDirectDoublesSketch sketch1 = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(200, 0);
final byte[] bytes = sketch1.toUpdatableByteArray();
- final KllDirectDoublesSketch sketch2 = new KllDirectDoublesSketch(WritableMemory.writableWrap(bytes),memReqSvr);
+ final KllDirectFloatsSketch sketch2 = new KllDirectFloatsSketch(WritableMemory.writableWrap(bytes),memReqSvr);
assertEquals(bytes.length, sketch1.getCurrentUpdatableSerializedSizeBytes());
assertTrue(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), sketch1.getNumRetained());
@@ -345,10 +344,10 @@ public class KllDirectDoublesSketchTest {
@Test
public void serializeDeserializeOneItem() { //compact serialize then heapify using KllDoublesSketch
- final KllDirectDoublesSketch sketch1 = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(200, 0);
sketch1.update(1);
final byte[] bytes = sketch1.toByteArray();
- final KllDoublesSketch sketch2 = KllDoublesSketch.heapify(Memory.wrap(bytes));
+ final KllFloatsSketch sketch2 = KllFloatsSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), 1);
@@ -356,15 +355,15 @@ public class KllDirectDoublesSketchTest {
assertEquals(sketch2.getNormalizedRankError(false), sketch1.getNormalizedRankError(false));
assertFalse(Double.isNaN(sketch2.getMinValue()));
assertFalse(Double.isNaN(sketch2.getMaxValue()));
- assertEquals(sketch2.getCurrentCompactSerializedSizeBytes(), 8 + Double.BYTES);
+ assertEquals(sketch2.getCurrentCompactSerializedSizeBytes(), 8 + Float.BYTES);
}
@Test
public void serializeDeserializeOneItem2() { //updatable serialize then new (loaded) KllDirectDoublesSketch
- final KllDirectDoublesSketch sketch1 = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(200, 0);
sketch1.update(1);
final byte[] bytes = sketch1.toUpdatableByteArray();
- final KllDirectDoublesSketch sketch2 = new KllDirectDoublesSketch(WritableMemory.writableWrap(bytes),memReqSvr);
+ final KllDirectFloatsSketch sketch2 = new KllDirectFloatsSketch(WritableMemory.writableWrap(bytes),memReqSvr);
assertEquals(bytes.length, sketch1.getCurrentUpdatableSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), 1);
@@ -372,18 +371,18 @@ public class KllDirectDoublesSketchTest {
assertEquals(sketch2.getNormalizedRankError(false), sketch1.getNormalizedRankError(false));
assertFalse(Double.isNaN(sketch2.getMinValue()));
assertFalse(Double.isNaN(sketch2.getMaxValue()));
- assertEquals(sketch2.getCurrentCompactSerializedSizeBytes(), 8 + Double.BYTES);
+ assertEquals(sketch2.getCurrentCompactSerializedSizeBytes(), 8 + Float.BYTES);
}
@Test
public void serializeDeserialize() { //compact serialize then heapify using KllDoublesSketch
- final KllDirectDoublesSketch sketch1 = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(200, 0);
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 KllFloatsSketch sketch2 = KllFloatsSketch.heapify(Memory.wrap(bytes));
assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), sketch1.getNumRetained());
@@ -396,13 +395,13 @@ public class KllDirectDoublesSketchTest {
@Test
public void serializeDeserialize2() { //updatable serialize then new (loaded) KllDirectDoublesSketch
- final KllDirectDoublesSketch sketch1 = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch1 = getDFSketch(200, 0);
final int n = 1000;
for (int i = 0; i < n; i++) {
sketch1.update(i);
}
final byte[] bytes = sketch1.toUpdatableByteArray();
- final KllDirectDoublesSketch sketch2 = new KllDirectDoublesSketch(WritableMemory.writableWrap(bytes),memReqSvr);
+ final KllDirectFloatsSketch sketch2 = new KllDirectFloatsSketch(WritableMemory.writableWrap(bytes),memReqSvr);
assertEquals(bytes.length, sketch1.getCurrentUpdatableSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), sketch1.getNumRetained());
@@ -415,39 +414,39 @@ public class KllDirectDoublesSketchTest {
@Test(expectedExceptions = SketchesArgumentException.class)
public void outOfOrderSplitPoints() {
- final KllDirectDoublesSketch sketch = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 0);
sketch.update(0);
- sketch.getCDF(new double[] {1, 0});
+ sketch.getCDF(new float[] {1, 0});
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void nanSplitPoint() {
- final KllDirectDoublesSketch sketch = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 0);
sketch.update(0);
- sketch.getCDF(new double[] {Double.NaN});
+ sketch.getCDF(new float[] {Float.NaN});
}
@Test
public void getQuantiles() {
- final KllDirectDoublesSketch sketch = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 0);
sketch.update(1);
sketch.update(2);
sketch.update(3);
- final double[] quantiles1 = sketch.getQuantiles(new double[] {0, 0.5, 1});
- final double[] quantiles2 = sketch.getQuantiles(3);
+ final float[] quantiles1 = sketch.getQuantiles(new double[] {0, 0.5, 1});
+ final float[] quantiles2 = sketch.getQuantiles(3);
assertEquals(quantiles1, quantiles2);
assertEquals(quantiles1[0], 1f);
assertEquals(quantiles1[1], 2f);
assertEquals(quantiles1[2], 3f);
}
- //@Test
+ @Test
public void checkSimpleMergeDirect() { //used for troubleshooting
int k = 20;
int n1 = 21;
int n2 = 43;
- KllDoublesSketch sk1 = new KllDoublesSketch(k);
- KllDoublesSketch sk2 = new KllDoublesSketch(k);
+ KllFloatsSketch sk1 = new KllFloatsSketch(k);
+ KllFloatsSketch sk2 = new KllFloatsSketch(k);
for (int i = 1; i <= n1; i++) {
sk1.update(i);
}
@@ -460,8 +459,8 @@ public class KllDirectDoublesSketchTest {
println(sk2.toString(true, true));
WritableMemory wmem1 = WritableMemory.writableWrap(sk1.toUpdatableByteArray());
WritableMemory wmem2 = WritableMemory.writableWrap(sk2.toUpdatableByteArray());
- KllDirectDoublesSketch dsk1 = new KllDirectDoublesSketch(wmem1, new DefaultMemoryRequestServer());
- KllDirectDoublesSketch dsk2 = new KllDirectDoublesSketch(wmem2, new DefaultMemoryRequestServer());
+ KllDirectFloatsSketch dsk1 = new KllDirectFloatsSketch(wmem1, new DefaultMemoryRequestServer());
+ KllDirectFloatsSketch dsk2 = new KllDirectFloatsSketch(wmem2, new DefaultMemoryRequestServer());
println("BEFORE MERGE");
println(dsk1.toString(true, true));
dsk1.merge(dsk2);
@@ -472,111 +471,111 @@ public class KllDirectDoublesSketchTest {
@Test
public void checkSketchInitializeDirectDoubleUpdatableMem() {
int k = 20; //don't change this
- KllDirectDoublesSketch sk;
- KllDoublesSketch sk2;
+ KllDirectFloatsSketch sk;
+ KllFloatsSketch sk2;
byte[] compBytes;
WritableMemory wmem;
println("#### CASE: DOUBLE FULL DIRECT FROM UPDATABLE");
- sk2 = new KllDoublesSketch(k);
+ sk2 = new KllFloatsSketch(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 = new KllDirectDoublesSketch(wmem, new DefaultMemoryRequestServer());
+ sk = new KllDirectFloatsSketch(wmem, new DefaultMemoryRequestServer());
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
assertEquals(sk.getNumRetained(), 11);
assertFalse(sk.isEmpty());
assertTrue(sk.isEstimationMode());
assertEquals(sk.getDyMinK(), k);
- assertEquals(sk.getDoubleItemsArray().length, 33);
- assertEquals(sk.getLayout(), "DOUBLE_UPDATABLE");
+ assertEquals(sk.getFloatItemsArray().length, 33);
+ assertEquals(sk.getLayout(), "FLOAT_UPDATABLE");
assertEquals(sk.getLevelsArray().length, 3);
- assertEquals(sk.getMaxDoubleValue(), 21.0);
- assertEquals(sk.getMinDoubleValue(), 1.0);
+ assertEquals(sk.getMaxFloatValue(), 21.0);
+ assertEquals(sk.getMinFloatValue(), 1.0);
assertEquals(sk.getNumLevels(), 2);
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: DOUBLE EMPTY HEAPIFIED FROM UPDATABLE");
- sk2 = new KllDoublesSketch(k);
+ sk2 = new KllFloatsSketch(k);
//println(sk.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = new KllDirectDoublesSketch(wmem, new DefaultMemoryRequestServer());
+ sk = new KllDirectFloatsSketch(wmem, new DefaultMemoryRequestServer());
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
assertEquals(sk.getNumRetained(), 0);
assertTrue(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getDyMinK(), k);
- assertEquals(sk.getDoubleItemsArray().length, 20);
- assertEquals(sk.getLayout(), "DOUBLE_UPDATABLE");
+ assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getLayout(), "FLOAT_UPDATABLE");
assertEquals(sk.getLevelsArray().length, 2);
- assertEquals(sk.getMaxDoubleValue(), Double.NaN);
- assertEquals(sk.getMinDoubleValue(), Double.NaN);
+ assertEquals(sk.getMaxFloatValue(), Double.NaN);
+ assertEquals(sk.getMinFloatValue(), Double.NaN);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
println("#### CASE: DOUBLE SINGLE HEAPIFIED FROM UPDATABLE");
- sk2 = new KllDoublesSketch(k);
+ sk2 = new KllFloatsSketch(k);
sk2.update(1);
//println(sk.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
println(KllPreambleUtil.toString(wmem));
- sk = new KllDirectDoublesSketch(wmem, new DefaultMemoryRequestServer());
+ sk = new KllDirectFloatsSketch(wmem, new DefaultMemoryRequestServer());
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
assertEquals(sk.getNumRetained(), 1);
assertFalse(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getDyMinK(), k);
- assertEquals(sk.getDoubleItemsArray().length, 20);
- assertEquals(sk.getLayout(), "DOUBLE_UPDATABLE");
+ assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getLayout(), "FLOAT_UPDATABLE");
assertEquals(sk.getLevelsArray().length, 2);
- assertEquals(sk.getMaxDoubleValue(), 1.0);
- assertEquals(sk.getMinDoubleValue(), 1.0);
+ assertEquals(sk.getMaxFloatValue(), 1.0);
+ assertEquals(sk.getMinFloatValue(), 1.0);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
}
@Test
public void checkGetWritableMemory() {
- final KllDirectDoublesSketch sketch = getDDSketch(200, 200);
+ final KllDirectFloatsSketch sketch = getDFSketch(200, 200);
assertEquals(sketch.getK(), 200);
assertEquals(sketch.getN(), 200);
assertFalse(sketch.isEmpty());
assertTrue(sketch.isDirect());
assertFalse(sketch.isEstimationMode());
- assertTrue(sketch.isDoublesSketch());
+ assertTrue(sketch.isFloatsSketch());
assertFalse(sketch.isLevelZeroSorted());
- assertFalse(sketch.isFloatsSketch());
+ assertFalse(sketch.isDoublesSketch());
final WritableMemory wmem = sketch.getWritableMemory();
- final KllDoublesSketch sk = KllDoublesSketch.heapify(wmem);
+ final KllFloatsSketch sk = KllFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), 200);
assertEquals(sk.getN(), 200);
assertFalse(sk.isEmpty());
assertFalse(sk.isDirect());
assertFalse(sk.isEstimationMode());
- assertTrue(sk.isDoublesSketch());
+ assertTrue(sk.isFloatsSketch());
assertFalse(sk.isLevelZeroSorted());
- assertFalse(sk.isFloatsSketch());
+ assertFalse(sk.isDoublesSketch());
assertTrue(KllSketch.isCompatible());
}
- private static KllDirectDoublesSketch getDDSketch(final int k, final int n) {
- KllDoublesSketch sk = new KllDoublesSketch(k);
+ private static KllDirectFloatsSketch getDFSketch(final int k, final int n) {
+ KllFloatsSketch sk = new KllFloatsSketch(k);
for (int i = 1; i <= n; i++) { sk.update(i); }
byte[] byteArr = sk.toUpdatableByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
- KllDirectDoublesSketch ddsk = new KllDirectDoublesSketch(wmem, memReqSvr);
- return ddsk;
+ KllDirectFloatsSketch dfsk = new KllDirectFloatsSketch(wmem, memReqSvr);
+ return dfsk;
}
@Test
diff --git a/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java
index a171350..081903b 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java
@@ -80,9 +80,9 @@ public class KllDoublesSketchTest {
assertEquals(sketch.getNumRetained(), 1);
assertEquals(sketch.getRank(1), 0.0);
assertEquals(sketch.getRank(2), 1.0);
- assertEquals(sketch.getMinValue(), 1f);
- assertEquals(sketch.getMaxValue(), 1f);
- assertEquals(sketch.getQuantile(0.5), 1f);
+ assertEquals(sketch.getMinValue(), 1.0);
+ assertEquals(sketch.getMaxValue(), 1.0);
+ assertEquals(sketch.getQuantile(0.5), 1.0);
}
@Test
@@ -193,7 +193,7 @@ public class KllDoublesSketchTest {
assertEquals(sketch1.getMaxValue(), n - 1f);
assertEquals(sketch2.getMinValue(), n);
- assertEquals(sketch2.getMaxValue(), 2f * n - 1f);
+ assertEquals(sketch2.getMaxValue(), 2f * n - 1.0);
assertTrue(sketch1.getNormalizedRankError(false) < sketch2.getNormalizedRankError(false));
assertTrue(sketch1.getNormalizedRankError(true) < sketch2.getNormalizedRankError(true));
@@ -205,8 +205,8 @@ public class KllDoublesSketchTest {
assertFalse(sketch1.isEmpty());
assertEquals(sketch1.getN(), 2 * n);
- assertEquals(sketch1.getMinValue(), 0f);
- assertEquals(sketch1.getMaxValue(), 2f * n - 1f);
+ assertEquals(sketch1.getMinValue(), 0);
+ assertEquals(sketch1.getMaxValue(), 2f * n - 1.0);
assertEquals(sketch1.getQuantile(0.5), n, n * PMF_EPS_FOR_K_128);
}
@@ -226,17 +226,17 @@ public class KllDoublesSketchTest {
assertFalse(sketch1.isEmpty());
assertEquals(sketch1.getN(), n);
- assertEquals(sketch1.getMinValue(), 0f);
- assertEquals(sketch1.getMaxValue(), n - 1f);
- assertEquals(sketch1.getQuantile(0.5), n / 2f, n / 2 * PMF_EPS_FOR_K_256);
+ assertEquals(sketch1.getMinValue(), 0);
+ assertEquals(sketch1.getMaxValue(), n - 1.0);
+ assertEquals(sketch1.getQuantile(0.5), n / 2.0, n / 2 * PMF_EPS_FOR_K_256);
//merge the other way
sketch2.merge(sketch1);
assertFalse(sketch1.isEmpty());
assertEquals(sketch1.getN(), n);
assertEquals(sketch1.getMinValue(), 0f);
- assertEquals(sketch1.getMaxValue(), n - 1f);
- assertEquals(sketch1.getQuantile(0.5), n / 2f, n / 2 * PMF_EPS_FOR_K_256);
+ assertEquals(sketch1.getMaxValue(), n - 1.0);
+ assertEquals(sketch1.getQuantile(0.5), n / 2.0, n / 2 * PMF_EPS_FOR_K_256);
}
@Test
@@ -262,7 +262,7 @@ public class KllDoublesSketchTest {
sketch1.update(1);
sketch2.update(2);
sketch2.merge(sketch1);
- assertEquals(sketch2.getMinValue(), 1.0F);
+ assertEquals(sketch2.getMinValue(), 1.0);
}
@Test
@@ -273,8 +273,8 @@ public class KllDoublesSketchTest {
}
final KllDoublesSketch sketch2 = new KllDoublesSketch();
sketch2.merge(sketch1);
- assertEquals(sketch2.getMinValue(), 1F);
- assertEquals(sketch2.getMaxValue(), 1_000_000F);
+ assertEquals(sketch2.getMinValue(), 1);
+ assertEquals(sketch2.getMaxValue(), 1_000_000);
}
@SuppressWarnings("unused")
@@ -392,9 +392,9 @@ public class KllDoublesSketchTest {
final double[] quantiles1 = sketch.getQuantiles(new double[] {0, 0.5, 1});
final double[] quantiles2 = sketch.getQuantiles(3);
assertEquals(quantiles1, quantiles2);
- assertEquals(quantiles1[0], 1f);
- assertEquals(quantiles1[1], 2f);
- assertEquals(quantiles1[2], 3f);
+ assertEquals(quantiles1[0], 1.0);
+ assertEquals(quantiles1[1], 2.0);
+ assertEquals(quantiles1[2], 3.0);
}
}
diff --git a/src/test/java/org/apache/datasketches/kll/MiscDirectDoublesTest.java b/src/test/java/org/apache/datasketches/kll/MiscDirectDoublesTest.java
index 60e2fd8..f3b6d7d 100644
--- a/src/test/java/org/apache/datasketches/kll/MiscDirectDoublesTest.java
+++ b/src/test/java/org/apache/datasketches/kll/MiscDirectDoublesTest.java
@@ -33,7 +33,6 @@ public class MiscDirectDoublesTest {
static final String LS = System.getProperty("line.separator");
private static final DefaultMemoryRequestServer memReqSvr = new DefaultMemoryRequestServer();
-
@Test
public void checkBounds() {
final KllDirectDoublesSketch sk = getDDSketch(200, 0);
@@ -81,7 +80,7 @@ public class MiscDirectDoublesTest {
println(LS + s2);
}
- @Test
+ //@Test
public void viewCompactions() {
final KllDirectDoublesSketch sk = getDDSketch(20, 0);
show(sk, 20);
@@ -125,9 +124,7 @@ public class MiscDirectDoublesTest {
assertEquals(sk.getLayout(), "DOUBLE_UPDATABLE");
assertEquals(sk.getLevelsArray().length, 3);
assertEquals(sk.getMaxDoubleValue(), 21.0);
- //assertEquals(sk.getMaxFloatValue(), 21.0F);
assertEquals(sk.getMinDoubleValue(), 1.0);
- //assertEquals(sk.getMinFloatValue(), 1.0F);
assertEquals(sk.getNumLevels(), 2);
assertFalse(sk.isLevelZeroSorted());
@@ -145,9 +142,7 @@ public class MiscDirectDoublesTest {
assertEquals(sk.getLayout(), "DOUBLE_UPDATABLE");
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxDoubleValue(), Double.NaN);
- //assertEquals(sk.getMaxFloatValue(), Float.NaN);
assertEquals(sk.getMinDoubleValue(), Double.NaN);
- //assertEquals(sk.getMinFloatValue(), Float.NaN);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
@@ -166,9 +161,7 @@ public class MiscDirectDoublesTest {
assertEquals(sk.getLayout(), "DOUBLE_UPDATABLE");
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxDoubleValue(), 1.0);
- //assertEquals(sk.getMaxFloatValue(), 1.0F);
assertEquals(sk.getMinDoubleValue(), 1.0);
- //assertEquals(sk.getMinFloatValue(), 1.0F);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
}
@@ -200,9 +193,7 @@ public class MiscDirectDoublesTest {
assertEquals(sk.getLayout(), "HEAP");
assertEquals(sk.getLevelsArray().length, 3);
assertEquals(sk.getMaxDoubleValue(), 21.0);
- //assertEquals(sk.getMaxFloatValue(), 21.0F);
assertEquals(sk.getMinDoubleValue(), 1.0);
- //assertEquals(sk.getMinFloatValue(), 1.0F);
assertEquals(sk.getNumLevels(), 2);
assertFalse(sk.isLevelZeroSorted());
@@ -224,9 +215,7 @@ public class MiscDirectDoublesTest {
assertEquals(sk.getLayout(), "HEAP");
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxDoubleValue(), Double.NaN);
- //assertEquals(sk.getMaxFloatValue(), Float.NaN);
assertEquals(sk.getMinDoubleValue(), Double.NaN);
- //assertEquals(sk.getMinFloatValue(), Float.NaN);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
@@ -249,9 +238,7 @@ public class MiscDirectDoublesTest {
assertEquals(sk.getLayout(), "HEAP");
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxDoubleValue(), 1.0);
- //assertEquals(sk.getMaxFloatValue(), 1.0F);
assertEquals(sk.getMinDoubleValue(), 1.0);
- //assertEquals(sk.getMinFloatValue(), 1.0F);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
}
@@ -283,9 +270,7 @@ public class MiscDirectDoublesTest {
assertEquals(sk.getLayout(), "HEAP");
assertEquals(sk.getLevelsArray().length, 3);
assertEquals(sk.getMaxDoubleValue(), 21.0);
- //assertEquals(sk.getMaxFloatValue(), 21.0F);
assertEquals(sk.getMinDoubleValue(), 1.0);
- //assertEquals(sk.getMinFloatValue(), 1.0F);
assertEquals(sk.getNumLevels(), 2);
assertFalse(sk.isLevelZeroSorted());
@@ -307,9 +292,7 @@ public class MiscDirectDoublesTest {
assertEquals(sk.getLayout(), "HEAP");
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxDoubleValue(), Double.NaN);
- //assertEquals(sk.getMaxFloatValue(), Float.NaN);
assertEquals(sk.getMinDoubleValue(), Double.NaN);
- //assertEquals(sk.getMinFloatValue(), Float.NaN);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
@@ -332,9 +315,7 @@ public class MiscDirectDoublesTest {
assertEquals(sk.getLayout(), "HEAP");
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxDoubleValue(), 1.0);
- //assertEquals(sk.getMaxFloatValue(), 1.0F);
assertEquals(sk.getMinDoubleValue(), 1.0);
- //assertEquals(sk.getMinFloatValue(), 1.0F);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
}
diff --git a/src/test/java/org/apache/datasketches/kll/MiscDirectDoublesTest.java b/src/test/java/org/apache/datasketches/kll/MiscDirectFloatsTest.java
similarity index 67%
copy from src/test/java/org/apache/datasketches/kll/MiscDirectDoublesTest.java
copy to src/test/java/org/apache/datasketches/kll/MiscDirectFloatsTest.java
index 60e2fd8..27094c5 100644
--- a/src/test/java/org/apache/datasketches/kll/MiscDirectDoublesTest.java
+++ b/src/test/java/org/apache/datasketches/kll/MiscDirectFloatsTest.java
@@ -29,21 +29,20 @@ import org.apache.datasketches.memory.DefaultMemoryRequestServer;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
-public class MiscDirectDoublesTest {
+public class MiscDirectFloatsTest {
static final String LS = System.getProperty("line.separator");
private static final DefaultMemoryRequestServer memReqSvr = new DefaultMemoryRequestServer();
-
@Test
public void checkBounds() {
- final KllDirectDoublesSketch sk = getDDSketch(200, 0);
+ final KllDirectFloatsSketch sk = getDFSketch(200, 0);
for (int i = 0; i < 1000; i++) {
sk.update(i);
}
final double eps = sk.getNormalizedRankError(false);
- final double est = sk.getQuantile(0.5);
- final double ub = sk.getQuantileUpperBound(0.5);
- final double lb = sk.getQuantileLowerBound(0.5);
+ final float est = sk.getQuantile(0.5);
+ final float ub = sk.getQuantileUpperBound(0.5);
+ final float lb = sk.getQuantileLowerBound(0.5);
assertEquals(ub, sk.getQuantile(.5 + eps));
assertEquals(lb, sk.getQuantile(0.5 - eps));
println("Ext : " + est);
@@ -53,13 +52,13 @@ public class MiscDirectDoublesTest {
@Test
public void checkMisc() {
- final KllDirectDoublesSketch sk = getDDSketch(8, 0);
+ final KllDirectFloatsSketch sk = getDFSketch(8, 0);
assertTrue(Objects.isNull(sk.getQuantiles(10)));
//sk.toString(true, true);
for (int i = 0; i < 20; i++) { sk.update(i); }
//sk.toString(true, true);
//sk.toByteArray();
- final double[] items = sk.getDoubleItemsArray();
+ final float[] items = sk.getFloatItemsArray();
assertEquals(items.length, 16);
final int[] levels = sk.getLevelsArray();
assertEquals(levels.length, 3);
@@ -68,11 +67,11 @@ public class MiscDirectDoublesTest {
//@Test //enable static println(..) for visual checking
public void visualCheckToString() {
- final KllDirectDoublesSketch sk = getDDSketch(20, 0);
+ final KllDirectFloatsSketch sk = getDFSketch(20, 0);
for (int i = 0; i < 10; i++) { sk.update(i + 1); }
println(sk.toString(true, true));
- final KllDirectDoublesSketch sk2 = getDDSketch(20, 0);
+ final KllDirectFloatsSketch sk2 = getDFSketch(20, 0);
for (int i = 0; i < 400; i++) { sk2.update(i + 1); }
println("\n" + sk2.toString(true, true));
@@ -81,9 +80,9 @@ public class MiscDirectDoublesTest {
println(LS + s2);
}
- @Test
+ //@Test
public void viewCompactions() {
- final KllDirectDoublesSketch sk = getDDSketch(20, 0);
+ final KllDirectFloatsSketch sk = getDFSketch(20, 0);
show(sk, 20);
show(sk, 21); //compaction 1
show(sk, 43);
@@ -99,19 +98,19 @@ public class MiscDirectDoublesTest {
show(sk, 108);
}
- private static void show(final KllDirectDoublesSketch sk, int limit) {
+ private static void show(final KllDirectFloatsSketch sk, int limit) {
int i = (int) sk.getN();
for ( ; i < limit; i++) { sk.update(i + 1); }
println(sk.toString(true, true));
}
@Test
- public void checkSketchInitializeDoubleHeap() {
+ public void checkSketchInitializeFloatHeap() {
int k = 20; //don't change this
- KllDirectDoublesSketch sk;
+ KllDirectFloatsSketch sk;
//println("#### CASE: DOUBLE FULL HEAP");
- sk = getDDSketch(k, 0);
+ sk = getDFSketch(k, 0);
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
//println(sk.toString(true, true));
assertEquals(sk.getK(), k);
@@ -120,19 +119,17 @@ public class MiscDirectDoublesTest {
assertFalse(sk.isEmpty());
assertTrue(sk.isEstimationMode());
assertEquals(sk.getDyMinK(), k);
- assertTrue(Objects.isNull(sk.getFloatItemsArray()));
- assertEquals(sk.getDoubleItemsArray().length, 33);
- assertEquals(sk.getLayout(), "DOUBLE_UPDATABLE");
+ assertTrue(Objects.isNull(sk.getDoubleItemsArray()));
+ assertEquals(sk.getFloatItemsArray().length, 33);
+ assertEquals(sk.getLayout(), "FLOAT_UPDATABLE");
assertEquals(sk.getLevelsArray().length, 3);
- assertEquals(sk.getMaxDoubleValue(), 21.0);
- //assertEquals(sk.getMaxFloatValue(), 21.0F);
- assertEquals(sk.getMinDoubleValue(), 1.0);
- //assertEquals(sk.getMinFloatValue(), 1.0F);
+ assertEquals(sk.getMaxFloatValue(), 21.0F);
+ assertEquals(sk.getMinFloatValue(), 1.0F);
assertEquals(sk.getNumLevels(), 2);
assertFalse(sk.isLevelZeroSorted());
//println("#### CASE: DOUBLE HEAP EMPTY");
- sk = getDDSketch(k, 0);
+ sk = getDFSketch(k, 0);
//println(sk.toString(true, true));
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
@@ -140,19 +137,17 @@ public class MiscDirectDoublesTest {
assertTrue(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getDyMinK(), k);
- assertTrue(Objects.isNull(sk.getFloatItemsArray()));
- assertEquals(sk.getDoubleItemsArray().length, 20);
- assertEquals(sk.getLayout(), "DOUBLE_UPDATABLE");
+ assertTrue(Objects.isNull(sk.getDoubleItemsArray()));
+ assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getLayout(), "FLOAT_UPDATABLE");
assertEquals(sk.getLevelsArray().length, 2);
- assertEquals(sk.getMaxDoubleValue(), Double.NaN);
- //assertEquals(sk.getMaxFloatValue(), Float.NaN);
- assertEquals(sk.getMinDoubleValue(), Double.NaN);
- //assertEquals(sk.getMinFloatValue(), Float.NaN);
+ assertEquals(sk.getMaxFloatValue(), Float.NaN);
+ assertEquals(sk.getMinFloatValue(), Float.NaN);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
//println("#### CASE: DOUBLE HEAP SINGLE");
- sk = getDDSketch(k, 0);
+ sk = getDFSketch(k, 0);
sk.update(1);
//println(sk.toString(true, true));
assertEquals(sk.getK(), k);
@@ -161,203 +156,189 @@ public class MiscDirectDoublesTest {
assertFalse(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getDyMinK(), k);
- assertTrue(Objects.isNull(sk.getFloatItemsArray()));
- assertEquals(sk.getDoubleItemsArray().length, 20);
- assertEquals(sk.getLayout(), "DOUBLE_UPDATABLE");
+ assertTrue(Objects.isNull(sk.getDoubleItemsArray()));
+ assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getLayout(), "FLOAT_UPDATABLE");
assertEquals(sk.getLevelsArray().length, 2);
- assertEquals(sk.getMaxDoubleValue(), 1.0);
- //assertEquals(sk.getMaxFloatValue(), 1.0F);
- assertEquals(sk.getMinDoubleValue(), 1.0);
- //assertEquals(sk.getMinFloatValue(), 1.0F);
+ assertEquals(sk.getMaxFloatValue(), 1.0F);
+ assertEquals(sk.getMinFloatValue(), 1.0F);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
}
@Test
- public void checkSketchInitializeDoubleHeapifyCompactMem() {
+ public void checkSketchInitializeFloatHeapifyCompactMem() {
int k = 20; //don't change this
- KllDoublesSketch sk;
- KllDirectDoublesSketch sk2;
+ KllFloatsSketch sk;
+ KllDirectFloatsSketch sk2;
byte[] compBytes;
WritableMemory wmem;
//println("#### CASE: DOUBLE FULL HEAPIFIED FROM COMPACT");
- sk2 = getDDSketch(k, 0);
+ sk2 = getDFSketch(k, 0);
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 = KllFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
assertEquals(sk.getNumRetained(), 11);
assertFalse(sk.isEmpty());
assertTrue(sk.isEstimationMode());
assertEquals(sk.getDyMinK(), k);
- assertTrue(Objects.isNull(sk.getFloatItemsArray()));
- assertEquals(sk.getDoubleItemsArray().length, 33);
+ assertTrue(Objects.isNull(sk.getDoubleItemsArray()));
+ assertEquals(sk.getFloatItemsArray().length, 33);
assertEquals(sk.getLayout(), "HEAP");
assertEquals(sk.getLevelsArray().length, 3);
- assertEquals(sk.getMaxDoubleValue(), 21.0);
- //assertEquals(sk.getMaxFloatValue(), 21.0F);
- assertEquals(sk.getMinDoubleValue(), 1.0);
- //assertEquals(sk.getMinFloatValue(), 1.0F);
+ assertEquals(sk.getMaxFloatValue(), 21.0F);
+ assertEquals(sk.getMinFloatValue(), 1.0f);
assertEquals(sk.getNumLevels(), 2);
assertFalse(sk.isLevelZeroSorted());
//println("#### CASE: DOUBLE EMPTY HEAPIFIED FROM COMPACT");
- sk2 = getDDSketch(k, 0);
+ sk2 = getDFSketch(k, 0);
//println(sk.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
assertEquals(sk.getNumRetained(), 0);
assertTrue(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getDyMinK(), k);
- assertTrue(Objects.isNull(sk.getFloatItemsArray()));
- assertEquals(sk.getDoubleItemsArray().length, 20);
+ assertTrue(Objects.isNull(sk.getDoubleItemsArray()));
+ assertEquals(sk.getFloatItemsArray().length, 20);
assertEquals(sk.getLayout(), "HEAP");
assertEquals(sk.getLevelsArray().length, 2);
- assertEquals(sk.getMaxDoubleValue(), Double.NaN);
- //assertEquals(sk.getMaxFloatValue(), Float.NaN);
- assertEquals(sk.getMinDoubleValue(), Double.NaN);
- //assertEquals(sk.getMinFloatValue(), Float.NaN);
+ assertEquals(sk.getMaxFloatValue(), Float.NaN);
+ assertEquals(sk.getMinFloatValue(), Float.NaN);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
//println("#### CASE: DOUBLE SINGLE HEAPIFIED FROM COMPACT");
- sk2 = getDDSketch(k, 0);
+ sk2 = getDFSketch(k, 0);
sk2.update(1);
//println(sk2.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
assertEquals(sk.getNumRetained(), 1);
assertFalse(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getDyMinK(), k);
- assertTrue(Objects.isNull(sk.getFloatItemsArray()));
- assertEquals(sk.getDoubleItemsArray().length, 20);
+ assertTrue(Objects.isNull(sk.getDoubleItemsArray()));
+ assertEquals(sk.getFloatItemsArray().length, 20);
assertEquals(sk.getLayout(), "HEAP");
assertEquals(sk.getLevelsArray().length, 2);
- assertEquals(sk.getMaxDoubleValue(), 1.0);
- //assertEquals(sk.getMaxFloatValue(), 1.0F);
- assertEquals(sk.getMinDoubleValue(), 1.0);
- //assertEquals(sk.getMinFloatValue(), 1.0F);
+ assertEquals(sk.getMaxFloatValue(), 1.0F);
+ assertEquals(sk.getMinFloatValue(), 1.0F);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
}
@Test
- public void checkSketchInitializeDoubleHeapifyUpdatableMem() {
+ public void checkSketchInitializeFloatHeapifyUpdatableMem() {
int k = 20; //don't change this
- KllDoublesSketch sk;
- KllDirectDoublesSketch sk2;
+ KllFloatsSketch sk;
+ KllDirectFloatsSketch sk2;
byte[] compBytes;
WritableMemory wmem;
//println("#### CASE: DOUBLE FULL HEAPIFIED FROM UPDATABLE");
- sk2 = getDDSketch(k, 0);
+ sk2 = getDFSketch(k, 0);
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 = KllFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
assertEquals(sk.getNumRetained(), 11);
assertFalse(sk.isEmpty());
assertTrue(sk.isEstimationMode());
assertEquals(sk.getDyMinK(), k);
- assertTrue(Objects.isNull(sk.getFloatItemsArray()));
- assertEquals(sk.getDoubleItemsArray().length, 33);
+ assertTrue(Objects.isNull(sk.getDoubleItemsArray()));
+ assertEquals(sk.getFloatItemsArray().length, 33);
assertEquals(sk.getLayout(), "HEAP");
assertEquals(sk.getLevelsArray().length, 3);
- assertEquals(sk.getMaxDoubleValue(), 21.0);
- //assertEquals(sk.getMaxFloatValue(), 21.0F);
- assertEquals(sk.getMinDoubleValue(), 1.0);
- //assertEquals(sk.getMinFloatValue(), 1.0F);
+ assertEquals(sk.getMaxFloatValue(), 21.0F);
+ assertEquals(sk.getMinFloatValue(), 1.0F);
assertEquals(sk.getNumLevels(), 2);
assertFalse(sk.isLevelZeroSorted());
// println("#### CASE: DOUBLE EMPTY HEAPIFIED FROM UPDATABLE");
- sk2 = getDDSketch(k, 0);
+ sk2 = getDFSketch(k, 0);
//println(sk.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
assertEquals(sk.getNumRetained(), 0);
assertTrue(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getDyMinK(), k);
- assertTrue(Objects.isNull(sk.getFloatItemsArray()));
- assertEquals(sk.getDoubleItemsArray().length, 20);
+ assertTrue(Objects.isNull(sk.getDoubleItemsArray()));
+ assertEquals(sk.getFloatItemsArray().length, 20);
assertEquals(sk.getLayout(), "HEAP");
assertEquals(sk.getLevelsArray().length, 2);
- assertEquals(sk.getMaxDoubleValue(), Double.NaN);
- //assertEquals(sk.getMaxFloatValue(), Float.NaN);
- assertEquals(sk.getMinDoubleValue(), Double.NaN);
- //assertEquals(sk.getMinFloatValue(), Float.NaN);
+ assertEquals(sk.getMaxFloatValue(), Float.NaN);
+ assertEquals(sk.getMinFloatValue(), Float.NaN);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
//println("#### CASE: DOUBLE SINGLE HEAPIFIED FROM UPDATABLE");
- sk2 = getDDSketch(k, 0);
+ sk2 = getDFSketch(k, 0);
sk2.update(1);
//println(sk.toString(true, true));
compBytes = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(compBytes);
//println(KllPreambleUtil.toString(wmem));
- sk = KllDoublesSketch.heapify(wmem);
+ sk = KllFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
assertEquals(sk.getNumRetained(), 1);
assertFalse(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getDyMinK(), k);
- assertTrue(Objects.isNull(sk.getFloatItemsArray()));
- assertEquals(sk.getDoubleItemsArray().length, 20);
+ assertTrue(Objects.isNull(sk.getDoubleItemsArray()));
+ assertEquals(sk.getFloatItemsArray().length, 20);
assertEquals(sk.getLayout(), "HEAP");
assertEquals(sk.getLevelsArray().length, 2);
- assertEquals(sk.getMaxDoubleValue(), 1.0);
- //assertEquals(sk.getMaxFloatValue(), 1.0F);
- assertEquals(sk.getMinDoubleValue(), 1.0);
- //assertEquals(sk.getMinFloatValue(), 1.0F);
+ assertEquals(sk.getMaxFloatValue(), 1.0F);
+ assertEquals(sk.getMinFloatValue(), 1.0F);
assertEquals(sk.getNumLevels(), 1);
assertFalse(sk.isLevelZeroSorted());
}
@Test
- public void checkMemoryToStringDoubleUpdatable() {
+ public void checkMemoryToStringFloatUpdatable() {
int k = 20; //don't change this
- KllDirectDoublesSketch sk;
- KllDirectDoublesSketch sk2;
+ KllDirectFloatsSketch sk;
+ KllDirectFloatsSketch sk2;
byte[] upBytes;
byte[] upBytes2;
WritableMemory wmem;
String s;
println("#### CASE: DOUBLE FULL UPDATABLE");
- sk = getDDSketch(k, 0);
+ sk = getDFSketch(k, 0);
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 = new KllDirectDoublesSketch(wmem, memReqSvr);
+ sk2 = new KllDirectFloatsSketch(wmem, memReqSvr);
upBytes2 = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -366,13 +347,13 @@ public class MiscDirectDoublesTest {
assertEquals(upBytes, upBytes2);
println("#### CASE: DOUBLE EMPTY UPDATABLE");
- sk = getDDSketch(k, 0);
+ sk = getDFSketch(k, 0);
upBytes = sk.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes);
s = KllPreambleUtil.memoryToString(wmem);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
- sk2 = new KllDirectDoublesSketch(wmem, memReqSvr);
+ sk2 = new KllDirectFloatsSketch(wmem, memReqSvr);
upBytes2 = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -381,14 +362,14 @@ public class MiscDirectDoublesTest {
assertEquals(upBytes, upBytes2);
println("#### CASE: DOUBLE SINGLE UPDATABL");
- sk = getDDSketch(k, 0);
+ sk = getDFSketch(k, 0);
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 = new KllDirectDoublesSketch(wmem, memReqSvr);
+ sk2 = new KllDirectFloatsSketch(wmem, memReqSvr);
upBytes2 = sk2.toUpdatableByteArray();
wmem = WritableMemory.writableWrap(upBytes2);
s = KllPreambleUtil.memoryToString(wmem);
@@ -402,8 +383,8 @@ public class MiscDirectDoublesTest {
int k = 20;
int n1 = 21;
int n2 = 21;
- KllDirectDoublesSketch sk1 = getDDSketch(k, 0);
- KllDirectDoublesSketch sk2 = getDDSketch(k, 0);
+ KllDirectFloatsSketch sk1 = getDFSketch(k, 0);
+ KllDirectFloatsSketch sk2 = getDFSketch(k, 0);
for (int i = 1; i <= n1; i++) {
sk1.update(i);
}
@@ -414,23 +395,23 @@ public class MiscDirectDoublesTest {
println(sk2.toString(true, true));
sk1.merge(sk2);
println(sk1.toString(true, true));
- assertEquals(sk1.getMaxValue(), 121.0);
- assertEquals(sk1.getMinValue(), 1.0);
+ assertEquals(sk1.getMaxValue(), 121.0F);
+ assertEquals(sk1.getMinValue(), 1.0F);
}
- private static KllDirectDoublesSketch getDDSketch(final int k, final int n) {
- KllDoublesSketch sk = new KllDoublesSketch(k);
+ private static KllDirectFloatsSketch getDFSketch(final int k, final int n) {
+ KllFloatsSketch sk = new KllFloatsSketch(k);
for (int i = 1; i <= n; i++) { sk.update(i); }
byte[] byteArr = sk.toUpdatableByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
- KllDirectDoublesSketch ddsk = new KllDirectDoublesSketch(wmem, memReqSvr);
- return ddsk;
+ KllDirectFloatsSketch dfsk = new KllDirectFloatsSketch(wmem, memReqSvr);
+ return dfsk;
}
@Test
public void printlnTest() {
- println("PRINTING: " + this.getClass().getName());
+ //println("PRINTING: " + this.getClass().getName());
}
/**
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org