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/08/02 22:38:53 UTC
[datasketches-java] 01/01: Interim 1 for KLL
This is an automated email from the ASF dual-hosted git repository.
leerho pushed a commit to branch Changes_to_kll
in repository https://gitbox.apache.org/repos/asf/datasketches-java.git
commit 851ec937a1372e3d82b41d8ed64c6abdd12d7c3f
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Tue Aug 2 15:38:38 2022 -0700
Interim 1 for KLL
---
.../datasketches/QuantileSearchCriteria.java | 2 +-
.../kll/KllDirectCompactDoublesSketch.java | 14 +-
.../kll/KllDirectCompactFloatsSketch.java | 22 +-
.../datasketches/kll/KllDirectDoublesSketch.java | 6 +-
.../datasketches/kll/KllDirectFloatsSketch.java | 8 +-
.../apache/datasketches/kll/KllDoublesHelper.java | 4 +-
.../apache/datasketches/kll/KllDoublesSketch.java | 18 +-
.../apache/datasketches/kll/KllFloatsHelper.java | 11 +-
.../apache/datasketches/kll/KllFloatsSketch.java | 216 +++++++++++--------
.../kll/KllFloatsSketchSortedView.java | 229 ++++++++++++---------
.../datasketches/kll/KllHeapDoublesSketch.java | 12 +-
.../datasketches/kll/KllHeapFloatsSketch.java | 14 +-
.../org/apache/datasketches/kll/KllHelper.java | 32 +--
.../apache/datasketches/kll/KllMemoryValidate.java | 20 +-
.../apache/datasketches/kll/KllPreambleUtil.java | 132 ++++++------
.../org/apache/datasketches/kll/KllSketch.java | 65 +++---
.../kll/KllDirectCompactFloatsSketchTest.java | 10 +-
.../kll/KllDirectDoublesSketchTest.java | 2 +-
.../kll/KllDirectFloatsSketchTest.java | 9 +-
.../datasketches/kll/KllDoublesSketchTest.java | 2 +-
.../datasketches/kll/KllFloatsSketchTest.java | 55 +++--
.../datasketches/kll/KllFloatsValidationTest.java | 2 +-
.../org/apache/datasketches/kll/KllHelperTest.java | 2 +-
.../datasketches/kll/KllMemoryValidateTest.java | 2 +-
.../datasketches/kll/KllMiscDirectFloatsTest.java | 20 +-
.../apache/datasketches/kll/KllMiscFloatsTest.java | 30 +--
26 files changed, 521 insertions(+), 418 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/QuantileSearchCriteria.java b/src/main/java/org/apache/datasketches/QuantileSearchCriteria.java
index 3b158cbb..dc539e83 100644
--- a/src/main/java/org/apache/datasketches/QuantileSearchCriteria.java
+++ b/src/main/java/org/apache/datasketches/QuantileSearchCriteria.java
@@ -20,7 +20,7 @@
package org.apache.datasketches;
/**
- * These criteria are used by all the quantiles algorithms in the library.
+ * These search criteria are used by all the quantiles algorithms in the DataSketches library.
* <ul>
* <li><b>Definition of Non Inclusive <i>getRank(q)</i> search:</b><br>
* Given quantile <i>q</i>, return the rank, <i>r</i>, of the largest quantile that is strictly less than <i>q</i>.
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectCompactDoublesSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectCompactDoublesSketch.java
index f00d1779..0fa9a4ec 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDirectCompactDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDirectCompactDoublesSketch.java
@@ -20,11 +20,11 @@
package org.apache.datasketches.kll;
import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR;
-import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryEmptyFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryN;
-import static org.apache.datasketches.kll.KllPreambleUtil.getMemorySingleItemFlag;
-import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemorySingleValueFlag;
+import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
import org.apache.datasketches.memory.Memory;
@@ -39,7 +39,7 @@ class KllDirectCompactDoublesSketch extends KllDirectDoublesSketch {
@Override
public long getN() {
if (getMemoryEmptyFlag(wmem)) { return 0; }
- if (getMemorySingleItemFlag(wmem)) { return 1; }
+ if (getMemorySingleValueFlag(wmem)) { return 1; }
return getMemoryN(wmem);
}
@@ -57,7 +57,7 @@ class KllDirectCompactDoublesSketch extends KllDirectDoublesSketch {
if (isEmpty()) { return new double[k]; }
if (isSingleItem()) {
final double[] itemsArr = new double[k];
- itemsArr[k - 1] = wmem.getDouble(DATA_START_ADR_SINGLE_ITEM);
+ itemsArr[k - 1] = wmem.getDouble(DATA_START_ADR_SINGLE_VALUE);
return itemsArr;
}
final int capacityItems = levelsArr[getNumLevels()];
@@ -71,8 +71,8 @@ class KllDirectCompactDoublesSketch extends KllDirectDoublesSketch {
@Override
double getDoubleSingleItem() {
- if (!isSingleItem()) { kllSketchThrow(NOT_SINGLE_ITEM); }
- return wmem.getDouble(DATA_START_ADR_SINGLE_ITEM);
+ if (!isSingleItem()) { kllSketchThrow(NOT_SINGLE_VALUE); }
+ return wmem.getDouble(DATA_START_ADR_SINGLE_VALUE);
}
@Override
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectCompactFloatsSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectCompactFloatsSketch.java
index 990b4664..c43ccad3 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDirectCompactFloatsSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDirectCompactFloatsSketch.java
@@ -20,11 +20,11 @@
package org.apache.datasketches.kll;
import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR;
-import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryEmptyFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryN;
-import static org.apache.datasketches.kll.KllPreambleUtil.getMemorySingleItemFlag;
-import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemorySingleValueFlag;
+import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
import org.apache.datasketches.memory.Memory;
@@ -39,7 +39,7 @@ class KllDirectCompactFloatsSketch extends KllDirectFloatsSketch {
@Override
public long getN() {
if (getMemoryEmptyFlag(wmem)) { return 0; }
- if (getMemorySingleItemFlag(wmem)) { return 1; }
+ if (getMemorySingleValueFlag(wmem)) { return 1; }
return getMemoryN(wmem);
}
@@ -52,12 +52,12 @@ class KllDirectCompactFloatsSketch extends KllDirectFloatsSketch {
}
@Override //returns expanded array including empty space at bottom
- float[] getFloatItemsArray() {
+ float[] getFloatValuesArray() {
final int k = getK();
if (isEmpty()) { return new float[k]; }
if (isSingleItem()) {
final float[] itemsArr = new float[k];
- itemsArr[k - 1] = wmem.getFloat(DATA_START_ADR_SINGLE_ITEM);
+ itemsArr[k - 1] = wmem.getFloat(DATA_START_ADR_SINGLE_VALUE);
return itemsArr;
}
final int capacityItems = levelsArr[getNumLevels()];
@@ -70,15 +70,15 @@ class KllDirectCompactFloatsSketch extends KllDirectFloatsSketch {
}
@Override
- float getFloatSingleItem() {
- if (!isSingleItem()) { kllSketchThrow(NOT_SINGLE_ITEM); }
- return wmem.getFloat(DATA_START_ADR_SINGLE_ITEM);
+ float getFloatSingleValue() {
+ if (!isSingleItem()) { kllSketchThrow(NOT_SINGLE_VALUE); }
+ return wmem.getFloat(DATA_START_ADR_SINGLE_VALUE);
}
@Override
float getMaxFloatValue() {
if (isEmpty()) { return Float.NaN; }
- if (isSingleItem()) { return getFloatSingleItem(); }
+ if (isSingleItem()) { return getFloatSingleValue(); }
final int offset =
DATA_START_ADR + (getLevelsArray().length - 1) * Integer.BYTES + Float.BYTES;
return wmem.getFloat(offset);
@@ -87,7 +87,7 @@ class KllDirectCompactFloatsSketch extends KllDirectFloatsSketch {
@Override
float getMinFloatValue() {
if (isEmpty()) { return Float.NaN; }
- if (isSingleItem()) { return getFloatSingleItem(); }
+ if (isSingleItem()) { return getFloatSingleValue(); }
final int offset =
DATA_START_ADR + (getLevelsArray().length - 1) * Integer.BYTES;
return wmem.getFloat(offset);
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
index a41a74af..392f42da 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
@@ -41,7 +41,7 @@ import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryNumLevels;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryPreInts;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemorySerVer;
import static org.apache.datasketches.kll.KllSketch.Error.MUST_NOT_CALL;
-import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllSketch.Error.TGT_IS_READ_ONLY;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
@@ -122,14 +122,14 @@ class KllDirectDoublesSketch extends KllDoublesSketch {
@Override
double getDoubleSingleItem() {
- if (!isSingleItem()) { kllSketchThrow(NOT_SINGLE_ITEM); return Double.NaN; }
+ if (!isSingleItem()) { kllSketchThrow(NOT_SINGLE_VALUE); return Double.NaN; }
final int k = getK();
final int offset = DATA_START_ADR + 2 * Integer.BYTES + (2 + k - 1) * Double.BYTES;
return wmem.getDouble(offset);
}
@Override
- float getFloatSingleItem() { kllSketchThrow(MUST_NOT_CALL); return Float.NaN; }
+ float getFloatSingleValue() { kllSketchThrow(MUST_NOT_CALL); return Float.NaN; }
@Override
int getM() {
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
index ec057f86..3c6550ee 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
@@ -40,7 +40,7 @@ import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryNumLevels;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryPreInts;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemorySerVer;
import static org.apache.datasketches.kll.KllSketch.Error.MUST_NOT_CALL;
-import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllSketch.Error.TGT_IS_READ_ONLY;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
@@ -114,7 +114,7 @@ class KllDirectFloatsSketch extends KllFloatsSketch {
double getDoubleSingleItem() { kllSketchThrow(MUST_NOT_CALL); return Double.NaN; }
@Override //returns entire array including empty space at bottom
- float[] getFloatItemsArray() {
+ float[] getFloatValuesArray() {
final int capacityItems = levelsArr[getNumLevels()];
final float[] itemsArr = new float[capacityItems];
final int levelsBytes = levelsArr.length * Integer.BYTES; //updatable format
@@ -124,8 +124,8 @@ class KllDirectFloatsSketch extends KllFloatsSketch {
}
@Override
- float getFloatSingleItem() {
- if (!isSingleItem()) { kllSketchThrow(NOT_SINGLE_ITEM); return Float.NaN; }
+ float getFloatSingleValue() {
+ if (!isSingleItem()) { kllSketchThrow(NOT_SINGLE_VALUE); return Float.NaN; }
final int k = getK();
final int offset = DATA_START_ADR + 2 * Integer.BYTES + (2 + k - 1) * Float.BYTES;
return wmem.getFloat(offset);
diff --git a/src/main/java/org/apache/datasketches/kll/KllDoublesHelper.java b/src/main/java/org/apache/datasketches/kll/KllDoublesHelper.java
index a893e0e9..f030e614 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDoublesHelper.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDoublesHelper.java
@@ -129,7 +129,7 @@ final class KllDoublesHelper {
return quantiles;
}
- static void mergeDoubleImpl(final KllSketch sketch, final KllSketch other) {
+ static void mergeDoubleImpl(final KllDoublesSketch sketch, final KllSketch other) {
if (other.isEmpty()) { return; }
final long finalN = sketch.getN() + other.getN();
final int otherNumLevels = other.getNumLevels();
@@ -361,7 +361,7 @@ final class KllDoublesHelper {
assert numLevelsIn > 0; // things are too weird if zero levels are allowed
int numLevels = numLevelsIn;
int currentItemCount = inLevels[numLevels] - inLevels[0]; // decreases with each compaction
- int targetItemCount = KllHelper.computeTotalItemCapacity(k, m, numLevels); // increases if we add levels
+ int targetItemCount = KllHelper.computeTotalValueCapacity(k, m, numLevels); // increases if we add levels
boolean doneYet = false;
outLevels[0] = 0;
int curLevel = -1;
diff --git a/src/main/java/org/apache/datasketches/kll/KllDoublesSketch.java b/src/main/java/org/apache/datasketches/kll/KllDoublesSketch.java
index 2aa4d9c1..e1d02051 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDoublesSketch.java
@@ -33,7 +33,22 @@ import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableMemory;
+/**
+ * This variation of the KllSketch implements primitive doubles for the quantile values.
+ *
+ * @see <a href="https://datasketches.apache.org/docs/KLL/KLLSketch.html">KLL Sketch</a>
+ * @see org.apache.datasketches.kll.KllSketch
+ * @see <a href="https://datasketches.apache.org/api/java/snapshot/apidocs/org/apache/datasketches/kll/package-summary.html">
+ * KLL package summary</a>
+ * @see <a href="https://datasketches.apache.org/docs/Quantiles/SketchingQuantilesAndRanksTutorial.html">
+ * Sketching Quantiles and Ranks, Tutorial</a>
+ * @see org.apache.datasketches.QuantileSearchCriteria
+ * @author Lee Rhodes
+ * @author Kevin Lang
+ * @author Alexander Saydakov
+ */
public abstract class KllDoublesSketch extends KllSketch {
+ KllDoublesSketchSortedView kllDoublesSV = null;
KllDoublesSketch(final WritableMemory wmem, final MemoryRequestServer memReqSvr) {
super(SketchType.DOUBLES_SKETCH, wmem, memReqSvr);
@@ -406,6 +421,7 @@ public abstract class KllDoublesSketch extends KllSketch {
public void update(final double value) {
if (readOnly) { kllSketchThrow(TGT_IS_READ_ONLY); }
KllDoublesHelper.updateDouble(this, value);
+ kllDoublesSV = null;
}
/**
@@ -420,7 +436,7 @@ public abstract class KllDoublesSketch extends KllSketch {
}
@Override //Artifact of inheritance
- float[] getFloatItemsArray() { kllSketchThrow(MUST_NOT_CALL); return null; }
+ float[] getFloatValuesArray() { kllSketchThrow(MUST_NOT_CALL); return null; }
@Override //Artifact of inheritance
float getMaxFloatValue() { kllSketchThrow(MUST_NOT_CALL); return Float.NaN; }
diff --git a/src/main/java/org/apache/datasketches/kll/KllFloatsHelper.java b/src/main/java/org/apache/datasketches/kll/KllFloatsHelper.java
index a29d9c89..fbefeb7b 100644
--- a/src/main/java/org/apache/datasketches/kll/KllFloatsHelper.java
+++ b/src/main/java/org/apache/datasketches/kll/KllFloatsHelper.java
@@ -36,8 +36,9 @@ final class KllFloatsHelper {
//Called from KllSketch
- static void mergeFloatImpl(final KllSketch sketch, final KllSketch other) {
+ static void mergeFloatImpl(final KllFloatsSketch sketch, final KllSketch other) {
if (other.isEmpty()) { return; }
+ sketch.kllFloatsSV = null;
final long finalN = sketch.getN() + other.getN();
final int otherNumLevels = other.getNumLevels();
final int[] otherLevelsArr = other.getLevelsArray();
@@ -49,10 +50,10 @@ final class KllFloatsHelper {
//update this sketch with level0 items from the other sketch
if (other.isCompactSingleItem()) {
- updateFloat(sketch, other.getFloatSingleItem());
+ updateFloat(sketch, other.getFloatSingleValue());
otherFloatItemsArr = new float[0];
} else {
- otherFloatItemsArr = other.getFloatItemsArray();
+ otherFloatItemsArr = other.getFloatValuesArray();
for (int i = otherLevelsArr[0]; i < otherLevelsArr[1]; i++) {
updateFloat(sketch, otherFloatItemsArr[i]);
}
@@ -60,7 +61,7 @@ final class KllFloatsHelper {
// after the level 0 update, we capture the state of levels and items arrays
final int myCurNumLevels = sketch.getNumLevels();
final int[] myCurLevelsArr = sketch.getLevelsArray();
- final float[] myCurFloatItemsArr = sketch.getFloatItemsArray();
+ final float[] myCurFloatItemsArr = sketch.getFloatValuesArray();
int myNewNumLevels = myCurNumLevels;
int[] myNewLevelsArr = myCurLevelsArr;
@@ -274,7 +275,7 @@ final class KllFloatsHelper {
assert numLevelsIn > 0; // things are too weird if zero levels are allowed
int numLevels = numLevelsIn;
int currentItemCount = inLevels[numLevels] - inLevels[0]; // decreases with each compaction
- int targetItemCount = KllHelper.computeTotalItemCapacity(k, m, numLevels); // increases if we add levels
+ int targetItemCount = KllHelper.computeTotalValueCapacity(k, m, numLevels); // increases if we add levels
boolean doneYet = false;
outLevels[0] = 0;
int curLevel = -1;
diff --git a/src/main/java/org/apache/datasketches/kll/KllFloatsSketch.java b/src/main/java/org/apache/datasketches/kll/KllFloatsSketch.java
index e420fcf6..e46937de 100644
--- a/src/main/java/org/apache/datasketches/kll/KllFloatsSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllFloatsSketch.java
@@ -26,15 +26,32 @@ import static org.apache.datasketches.kll.KllSketch.Error.MUST_NOT_BE_UPDATABLE_
import static org.apache.datasketches.kll.KllSketch.Error.MUST_NOT_CALL;
import static org.apache.datasketches.kll.KllSketch.Error.TGT_IS_READ_ONLY;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
+import static org.apache.datasketches.QuantileSearchCriteria.*;
import java.util.Objects;
+import org.apache.datasketches.QuantileSearchCriteria;
+import org.apache.datasketches.SketchesArgumentException;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableMemory;
+/**
+ * This variation of the KllSketch implements primitive floats for the quantile values.
+ *
+ * @see <a href="https://datasketches.apache.org/docs/KLL/KLLSketch.html">KLL Sketch</a>
+ * @see org.apache.datasketches.kll.KllSketch
+ * @see <a href="https://datasketches.apache.org/api/java/snapshot/apidocs/org/apache/datasketches/kll/package-summary.html">
+ * KLL package summary</a>
+ * @see <a href="https://datasketches.apache.org/docs/Quantiles/SketchingQuantilesAndRanksTutorial.html">
+ * Sketching Quantiles and Ranks, Tutorial</a>
+ * @see org.apache.datasketches.QuantileSearchCriteria
+ * @author Lee Rhodes
+ * @author Kevin Lang
+ * @author Alexander Saydakov
+ */
public abstract class KllFloatsSketch extends KllSketch {
- KllFloatsSketchSortedView sortedView = null;
+ KllFloatsSketchSortedView kllFloatsSV = null;
KllFloatsSketch(final WritableMemory wmem, final MemoryRequestServer memReqSvr) {
super(SketchType.FLOATS_SKETCH, wmem, memReqSvr);
@@ -158,15 +175,31 @@ public abstract class KllFloatsSketch extends KllSketch {
}
/**
- * Same as {@link #getCDF(float[], boolean) getCDF(float[] splitPoints, false)}
+ * Same as {@link #getCDF(float[], QuantileSearchCriteria) getCDF(splitPoints, NON_INCLUSIVE)}
* @param splitPoints splitPoints
* @return CDF
*/
public double[] getCDF(final float[] splitPoints) {
//TDO add check for sorted view eventually
- return KllFloatsSketchSortedView.getFloatsPmfOrCdf(this, splitPoints, true, false);
+ return KllFloatsSketchSortedView.getFloatsPmfOrCdf(this, splitPoints, true, NON_INCLUSIVE);
}
+ /**
+ * Returns the max value of the stream.
+ * If the sketch is empty this returns NaN.
+ *
+ * @return the max value of the stream
+ */
+ public float getMaxValue() { return getMaxFloatValue(); }
+
+ /**
+ * Returns the min value of the stream.
+ * If the sketch is empty this returns NaN.
+ *
+ * @return the min value of the stream
+ */
+ public float getMinValue() { return getMinFloatValue(); }
+
/**
* 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).
@@ -191,34 +224,19 @@ public abstract class KllFloatsSketch extends KllSketch {
* The value at array position j of the returned CDF array is the sum of the returned values
* in positions 0 through j of the returned PMF array.
*/
- public double[] getCDF(final float[] splitPoints, final boolean inclusive) {
+ public double[] getCDF(final float[] splitPoints, final QuantileSearchCriteria inclusive) {
//TODO add check for sorted view eventually
return KllFloatsSketchSortedView.getFloatsPmfOrCdf(this, splitPoints, true, inclusive);
}
/**
- * Returns the max value of the stream.
- * If the sketch is empty this returns NaN.
- *
- * @return the max value of the stream
- */
- public float getMaxValue() { return getMaxFloatValue(); }
-
- /**
- * Returns the min value of the stream.
- * If the sketch is empty this returns NaN.
- *
- * @return the min value of the stream
- */
- public float getMinValue() { return getMinFloatValue(); }
-
- /**
- * Same as {@link #getPMF(float[], boolean) getPMF(float[] splitPoints, false)}
+ * Same as {@link #getPMF(float[], QuantileSearchCriteria) getPMF(splitPoints, NON_INCLUSIVE)}
* @param splitPoints splitPoints
* @return PMF
*/
public double[] getPMF(final float[] splitPoints) {
- return KllFloatsSketchSortedView.getFloatsPmfOrCdf(this, splitPoints, false, false);
+ //TODO add check for sorted view eventually
+ return KllFloatsSketchSortedView.getFloatsPmfOrCdf(this, splitPoints, false, NON_INCLUSIVE);
}
/**
@@ -241,131 +259,137 @@ public abstract class KllFloatsSketch extends KllSketch {
* Otherwise the rank equals the sum of the weights of all values that are less than the given value
*
* @return an array of m+1 doubles on the interval [0.0, 1.0),
- * each of which is an approximation to the fraction of the total input stream values
- * (the mass) that fall into one of those intervals.
+ * each of which is an approximation to the fraction, or mass, of the total input stream values
+ * that fall into one of those intervals.
+ * //TODO is this correct?
* 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 float[] splitPoints, final boolean inclusive) {
+ public double[] getPMF(final float[] splitPoints, final QuantileSearchCriteria inclusive) {
//add check for sorted view eventually
return KllFloatsSketchSortedView.getFloatsPmfOrCdf(this, splitPoints, false, inclusive);
}
/**
- * Same as {@link #getQuantile(double, boolean) getQuantile(double fraction, false)}
+ * Same as {@link #getQuantile(double, QuantileSearchCriteria) getQuantile(rank, NON_INCLUSIVE)}
* @param rank the given normalized rank, a value in the interval [0.0,1.0].
* @return quantile
+ * @see org.apache.datasketches.QuantileSearchCriteria QuantileSearchCriteria
*/
public float getQuantile(final double rank) {
- return KllFloatsSketchSortedView.getFloatsQuantile(this, rank, false);
+ return getQuantile(rank, NON_INCLUSIVE);
}
/**
- * Returns an approximation to the value of the data item
- * that would be preceded by the given fraction of a hypothetical sorted
- * version of the input stream so far.
+ * Returns the quantile associated with the given rank.
*
- * <p>We note that this method has a fairly large overhead (microseconds instead of nanoseconds)
- * so it should not be called multiple times to get different quantiles from the same
- * sketch. Instead use getQuantiles(), which pays the overhead only once.
+ * <p>We note that this method has an overhead (microseconds instead of nanoseconds) when called for the first time
+ * after an update or sketch merge. Use getQuantiles() if there is a requirement to obtain multiple quantiles.
*
* <p>If the sketch is empty this returns NaN.
*
* @param rank the given normalized rank, a value in the interval [0.0,1.0].
- *
- * @param inclusive if true, the given rank includes all values ≤ the value directly
+ * @param inclusive is INCLUSIVE, the given rank includes all values ≤ the value directly
* corresponding to the given rank.
- * @return the approximation to the value at the given fraction
+ * @return the quantile associated with the given rank.
+ * @see org.apache.datasketches.QuantileSearchCriteria QuantileSearchCriteria
*/
- public float getQuantile(final double rank, final boolean inclusive) {
- //TODO START HERE
- return KllFloatsSketchSortedView.getFloatsQuantile(this, rank, inclusive);
+ public float getQuantile(final double rank, final QuantileSearchCriteria inclusive) {
+ if (this.isEmpty()) { return Float.NaN; }
+ checkRank(rank);
+ refreshSortedView();
+ return kllFloatsSV.getQuantile(rank, inclusive);
}
/**
- * Gets the lower bound of the value interval in which the true quantile of the given rank
- * exists with a confidence of at least 99%.
- * @param rank the given normalized rank, a value in the interval [0.0,1.0].
- * @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.
+ * Same as {@link #getQuantiles(double[], QuantileSearchCriteria) getQuantiles(ranks, NON_INCLUSIVE)}
+ * @param ranks normalied ranks on the interval [0.0, 1.0].
+ * @return quantiles
+ * @see org.apache.datasketches.QuantileSearchCriteria QuantileSearchCriteria
*/
- public float getQuantileLowerBound(final double rank) {
- return getQuantile(max(0, rank - KllHelper.getNormalizedRankError(getMinK(), false)));
+ public float[] getQuantiles(final double[] ranks) {
+ return getQuantiles(ranks, NON_INCLUSIVE);
}
/**
* This is a more efficient multiple-query version of getQuantile().
*
- * <p>This returns an array that could have been generated by using getQuantile() with many
- * different fractional ranks, but would be very inefficient.
- * This method incurs the internal set-up overhead once and obtains multiple quantile values in
- * a single query. It is strongly recommend that this method be used instead of multiple calls
- * to getQuantile().
+ * <p>Returns an array of quantiles from the given array of normalized ranks.
*
* <p>If the sketch is empty this returns null.
*
- * @param fractions the given array of normalized ranks, each of which must be in the interval [0.0,1.0].
- * @param inclusive if true, the given ranks include all values ≤ the value directly corresponding to each rank.
- * @return array of approximations to the given fractions in the same order as given fractions
- * array.
+ * @param ranks the given array of normalized ranks, each of which must be in the interval [0.0,1.0].
+ * @param inclusive if INCLUSIVE, the given ranks include all values ≤ the value directly corresponding to each rank.
+ * @return array of quantiles
+ * @see org.apache.datasketches.QuantileSearchCriteria QuantileSearchCriteria
*/
- public float[] getQuantiles(final double[] fractions, final boolean inclusive) {
- return KllFloatsSketchSortedView.getFloatsQuantiles(this, fractions, inclusive);
+ public float[] getQuantiles(final double[] ranks, final QuantileSearchCriteria inclusive) {
+ if (this.isEmpty()) { return null; }
+ checkRanks(ranks);
+ refreshSortedView();
+ final int len = ranks.length;
+ final float[] quantiles = new float[len];
+ for (int i = 0; i < len; i++) {
+ quantiles[i] = kllFloatsSV.getQuantile(ranks[i], inclusive);
+ }
+ return quantiles;
}
/**
- * Same as {@link #getQuantiles(double[], boolean) getQuantiles(double[] fractions, false)}
- * @param ranks fractional ranks
- * @return quantiles
+ * Same as {@link #getQuantiles(int, QuantileSearchCriteria) getQuantiles(numEvenlySpaced, NON_INCLUSIVE)}
+ * @param numEvenlySpaced number of evenly spaced normalied ranks
+ * @return array of quantiles.
+ * @see org.apache.datasketches.QuantileSearchCriteria QuantileSearchCriteria
*/
- public float[] getQuantiles(final double[] ranks) {
- return KllFloatsSketchSortedView.getFloatsQuantiles(this, ranks, false);
+ public float[] getQuantiles(final int numEvenlySpaced) {
+ if (isEmpty()) { return null; }
+ return getQuantiles(org.apache.datasketches.Util.evenlySpaced(0.0, 1.0, numEvenlySpaced), NON_INCLUSIVE);
}
/**
* This is also a more efficient multiple-query version of getQuantile() and allows the caller to
- * specify the number of evenly spaced fractional ranks.
+ * specify the number of evenly spaced normalized ranks.
*
* <p>If the sketch is empty this returns null.
*
- * @param numEvenlySpaced an integer that specifies the number of evenly spaced fractional ranks.
+ * @param numEvenlySpaced an integer that specifies the number of evenly spaced normalized ranks.
* This must be a positive integer greater than 0. A value of 1 will return the min value.
* A value of 2 will return the min and the max value. A value of 3 will return the min,
* the median and the max value, etc.
*
- * @param inclusive if true, the fractional ranks are considered inclusive
- * @return array of approximations to the given fractions in the same order as given fractions
- * array.
+ * @param inclusive if true, the normalized ranks are considered inclusive
+ * @return array of quantiles.
+ * @see org.apache.datasketches.QuantileSearchCriteria QuantileSearchCriteria
*/
- public float[] getQuantiles(final int numEvenlySpaced, final boolean inclusive) {
+ public float[] getQuantiles(final int numEvenlySpaced, final QuantileSearchCriteria inclusive) {
if (isEmpty()) { return null; }
return getQuantiles(org.apache.datasketches.Util.evenlySpaced(0.0, 1.0, numEvenlySpaced), inclusive);
}
/**
- * Same as {@link #getQuantiles(int, boolean) getQuantiles(int numEvenlySpaced, false)}
- * @param numEvenlySpaced number of evenly spaced fractional ranks
- * @return quantiles
+ * Gets the lower bound of the value interval in which the true quantile of the given rank
+ * exists with a confidence of at least 99%.
+ * @param rank the given normalized rank, a value in the interval [0.0,1.0].
+ * @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 float[] getQuantiles(final int numEvenlySpaced) {
- if (isEmpty()) { return null; }
- return getQuantiles(org.apache.datasketches.Util.evenlySpaced(0.0, 1.0, numEvenlySpaced));
+ public float getQuantileLowerBound(final double rank) {
+ return getQuantile(max(0, rank - KllHelper.getNormalizedRankError(getMinK(), false)));
}
/**
* Gets the upper bound of the value interval in which the true quantile of the given rank
* exists with a confidence of at least 99%.
- * @param fraction the given normalized rank as a fraction
+ * @param rank the given normalized rank
* @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 float getQuantileUpperBound(final double fraction) {
- return getQuantile(min(1.0, fraction + KllHelper.getNormalizedRankError(getMinK(), false)));
+ public float getQuantileUpperBound(final double rank) {
+ return getQuantile(min(1.0, rank + KllHelper.getNormalizedRankError(getMinK(), false)));
}
/**
- * Returns an approximation to the normalized (fractional) rank of the given value from 0 to 1,
- * inclusive.
+ * Returns a normalized rank given a quantile value.
*
* <p>The resulting approximation has a probabilistic guarantee that can be obtained from the
* getNormalizedRankError(false) function.
@@ -373,28 +397,27 @@ public abstract class KllFloatsSketch extends KllSketch {
* <p>If the sketch is empty this returns NaN.</p>
*
* @param value to be ranked
- * @param inclusive if true the weight of the given value is included into the rank.
- * Otherwise the rank equals the sum of the weights of all values that are less than the given value
+ * @param inclusive if INCLUSIVE the weight of the given quantile value is included into the rank.
* @return an approximate rank of the given value
*/
- public double getRank(final float value, final boolean inclusive) {
+ public double getRank(final float value, final QuantileSearchCriteria inclusive) {
return KllFloatsSketchSortedView.getFloatRank(this, value, inclusive);
}
/**
- * Same as {@link #getRank(float, boolean) getRank(float value, false)}
+ * Same as {@link #getRank(float, QuantileSearchCriteria) getRank(value, NON_INCLUSIVE)}
* @param value value to be ranked
- * @return fractional rank
+ * @return normalized rank
*/
public double getRank(final float value) {
- return KllFloatsSketchSortedView.getFloatRank(this, value, false);
+ return KllFloatsSketchSortedView.getFloatRank(this, value, NON_INCLUSIVE);
}
/**
* @return the iterator for this class
*/
public KllFloatsSketchIterator iterator() {
- return new KllFloatsSketchIterator(getFloatItemsArray(), getLevelsArray(), getNumLevels());
+ return new KllFloatsSketchIterator(getFloatValuesArray(), getLevelsArray(), getNumLevels());
}
/**
@@ -405,6 +428,7 @@ public abstract class KllFloatsSketch extends KllSketch {
public void update(final float value) {
if (readOnly) { kllSketchThrow(TGT_IS_READ_ONLY); }
KllFloatsHelper.updateFloat(this, value);
+ kllFloatsSV = null;
}
/**
@@ -413,7 +437,7 @@ public abstract class KllFloatsSketch extends KllSketch {
* @return sorted view object
*/
public KllFloatsSketchSortedView getSortedView() {
- return KllFloatsSketchSortedView.getFloatsSortedView(this);
+ return kllFloatsSV = (kllFloatsSV == null) ? new KllFloatsSketchSortedView(this) : kllFloatsSV;
}
@Override //Artifact of inheritance
@@ -437,4 +461,22 @@ public abstract class KllFloatsSketch extends KllSketch {
@Override //Artifact of inheritance
void setMinDoubleValue(final double value) { kllSketchThrow(MUST_NOT_CALL); }
+ private static final void checkRank(final double rank) {
+ if (rank < 0.0 || rank > 1.0) {
+ throw new SketchesArgumentException("Rank cannot be less than zero nor greater than 1.0");
+ }
+ }
+
+ private static final void checkRanks(final double[] ranks) {
+ for (int i = 0; i < ranks.length; i++) {
+ if ((ranks[i] < 0.0) || (ranks[i] > 1.0)) {
+ throw new SketchesArgumentException("Rank " + ranks[i] + " cannot be less than 0.0 nor greater than 1.0");
+ }
+ }
+ }
+
+ private final void refreshSortedView() {
+ kllFloatsSV = (kllFloatsSV == null) ? new KllFloatsSketchSortedView(this) : kllFloatsSV;
+ }
+
}
diff --git a/src/main/java/org/apache/datasketches/kll/KllFloatsSketchSortedView.java b/src/main/java/org/apache/datasketches/kll/KllFloatsSketchSortedView.java
index b4f8191f..288066ce 100644
--- a/src/main/java/org/apache/datasketches/kll/KllFloatsSketchSortedView.java
+++ b/src/main/java/org/apache/datasketches/kll/KllFloatsSketchSortedView.java
@@ -19,10 +19,15 @@
package org.apache.datasketches.kll;
+import static org.apache.datasketches.QuantileSearchCriteria.INCLUSIVE;
+import static org.apache.datasketches.QuantileSearchCriteria.NON_INCLUSIVE;
+import static org.apache.datasketches.QuantileSearchCriteria.NON_INCLUSIVE_STRICT;
+
import java.util.Arrays;
+import org.apache.datasketches.InequalitySearch;
+import org.apache.datasketches.QuantileSearchCriteria;
import org.apache.datasketches.SketchesArgumentException;
-import org.apache.datasketches.SketchesStateException;
/**
* The Sorted View provides a view of the data retained by the sketch that would be cumbersome to get any other way.
@@ -45,95 +50,111 @@ import org.apache.datasketches.SketchesStateException;
* @author Alexander Saydakov
*/
public final class KllFloatsSketchSortedView {
- private final long n_;
- private final float[] items_;
- private final long[] weights_; //comes in as weights, converted to cumulative weights
- private final int[] levels_;
- private int numLevels_;
-
- // assumes that all levels are sorted including level 0
- KllFloatsSketchSortedView(final float[] items, final int[] levels, final int numLevels, final long n) {
- n_ = n;
- final int numItems = levels[numLevels] - levels[0];
- items_ = new float[numItems];
- weights_ = new long[numItems];
- levels_ = new int[numLevels + 1];
- populateFromSketch(items, levels, numLevels, numItems);
- blockyTandemMergeSort(items_, weights_, levels_, numLevels_);
- KllHelper.convertToCumulative(weights_);
- }
+ private final long N;
+ private final float[] values;
+ private final long[] cumWeights; //comes in as individual weights, converted to cumulative natural weights
- static KllFloatsSketchSortedView getFloatsSortedView(final KllSketch sketch) {
- final float[] skFloatItemsArr = sketch.getFloatItemsArray();
- final int[] skLevelsArr = sketch.getLevelsArray();
+ public KllFloatsSketchSortedView(final KllFloatsSketch sk) {
+ this.N = sk.getN();
+ final float[] srcValues = sk.getFloatValuesArray();
+ final int[] srcLevels = sk.getLevelsArray();
+ final int srcNumLevels = sk.getNumLevels();
- if (!sketch.isLevelZeroSorted()) {
- Arrays.sort(skFloatItemsArr, skLevelsArr[0], skLevelsArr[1]);
- if (!sketch.hasMemory()) { sketch.setLevelZeroSorted(true); }
+ if (!sk.isLevelZeroSorted()) {
+ Arrays.sort(srcValues, srcLevels[0], srcLevels[1]);
+ if (!sk.hasMemory()) { sk.setLevelZeroSorted(true); }
}
- return new KllFloatsSketchSortedView(skFloatItemsArr, skLevelsArr, sketch.getNumLevels(), sketch.getN());
+
+ final int numItems = srcLevels[srcNumLevels] - srcLevels[0]; //remove garbage
+ values = new float[numItems];
+ cumWeights = new long[numItems];
+ populateFromSketch(srcValues, srcLevels, srcNumLevels, numItems);
+ sk.kllFloatsSV = this;
}
+ //populates values, cumWeights, levels, numLevels
private void populateFromSketch(final float[] srcItems, final int[] srcLevels,
- final int numLevels, final int numItems) {
+ final int srcNumLevels, final int numItems) {
+ final int[] myLevels = new int[srcNumLevels + 1];
final int offset = srcLevels[0];
- System.arraycopy(srcItems, offset, items_, 0, numItems);
+ System.arraycopy(srcItems, offset, values, 0, numItems);
int srcLevel = 0;
int dstLevel = 0;
long weight = 1;
- while (srcLevel < numLevels) {
+ while (srcLevel < srcNumLevels) {
final int fromIndex = srcLevels[srcLevel] - offset;
final int toIndex = srcLevels[srcLevel + 1] - offset; // exclusive
if (fromIndex < toIndex) { // if equal, skip empty level
- Arrays.fill(weights_, fromIndex, toIndex, weight);
- levels_[dstLevel] = fromIndex;
- levels_[dstLevel + 1] = toIndex;
+ Arrays.fill(cumWeights, fromIndex, toIndex, weight);
+ myLevels[dstLevel] = fromIndex;
+ myLevels[dstLevel + 1] = toIndex;
dstLevel++;
}
srcLevel++;
weight *= 2;
}
- weights_[numItems] = 0;
- numLevels_ = dstLevel;
+ final int numLevels = dstLevel;
+ blockyTandemMergeSort(values, cumWeights, myLevels, numLevels); //create unit weights
+ KllHelper.convertToCumulative(cumWeights);
}
-
- //For testing only. Allows testing of getQuantile without a sketch. NOT USED
- KllFloatsSketchSortedView(final float[] items, final long[] weights, final long n) {
- n_ = n;
- items_ = items;
- weights_ = weights; //must be size of items + 1
- levels_ = null; //not used by test
- numLevels_ = 0; //not used by test
+ /**
+ * Gets the quantile based on the given normalized rank,
+ * which must be in the range [0.0, 1.0], inclusive.
+ * @param normRank the given normalized rank
+ * @param inclusive determines the search criterion used.
+ * @return the quantile
+ */
+ public float getQuantile(final double normRank, final QuantileSearchCriteria inclusive) {
+ final int len = cumWeights.length;
+ final long rank = (int)(normRank * N);
+ final InequalitySearch crit = (inclusive == INCLUSIVE) ? InequalitySearch.GE : InequalitySearch.GT;
+ final int index = InequalitySearch.find(cumWeights, 0, len - 1, rank, crit);
+ if (index == -1) {
+ if (inclusive == NON_INCLUSIVE_STRICT) { return Float.NaN; } //GT: normRank == 1.0;
+ if (inclusive == NON_INCLUSIVE) { return values[len - 1]; }
+ }
+ return values[index];
}
- @SuppressWarnings("deprecation")
- public float getQuantile(final double rank) {
- if (weights_[weights_.length - 1] < n_) {
- throw new SketchesStateException("getQuantile must be used with cumulative view only");
+ /**
+ * Gets the normalized rank based on the given value.
+ * @param value the given value
+ * @param inclusive determines the search criterion used.
+ * @return the normalized rank
+ */
+ public double getRank(final float value, final QuantileSearchCriteria inclusive) {
+ final int len = values.length;
+ final InequalitySearch crit = (inclusive == INCLUSIVE) ? InequalitySearch.LE : InequalitySearch.LT;
+ final int index = InequalitySearch.find(values, 0, len - 1, value, crit);
+ if (index == -1) {
+ return 0; //LT: value <= minValue; LE: value < minValue
}
- final long pos = KllQuantilesHelper.posOfRank(rank, n_);
- return approximatelyAnswerPositonalQuery(pos);
+ return (double)cumWeights[index] / N;
}
+ /**
+ * Returns an iterator for this sorted view
+ * @return an iterator for this sorted view
+ */
public KllFloatsSketchSortedViewIterator iterator() {
- return new KllFloatsSketchSortedViewIterator(items_, weights_);
+ return new KllFloatsSketchSortedViewIterator(values, cumWeights);
}
- //Called only from KllFloatsSketch
- static double getFloatRank(final KllSketch sketch, final float value, final boolean inclusive) {
+ //Called only from KllFloatsSketch - original search for rank
+ static double getFloatRank(final KllSketch sketch, final float value, final QuantileSearchCriteria inclusive) {
if (sketch.isEmpty()) { return Double.NaN; }
int level = 0;
int weight = 1;
long total = 0;
- final float[] floatItemsArr = sketch.getFloatItemsArray();
+ final float[] floatItemsArr = sketch.getFloatValuesArray();
final int[] levelsArr = sketch.getLevelsArray();
while (level < sketch.getNumLevels()) {
final int fromIndex = levelsArr[level];
final int toIndex = levelsArr[level + 1]; // exclusive
for (int i = fromIndex; i < toIndex; i++) {
- if (inclusive ? floatItemsArr[i] <= value : floatItemsArr[i] < value) {
+ if (inclusive == INCLUSIVE ? floatItemsArr[i] <= value : floatItemsArr[i] < value) {
total += weight;
} else if (level > 0 || sketch.isLevelZeroSorted()) {
break; // levels above 0 are sorted, no point comparing further
@@ -147,7 +168,7 @@ public final class KllFloatsSketchSortedView {
//Called only from KllFloatsSketch TODO rewrite using sorted view and new getRanks
static double[] getFloatsPmfOrCdf(final KllSketch sketch, final float[] splitPoints,
- final boolean isCdf, final boolean inclusive) {
+ final boolean isCdf, final QuantileSearchCriteria inclusive) {
if (sketch.isEmpty()) { return null; }
validateFloatValues(splitPoints);
final double[] buckets = new double[splitPoints.length + 1];
@@ -184,6 +205,7 @@ public final class KllFloatsSketchSortedView {
/**
* Checks the sequential validity of the given array of float values.
* They must be unique, monotonically increasing and not NaN.
+ * Only used for getPmfOrCdf().
* @param values the given array of values
*/
private static void validateFloatValues(final float[] values) {
@@ -198,14 +220,15 @@ public final class KllFloatsSketchSortedView {
}
}
+ //Only used for getPmfOrCdf
private static void incrementFloatBucketsSortedLevel(
final KllSketch sketch, final int fromIndex, final int toIndex, final int weight,
- final float[] splitPoints, final double[] buckets, final boolean inclusive) {
- final float[] floatItemsArr = sketch.getFloatItemsArray();
+ final float[] splitPoints, final double[] buckets, final QuantileSearchCriteria inclusive) {
+ final float[] floatItemsArr = sketch.getFloatValuesArray();
int i = fromIndex;
int j = 0;
while (i < toIndex && j < splitPoints.length) {
- if (inclusive ? floatItemsArr[i] <= splitPoints[j]: floatItemsArr[i] < splitPoints[j]) {
+ if (inclusive == INCLUSIVE ? floatItemsArr[i] <= splitPoints[j]: floatItemsArr[i] < splitPoints[j]) {
buckets[j] += weight; // this sample goes into this bucket
i++; // move on to next sample and see whether it also goes into this bucket
} else {
@@ -220,14 +243,15 @@ public final class KllFloatsSketchSortedView {
}
}
+ //Only used for getPmfOrCdf
private static void incrementFloatBucketsUnsortedLevel(
final KllSketch sketch, final int fromIndex, final int toIndex, final int weight,
- final float[] splitPoints, final double[] buckets, final boolean inclusive) {
- final float[] floatItemsArr = sketch.getFloatItemsArray();
+ final float[] splitPoints, final double[] buckets, final QuantileSearchCriteria inclusive) {
+ final float[] floatItemsArr = sketch.getFloatValuesArray();
for (int i = fromIndex; i < toIndex; i++) {
int j;
for (j = 0; j < splitPoints.length; j++) {
- if (inclusive ? floatItemsArr[i] <= splitPoints[j] : floatItemsArr[i] < splitPoints[j]) {
+ if (inclusive == INCLUSIVE ? floatItemsArr[i] <= splitPoints[j] : floatItemsArr[i] < splitPoints[j]) {
break;
}
}
@@ -235,35 +259,6 @@ public final class KllFloatsSketchSortedView {
}
}
- //Called only from KllFloatsSketch
- static float getFloatsQuantile(final KllSketch sketch, final double rank, final boolean inclusive) {
- if (sketch.isEmpty()) { return Float.NaN; }
- if (rank < 0.0 || rank > 1.0) {
- throw new SketchesArgumentException("Fraction cannot be less than zero nor greater than 1.0");
- }
- final KllFloatsSketchSortedView kllFSV = KllFloatsSketchSortedView.getFloatsSortedView(sketch);
- return kllFSV.getQuantile(rank);
- }
-
- //Called only from KllFloatsSketch
- static float[] getFloatsQuantiles(final KllSketch sketch, final double[] fractions, final boolean inclusive) {
- if (sketch.isEmpty()) { return null; }
- KllFloatsSketchSortedView kllFSV = null;
- final float[] quantiles = new float[fractions.length];
- for (int i = 0; i < fractions.length; i++) { //check if fraction are in [0, 1]
- final double fraction = fractions[i];
- if (fraction < 0.0 || fraction > 1.0) {
- throw new SketchesArgumentException("Fraction cannot be less than zero nor greater than 1.0");
- }
- if (kllFSV == null) {
- kllFSV = getFloatsSortedView(sketch);
- }
- quantiles[i] = kllFSV.getQuantile(fraction);
- }
- return quantiles;
- }
-
-
private static void blockyTandemMergeSort(final float[] items, final long[] weights,
final int[] levels, final int numLevels) {
if (numLevels == 1) { return; }
@@ -279,6 +274,7 @@ public final class KllFloatsSketchSortedView {
final float[] itemsSrc, final long[] weightsSrc,
final float[] itemsDst, final long[] weightsDst,
final int[] levels, final int startingLevel, final int numLevels) {
+ //printAll(itemsSrc, weightsSrc, itemsDst, weightsDst, levels, startingLevel, numLevels);
if (numLevels == 1) { return; }
final int numLevels1 = numLevels / 2;
final int numLevels2 = numLevels - numLevels1;
@@ -338,12 +334,57 @@ public final class KllFloatsSketchSortedView {
}
}
- @SuppressWarnings("deprecation")
- private float approximatelyAnswerPositonalQuery(final long pos) {
- assert pos >= 0;
- assert pos < n_;
- final int index = KllQuantilesHelper.chunkContainingPos(weights_, pos);
- return items_[index];
+// @SuppressWarnings("deprecation")
+// private float approximatelyAnswerPositonalQuery(final long pos) {
+// assert pos >= 0;
+// assert pos < N;
+// final int index = KllQuantilesHelper.chunkContainingPos(cumWeights, pos);
+// return values[index];
+// }
+
+ static void printLevels(int[] levels, int numLevels) {
+ for (int i = 0; i < levels.length; i++) { print(levels[i] + ", "); }
+ println("numLevels: " + numLevels);
+ }
+
+ static void printAll(
+ float[] values, long[] cumWeights,
+ float[] itemsDst, long[] weightsDst,
+ int[] levels, int startingLevel, int numLevels) {
+ //StringBuilder sb = new StringBuilder();
+ println("itemSrc[] len: " + values.length);
+ println("weightsSrc[] len: " + cumWeights.length);
+ println("itemsDst[] len: " + itemsDst.length);
+ println("weightsDst[] len: " + weightsDst.length);
+ println("levels[] len: " + levels.length);
+ for (int i = 0; i < levels.length; i++) { print(levels[i] + ", "); } println("");
+ println("startingLevel: " + startingLevel);
+ println("numLevels: " + numLevels);
+ println("");
+ }
+
+ private final static boolean enablePrinting = true;
+
+ /**
+ * @param format the format
+ * @param args the args
+ */
+ static final void printf(final String format, final Object ...args) {
+ if (enablePrinting) { System.out.printf(format, args); }
+ }
+
+ /**
+ * @param o the Object to println
+ */
+ static final void println(final Object o) {
+ if (enablePrinting) { System.out.println(o.toString()); }
+ }
+
+ /**
+ * @param o the Object to print
+ */
+ static final void print(final Object o) {
+ if (enablePrinting) { System.out.print(o.toString()); }
}
}
diff --git a/src/main/java/org/apache/datasketches/kll/KllHeapDoublesSketch.java b/src/main/java/org/apache/datasketches/kll/KllHeapDoublesSketch.java
index 189b9560..af3b14b3 100644
--- a/src/main/java/org/apache/datasketches/kll/KllHeapDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllHeapDoublesSketch.java
@@ -20,9 +20,9 @@
package org.apache.datasketches.kll;
import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR;
-import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllSketch.Error.MUST_NOT_CALL;
-import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllSketch.Error.SRC_MUST_BE_DOUBLE;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
@@ -94,8 +94,8 @@ final class KllHeapDoublesSketch extends KllDoublesSketch {
maxDoubleValue_ = Double.NaN;
doubleItems_ = new double[k_];
}
- else if (memVal.singleItem && !updatableMemFormat) {
- final double value = srcMem.getDouble(DATA_START_ADR_SINGLE_ITEM);
+ else if (memVal.singleValue && !updatableMemFormat) {
+ final double value = srcMem.getDouble(DATA_START_ADR_SINGLE_VALUE);
minDoubleValue_ = maxDoubleValue_ = value;
doubleItems_ = new double[k_];
doubleItems_[k_ - 1] = value;
@@ -138,12 +138,12 @@ final class KllHeapDoublesSketch extends KllDoublesSketch {
@Override
double getDoubleSingleItem() {
- if (n_ != 1L) { kllSketchThrow(NOT_SINGLE_ITEM); return Double.NaN; }
+ if (n_ != 1L) { kllSketchThrow(NOT_SINGLE_VALUE); return Double.NaN; }
return doubleItems_[k_ - 1];
}
@Override
- float getFloatSingleItem() { kllSketchThrow(MUST_NOT_CALL); return Float.NaN; }
+ float getFloatSingleValue() { kllSketchThrow(MUST_NOT_CALL); return Float.NaN; }
@Override
int getM() { return m_; }
diff --git a/src/main/java/org/apache/datasketches/kll/KllHeapFloatsSketch.java b/src/main/java/org/apache/datasketches/kll/KllHeapFloatsSketch.java
index 3499850e..5252e2bf 100644
--- a/src/main/java/org/apache/datasketches/kll/KllHeapFloatsSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllHeapFloatsSketch.java
@@ -20,9 +20,9 @@
package org.apache.datasketches.kll;
import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR;
-import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllSketch.Error.MUST_NOT_CALL;
-import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllSketch.Error.SRC_MUST_BE_FLOAT;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
@@ -94,8 +94,8 @@ final class KllHeapFloatsSketch extends KllFloatsSketch {
maxFloatValue_ = Float.NaN;
floatItems_ = new float[k_];
}
- else if (memVal.singleItem && !updatableMemFormat) {
- final float value = srcMem.getFloat(DATA_START_ADR_SINGLE_ITEM);
+ else if (memVal.singleValue && !updatableMemFormat) {
+ final float value = srcMem.getFloat(DATA_START_ADR_SINGLE_VALUE);
minFloatValue_ = maxFloatValue_ = value;
floatItems_ = new float[k_];
floatItems_[k_ - 1] = value;
@@ -137,11 +137,11 @@ final class KllHeapFloatsSketch extends KllFloatsSketch {
double getDoubleSingleItem() { kllSketchThrow(MUST_NOT_CALL); return Double.NaN; }
@Override
- float[] getFloatItemsArray() { return floatItems_; }
+ float[] getFloatValuesArray() { return floatItems_; }
@Override
- float getFloatSingleItem() {
- if (n_ != 1L) { kllSketchThrow(NOT_SINGLE_ITEM); return Float.NaN; }
+ float getFloatSingleValue() {
+ if (n_ != 1L) { kllSketchThrow(NOT_SINGLE_VALUE); return Float.NaN; }
return floatItems_[k_ - 1];
}
diff --git a/src/main/java/org/apache/datasketches/kll/KllHelper.java b/src/main/java/org/apache/datasketches/kll/KllHelper.java
index 8f5d4cc5..63670a8b 100644
--- a/src/main/java/org/apache/datasketches/kll/KllHelper.java
+++ b/src/main/java/org/apache/datasketches/kll/KllHelper.java
@@ -30,7 +30,7 @@ import static java.lang.Math.round;
import static org.apache.datasketches.Util.floorPowerOf2;
import static org.apache.datasketches.Util.isOdd;
import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR;
-import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllPreambleUtil.DOUBLES_SKETCH_BIT_MASK;
import static org.apache.datasketches.kll.KllPreambleUtil.EMPTY_BIT_MASK;
import static org.apache.datasketches.kll.KllPreambleUtil.FLAGS_BYTE_ADR;
@@ -41,7 +41,7 @@ import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_FULL;
import static org.apache.datasketches.kll.KllPreambleUtil.SERIAL_VERSION_EMPTY_FULL;
import static org.apache.datasketches.kll.KllPreambleUtil.SERIAL_VERSION_SINGLE;
import static org.apache.datasketches.kll.KllPreambleUtil.SERIAL_VERSION_UPDATABLE;
-import static org.apache.datasketches.kll.KllPreambleUtil.SINGLE_ITEM_BIT_MASK;
+import static org.apache.datasketches.kll.KllPreambleUtil.SINGLE_VALUE_BIT_MASK;
import static org.apache.datasketches.kll.KllPreambleUtil.UPDATABLE_BIT_MASK;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryDoubleSketchFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryEmptyFlag;
@@ -54,7 +54,7 @@ import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryN;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryNumLevels;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryPreInts;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemorySerVer;
-import static org.apache.datasketches.kll.KllPreambleUtil.setMemorySingleItemFlag;
+import static org.apache.datasketches.kll.KllPreambleUtil.setMemorySingleValueFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryUpdatableFlag;
import static org.apache.datasketches.kll.KllSketch.SketchType.DOUBLES_SKETCH;
@@ -202,7 +202,7 @@ final class KllHelper {
sketch.setDoubleItemsArray(myDoubleItemsArr);
}
else { //Float sketch
- final float[] myFloatItemsArr = sketch.getFloatItemsArray();
+ final float[] myFloatItemsArr = sketch.getFloatValuesArray();
if (level == 0) { // level zero might not be sorted, so we must sort it if we wish to compact it
Arrays.sort(myFloatItemsArr, adjBeg, adjBeg + adjPop);
}
@@ -252,7 +252,7 @@ final class KllHelper {
* @param numLevels the upper bound number of levels based on <i>n</i> items.
* @return the total item capacity of the sketch.
*/
- static int computeTotalItemCapacity(final int k, final int m, final int numLevels) {
+ static int computeTotalValueCapacity(final int k, final int m, final int numLevels) {
long total = 0;
for (int level = 0; level < numLevels; level++) {
total += levelCapacity(k, numLevels, level, m);
@@ -569,13 +569,13 @@ final class KllHelper {
final boolean doubleType = (sketch.sketchType == DOUBLES_SKETCH);
//load data
- int offset = DATA_START_ADR_SINGLE_ITEM;
+ int offset = DATA_START_ADR_SINGLE_VALUE;
final int[] myLevelsArr = sketch.getLevelsArray();
if (sketch.getN() == 1) { //single item
if (doubleType) {
wmem.putDouble(offset, sketch.getDoubleItemsArray()[myLevelsArr[0]]);
} else {
- wmem.putFloat(offset, sketch.getFloatItemsArray()[myLevelsArr[0]]);
+ wmem.putFloat(offset, sketch.getFloatValuesArray()[myLevelsArr[0]]);
}
} else { // n > 1
//remainder of preamble after first 8 bytes
@@ -601,7 +601,7 @@ final class KllHelper {
offset += Float.BYTES;
wmem.putFloat(offset, sketch.getMaxFloatValue());
offset += Float.BYTES;
- wmem.putFloatArray(offset, sketch.getFloatItemsArray(), myLevelsArr[0], sketch.getNumRetained());
+ wmem.putFloatArray(offset, sketch.getFloatValuesArray(), myLevelsArr[0], sketch.getNumRetained());
}
}
return byteArr;
@@ -626,13 +626,13 @@ final class KllHelper {
byteArr[0] = PREAMBLE_INTS_EMPTY_SINGLE; //2
byteArr[1] = SERIAL_VERSION_SINGLE; //2
byteArr[2] = KLL_FAMILY; //15
- byteArr[3] = (byte) (SINGLE_ITEM_BIT_MASK | doubleFlagBit);
+ byteArr[3] = (byte) (SINGLE_VALUE_BIT_MASK | doubleFlagBit);
ByteArrayUtil.putShortLE(byteArr, K_SHORT_ADR, (short)sketch.getK());
byteArr[6] = (byte)sketch.getM();
if (doubleSketch) {
- ByteArrayUtil.putDoubleLE(byteArr, DATA_START_ADR_SINGLE_ITEM, sketch.getDoubleSingleItem());
+ ByteArrayUtil.putDoubleLE(byteArr, DATA_START_ADR_SINGLE_VALUE, sketch.getDoubleSingleItem());
} else {
- ByteArrayUtil.putFloatLE(byteArr, DATA_START_ADR_SINGLE_ITEM, sketch.getFloatSingleItem());
+ ByteArrayUtil.putFloatLE(byteArr, DATA_START_ADR_SINGLE_VALUE, sketch.getFloatSingleValue());
}
return byteArr;
}
@@ -680,7 +680,7 @@ final class KllHelper {
if (doubleType) {
myDoubleItemsArr = sketch.getDoubleItemsArray();
} else {
- myFloatItemsArr = sketch.getFloatItemsArray();
+ myFloatItemsArr = sketch.getFloatValuesArray();
}
if (withLevels) {
sb.append(outputLevels(k, m, numLevels, levelsArr));
@@ -704,7 +704,7 @@ final class KllHelper {
final long n = sketch.getN();
final byte flags = (byte) (UPDATABLE_BIT_MASK
| ((n == 0) ? EMPTY_BIT_MASK : 0)
- | ((n == 1) ? SINGLE_ITEM_BIT_MASK : 0)
+ | ((n == 1) ? SINGLE_VALUE_BIT_MASK : 0)
| (doubleType ? DOUBLES_SKETCH_BIT_MASK : 0));
final byte[] byteArr = new byte[curBytes];
sketch.wmem.getByteArray(0, byteArr, 0, curBytes);
@@ -754,7 +754,7 @@ final class KllHelper {
offset += Float.BYTES;
wmem.putFloat(offset,sketch.getMaxFloatValue());
offset += Float.BYTES;
- final float[] floatItemsArr = sketch.getFloatItemsArray();
+ final float[] floatItemsArr = sketch.getFloatValuesArray();
wmem.putFloatArray(offset, floatItemsArr, 0, floatItemsArr.length);
}
return byteArr;
@@ -802,7 +802,7 @@ final class KllHelper {
} else { //FLOATS_SKETCH
minFloat = sketch.getMinFloatValue();
maxFloat = sketch.getMaxFloatValue();
- myCurFloatItemsArr = sketch.getFloatItemsArray();
+ myCurFloatItemsArr = sketch.getFloatValuesArray();
assert myCurFloatItemsArr.length == myCurTotalItemsCapacity;
}
assert myCurLevelsArr[0] == 0; //definition of full is part of the growth scheme
@@ -928,7 +928,7 @@ final class KllHelper {
setMemoryFamilyID(wmem, Family.KLL.getID());
setMemoryEmptyFlag(wmem, empty);
setMemoryLevelZeroSortedFlag(wmem, lvlZeroSorted);
- setMemorySingleItemFlag(wmem, singleItem);
+ setMemorySingleValueFlag(wmem, singleItem);
setMemoryDoubleSketchFlag(wmem, doubleType);
setMemoryUpdatableFlag(wmem, updatableFormat);
setMemoryK(wmem, sk.getK());
diff --git a/src/main/java/org/apache/datasketches/kll/KllMemoryValidate.java b/src/main/java/org/apache/datasketches/kll/KllMemoryValidate.java
index 9eb25195..914ff357 100644
--- a/src/main/java/org/apache/datasketches/kll/KllMemoryValidate.java
+++ b/src/main/java/org/apache/datasketches/kll/KllMemoryValidate.java
@@ -30,7 +30,7 @@ import static org.apache.datasketches.kll.KllMemoryValidate.MemoryInputError.SRC
import static org.apache.datasketches.kll.KllMemoryValidate.MemoryInputError.UPDATABLEBIT_AND_SER_VER;
import static org.apache.datasketches.kll.KllMemoryValidate.MemoryInputError.memoryValidateThrow;
import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR;
-import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_EMPTY_SINGLE;
import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_FULL;
import static org.apache.datasketches.kll.KllPreambleUtil.SERIAL_VERSION_EMPTY_FULL;
@@ -48,7 +48,7 @@ import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryN;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryNumLevels;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryPreInts;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemorySerVer;
-import static org.apache.datasketches.kll.KllPreambleUtil.getMemorySingleItemFlag;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemorySingleValueFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryUpdatableFormatFlag;
import org.apache.datasketches.Family;
@@ -71,7 +71,7 @@ final class KllMemoryValidate {
final String famName;
final int flags;
boolean empty;
- boolean singleItem;
+ boolean singleValue;
final boolean level0Sorted;
final boolean doublesSketch;
boolean updatableMemFormat = false;
@@ -101,7 +101,7 @@ final class KllMemoryValidate {
flags = getMemoryFlags(srcMem);
updatableMemFormat = getMemoryUpdatableFormatFlag(srcMem);
empty = getMemoryEmptyFlag(srcMem);
- singleItem = getMemorySingleItemFlag(srcMem);
+ singleValue = getMemorySingleValueFlag(srcMem);
level0Sorted = getMemoryLevelZeroSortedFlag(srcMem);
doublesSketch = getMemoryDoubleSketchFlag(srcMem);
k = getMemoryK(srcMem);
@@ -116,8 +116,8 @@ final class KllMemoryValidate {
}
void compactMemoryValidate(final Memory srcMem) { //FOR HEAPIFY
- if (empty && singleItem) { memoryValidateThrow(EMPTYBIT_AND_SINGLEBIT, flags); }
- final int sw = (empty ? 1 : 0) | (singleItem ? 4 : 0);
+ if (empty && singleValue) { memoryValidateThrow(EMPTYBIT_AND_SINGLEBIT, flags); }
+ final int sw = (empty ? 1 : 0) | (singleValue ? 4 : 0);
switch (sw) {
case 0: { //FULL_COMPACT
if (preInts != PREAMBLE_INTS_FULL) { memoryValidateThrow(INVALID_PREINTS, preInts); }
@@ -129,7 +129,7 @@ final class KllMemoryValidate {
// Create Levels Arr
levelsArr = new int[numLevels + 1];
srcMem.getIntArray(DATA_START_ADR, levelsArr, 0, numLevels); //copies all except the last one
- final int capacityItems = KllHelper.computeTotalItemCapacity(k, m, numLevels);
+ final int capacityItems = KllHelper.computeTotalValueCapacity(k, m, numLevels);
levelsArr[numLevels] = capacityItems; //load the last one
final int retainedItems = (levelsArr[numLevels] - levelsArr[0]);
@@ -143,7 +143,7 @@ final class KllMemoryValidate {
minK = k; //assumed
numLevels = 1; //assumed
levelsArr = new int[] {k, k};
- sketchBytes = DATA_START_ADR_SINGLE_ITEM;
+ sketchBytes = DATA_START_ADR_SINGLE_VALUE;
break;
}
case 4: { //SINGLE_COMPACT
@@ -153,7 +153,7 @@ final class KllMemoryValidate {
minK = k; //assumed
numLevels = 1; //assumed
levelsArr = new int[] {k - 1, k};
- sketchBytes = DATA_START_ADR_SINGLE_ITEM + typeBytes;
+ sketchBytes = DATA_START_ADR_SINGLE_VALUE + typeBytes;
break;
}
default: //can not happen
@@ -164,7 +164,7 @@ final class KllMemoryValidate {
if (preInts != PREAMBLE_INTS_FULL) { memoryValidateThrow(INVALID_PREINTS, preInts); }
n = getMemoryN(wSrcMem);
empty = n == 0; //empty & singleItem are set for convenience
- singleItem = n == 1; // there is no error checking on these bits
+ singleValue = n == 1; // there is no error checking on these bits
minK = getMemoryMinK(wSrcMem);
numLevels = getMemoryNumLevels(wSrcMem);
diff --git a/src/main/java/org/apache/datasketches/kll/KllPreambleUtil.java b/src/main/java/org/apache/datasketches/kll/KllPreambleUtil.java
index 625c7c68..60ee1cb9 100644
--- a/src/main/java/org/apache/datasketches/kll/KllPreambleUtil.java
+++ b/src/main/java/org/apache/datasketches/kll/KllPreambleUtil.java
@@ -45,7 +45,7 @@ import org.apache.datasketches.memory.WritableMemory;
* A serialized, non-empty KllFloatsSketch requires at least 12 bytes of preamble.</p>
*
* <pre>{@code
- * Serialized float sketch layout, more than one item:
+ * Serialized float sketch layout, more than one value:
* Adr:
* || 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
* 0 || unused | M |--------K--------| Flags | FamID | SerVer | PreambleInts |
@@ -56,20 +56,20 @@ import org.apache.datasketches.memory.WritableMemory;
* || | | | | | | | |
* ? ||<-------Min/Max Arr Start---------]|[<----------Levels Arr End----------------|
* || | | | | | | | |
- * ? ||<-----Float Items Arr Start-------]|[<---------Min/Max Arr End----------------|
+ * ? ||<----Float Valuess Arr Start------]|[<---------Min/Max Arr End----------------|
* || | | | | | | | |
- * ? || | | | |[<-------Float Items Arr End--------------|
+ * ? || | | | |[<------Float Values Arr End--------------|
*
- * Serialized float sketch layout, Empty (8 bytes) and Single Item (12 bytes):
+ * Serialized float sketch layout, Empty (8 bytes) and Single Value (12 bytes):
* Adr:
* || 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
* 0 || unused | M |--------K--------| Flags | FamID | SerVer | PreambleInts |
* || 15 | 14 | 13 | 12 | 11 | 10 | 9 | 8 |
- * 1 || |-------------Single Item------------------|
+ * 1 || |-------------Single Value------------------|
*
*
*
- * Serialized double sketch layout, more than one item:
+ * Serialized double sketch layout, more than one value:
* Adr:
* || 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
* 0 || unused | M |--------K--------| Flags | FamID | SerVer | PreambleInts |
@@ -80,41 +80,41 @@ import org.apache.datasketches.memory.WritableMemory;
* || | | | | | | | |
* ? ||<-------Min/Max Arr Start---------]|[<----------Levels Arr End----------------|
* || | | | | | | | |
- * ? ||<----Double Items Arr Start-------]|[<---------Min/Max Arr End----------------|
+ * ? ||<----Double Values Arr Start------]|[<---------Min/Max Arr End----------------|
* || | | | | | | | |
- * ? || | | | |[<------Double Items Arr End--------------|
+ * ? || | | | |[<------Double Values Arr End-------------|
*
- * Serialized double sketch layout, Empty (8 bytes) and Single Item (16 bytes):
+ * Serialized double sketch layout, Empty (8 bytes) and Single Value (16 bytes):
* Adr:
* || 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
* 0 || unused | M |--------K--------| Flags | FamID | SerVer | PreambleInts |
* || | 8 |
- * 1 ||------------------------------Single Item-------------------------------------|
+ * 1 ||------------------------------Single Value-------------------------------------|
*
* The structure of the data block depends on Layout:
*
* For FLOAT_SINGLE_COMPACT or DOUBLE_SINGLE_COMPACT:
- * The single data item is at offset DATA_START_ADR_SINGLE_ITEM = 8
+ * The single data value is at offset DATA_START_ADR_SINGLE_VALUe = 8
*
* For FLOAT_FULL_COMPACT:
* The int[] levels array starts at offset DATA_START_ADR_FLOAT = 20 with a length of numLevels integers;
* Followed by Float Min_Value, then Float Max_Value
- * Followed by an array of Floats of length retainedItems()
+ * Followed by an array of Floats of length retainedValues()
*
* For DOUBLE_FULL_COMPACT
* The int[] levels array starts at offset DATA_START_ADR_DOUBLE = 20 with a length of numLevels integers;
* Followed by Double Min_Value, then Double Max_Value
- * Followed by an array of Doubles of length retainedItems()
+ * Followed by an array of Doubles of length retainedValues()
*
* For FLOAT_UPDATABLE
* The int[] levels array starts at offset DATA_START_ADR_FLOAT = 20 with a length of (numLevels + 1) integers;
* Followed by Float Min_Value, then Float Max_Value
- * Followed by an array of Floats of length KllHelper.computeTotalItemCapacity(...).
+ * Followed by an array of Floats of length KllHelper.computeTotalValueCapacity(...).
*
* For DOUBLE_UPDATABLE
* The int[] levels array starts at offset DATA_START_ADR_DOUBLE = 20 with a length of (numLevels + 1) integers;
* Followed by Double Min_Value, then Double Max_Value
- * Followed by an array of Doubles of length KllHelper.computeTotalItemCapacity(...).
+ * Followed by an array of Doubles of length KllHelper.computeTotalValueCapacity(...).
*
* }</pre>
*
@@ -134,29 +134,29 @@ final class KllPreambleUtil {
static final int K_SHORT_ADR = 4; // to 5
static final int M_BYTE_ADR = 6;
// 7 is reserved for future use
- // SINGLE ITEM ONLY
- static final int DATA_START_ADR_SINGLE_ITEM = 8;
+ // SINGLE VALUE ONLY
+ static final int DATA_START_ADR_SINGLE_VALUE = 8;
- // MULTI-ITEM
+ // MULTI-VALUE
static final int N_LONG_ADR = 8; // to 15
static final int MIN_K_SHORT_ADR = 16; // to 17
static final int NUM_LEVELS_BYTE_ADR = 18;
// 19 is reserved for future use
- static final int DATA_START_ADR = 20; // Full Sketch, not single item
+ static final int DATA_START_ADR = 20; // Full Sketch, not single value
// Other static values
- static final byte SERIAL_VERSION_EMPTY_FULL = 1; // Empty or full preamble, NOT single item format
- static final byte SERIAL_VERSION_SINGLE = 2; // only single-item format
+ static final byte SERIAL_VERSION_EMPTY_FULL = 1; // Empty or full preamble, NOT single value format
+ static final byte SERIAL_VERSION_SINGLE = 2; // only single-value format
static final byte SERIAL_VERSION_UPDATABLE = 3; //
- static final byte PREAMBLE_INTS_EMPTY_SINGLE = 2; // for empty or single item
- static final byte PREAMBLE_INTS_FULL = 5; // Full preamble, not empty nor single item
+ static final byte PREAMBLE_INTS_EMPTY_SINGLE = 2; // for empty or single value
+ static final byte PREAMBLE_INTS_FULL = 5; // Full preamble, not empty nor single value
static final byte KLL_FAMILY = 15;
// Flag bit masks
static final int EMPTY_BIT_MASK = 1;
static final int LEVEL_ZERO_SORTED_BIT_MASK = 2;
- static final int SINGLE_ITEM_BIT_MASK = 4;
+ static final int SINGLE_VALUE_BIT_MASK = 4;
static final int DOUBLES_SKETCH_BIT_MASK = 8;
static final int UPDATABLE_BIT_MASK = 16;
@@ -190,43 +190,43 @@ final class KllPreambleUtil {
final boolean doublesSketch = memVal.doublesSketch;
final boolean updatableMemFormat = memVal.updatableMemFormat;
final boolean empty = memVal.empty;
- final boolean singleItem = memVal.singleItem;
+ final boolean singleValue = memVal.singleValue;
final int sketchBytes = memVal.sketchBytes;
final int typeBytes = memVal.typeBytes;
final StringBuilder sb = new StringBuilder();
sb.append(Util.LS).append("### KLL SKETCH MEMORY SUMMARY:").append(LS);
- sb.append("Byte 0 : Preamble Ints : ").append(preInts).append(LS);
- sb.append("Byte 1 : SerVer : ").append(memVal.serVer).append(LS);
- sb.append("Byte 2 : FamilyID : ").append(memVal.familyID).append(LS);
- sb.append(" FamilyName : ").append(memVal.famName).append(LS);
- sb.append("Byte 3 : Flags Field : ").append(flagsStr).append(LS);
+ sb.append("Byte 0 : Preamble Ints : ").append(preInts).append(LS);
+ sb.append("Byte 1 : SerVer : ").append(memVal.serVer).append(LS);
+ sb.append("Byte 2 : FamilyID : ").append(memVal.familyID).append(LS);
+ sb.append(" FamilyName : ").append(memVal.famName).append(LS);
+ sb.append("Byte 3 : Flags Field : ").append(flagsStr).append(LS);
sb.append(" Bit Flag Name").append(LS);
- sb.append(" 0 EMPTY COMPACT : ").append(empty).append(LS);
- sb.append(" 1 LEVEL_ZERO_SORTED : ").append(memVal.level0Sorted).append(LS);
- sb.append(" 2 SINGLE_ITEM COMPACT: ").append(singleItem).append(LS);
- sb.append(" 3 DOUBLES_SKETCH : ").append(doublesSketch).append(LS);
- sb.append(" 4 UPDATABLE : ").append(updatableMemFormat).append(LS);
- sb.append("Bytes 4-5 : K : ").append(memVal.k).append(LS);
- sb.append("Byte 6 : Min Level Cap, M : ").append(memVal.m).append(LS);
- sb.append("Byte 7 : (Reserved) : ").append(LS);
+ sb.append(" 0 EMPTY COMPACT : ").append(empty).append(LS);
+ sb.append(" 1 LEVEL_ZERO_SORTED : ").append(memVal.level0Sorted).append(LS);
+ sb.append(" 2 SINGLE_VALUE COMPACT: ").append(singleValue).append(LS);
+ sb.append(" 3 DOUBLES_SKETCH : ").append(doublesSketch).append(LS);
+ sb.append(" 4 UPDATABLE : ").append(updatableMemFormat).append(LS);
+ sb.append("Bytes 4-5 : K : ").append(memVal.k).append(LS);
+ sb.append("Byte 6 : Min Level Cap, M : ").append(memVal.m).append(LS);
+ sb.append("Byte 7 : (Reserved) : ").append(LS);
final long n = memVal.n;
final int minK = memVal.minK;
final int numLevels = memVal.numLevels;
- if (updatableMemFormat || (!updatableMemFormat && !empty && !singleItem)) {
- sb.append("Bytes 8-15: N : ").append(n).append(LS);
- sb.append("Bytes 16-17: MinK : ").append(minK).append(LS);
- sb.append("Byte 18 : NumLevels : ").append(numLevels).append(LS);
+ if (updatableMemFormat || (!updatableMemFormat && !empty && !singleValue)) {
+ sb.append("Bytes 8-15: N : ").append(n).append(LS);
+ sb.append("Bytes 16-17: MinK : ").append(minK).append(LS);
+ sb.append("Byte 18 : NumLevels : ").append(numLevels).append(LS);
}
else {
- sb.append("Assumed : N : ").append(n).append(LS);
- sb.append("Assumed : MinK : ").append(minK).append(LS);
- sb.append("Assumed : NumLevels : ").append(numLevels).append(LS);
+ sb.append("Assumed : N : ").append(n).append(LS);
+ sb.append("Assumed : MinK : ").append(minK).append(LS);
+ sb.append("Assumed : NumLevels : ").append(numLevels).append(LS);
}
- sb.append("PreambleBytes : ").append(preInts * 4).append(LS);
- sb.append("Sketch Bytes : ").append(sketchBytes).append(LS);
- sb.append("Memory Capacity Bytes : ").append(mem.getCapacity()).append(LS);
+ sb.append("PreambleBytes : ").append(preInts * 4).append(LS);
+ sb.append("Sketch Bytes : ").append(sketchBytes).append(LS);
+ sb.append("Memory Capacity Bytes : ").append(mem.getCapacity()).append(LS);
sb.append("### END KLL Sketch Memory Summary").append(LS);
if (includeData) {
@@ -253,21 +253,21 @@ final class KllPreambleUtil {
sb.append(mem.getFloat(offsetBytes)).append(LS);
offsetBytes += typeBytes;
}
- sb.append("ITEMS DATA").append(LS);
- final int itemSpace = (sketchBytes - offsetBytes) / typeBytes;
+ sb.append("VALUES DATA").append(LS);
+ final int valueSpace = (sketchBytes - offsetBytes) / typeBytes;
if (doublesSketch) {
- for (int i = 0; i < itemSpace; i++) {
+ for (int i = 0; i < valueSpace; i++) {
sb.append(i + ", " + mem.getDouble(offsetBytes)).append(LS);
offsetBytes += typeBytes;
}
} else { //floats
- for (int i = 0; i < itemSpace; i++) {
+ for (int i = 0; i < valueSpace; i++) {
sb.append(mem.getFloat(offsetBytes)).append(LS);
offsetBytes += typeBytes;
}
}
- } else if (!empty && !singleItem) { //compact full
+ } else if (!empty && !singleValue) { //compact full
sb.append("LEVELS ARR:").append(LS);
offsetBytes = DATA_START_ADR;
for (int i = 0; i < numLevels; i++) {
@@ -287,26 +287,26 @@ final class KllPreambleUtil {
sb.append(mem.getFloat(offsetBytes)).append(LS);
offsetBytes += typeBytes;
}
- sb.append("ITEMS DATA").append(LS);
- final int itemSpace = (sketchBytes - offsetBytes) / typeBytes;
+ sb.append("VALUES DATA").append(LS);
+ final int valueSpace = (sketchBytes - offsetBytes) / typeBytes;
if (doublesSketch) {
- for (int i = 0; i < itemSpace; i++) {
+ for (int i = 0; i < valueSpace; i++) {
sb.append(i + ", " + mem.getDouble(offsetBytes)).append(LS);
offsetBytes += typeBytes;
}
} else { //floats
- for (int i = 0; i < itemSpace; i++) {
+ for (int i = 0; i < valueSpace; i++) {
sb.append(i + ", " + mem.getFloat(offsetBytes)).append(LS);
offsetBytes += typeBytes;
}
}
- } else { //single item
- if (singleItem) {
- sb.append("SINGLE ITEM DATA").append(LS);
+ } else { //single value
+ if (singleValue) {
+ sb.append("SINGLE VALUE DATA").append(LS);
sb.append(doublesSketch
- ? mem.getDouble(DATA_START_ADR_SINGLE_ITEM)
- : mem.getFloat(DATA_START_ADR_SINGLE_ITEM)).append(LS);
+ ? mem.getDouble(DATA_START_ADR_SINGLE_VALUE)
+ : mem.getFloat(DATA_START_ADR_SINGLE_VALUE)).append(LS);
}
}
sb.append("### END KLL DATA:").append(LS);
@@ -338,8 +338,8 @@ final class KllPreambleUtil {
return (getMemoryFlags(mem) & LEVEL_ZERO_SORTED_BIT_MASK) != 0;
}
- static boolean getMemorySingleItemFlag(final Memory mem) {
- return (getMemoryFlags(mem) & SINGLE_ITEM_BIT_MASK) != 0;
+ static boolean getMemorySingleValueFlag(final Memory mem) {
+ return (getMemoryFlags(mem) & SINGLE_VALUE_BIT_MASK) != 0;
}
static boolean getMemoryDoubleSketchFlag(final Memory mem) {
@@ -396,9 +396,9 @@ final class KllPreambleUtil {
setMemoryFlags(wmem, levelZeroSorted ? flags | LEVEL_ZERO_SORTED_BIT_MASK : flags & ~LEVEL_ZERO_SORTED_BIT_MASK);
}
- static void setMemorySingleItemFlag(final WritableMemory wmem, final boolean singleItem) {
+ static void setMemorySingleValueFlag(final WritableMemory wmem, final boolean singleValue) {
final int flags = getMemoryFlags(wmem);
- setMemoryFlags(wmem, singleItem ? flags | SINGLE_ITEM_BIT_MASK : flags & ~SINGLE_ITEM_BIT_MASK);
+ setMemoryFlags(wmem, singleValue ? flags | SINGLE_VALUE_BIT_MASK : flags & ~SINGLE_VALUE_BIT_MASK);
}
static void setMemoryDoubleSketchFlag(final WritableMemory wmem, final boolean doubleSketch) {
diff --git a/src/main/java/org/apache/datasketches/kll/KllSketch.java b/src/main/java/org/apache/datasketches/kll/KllSketch.java
index 896cb1b9..51368a5d 100644
--- a/src/main/java/org/apache/datasketches/kll/KllSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllSketch.java
@@ -20,7 +20,7 @@
package org.apache.datasketches.kll;
import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR;
-import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_ITEM;
+import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_VALUE;
import static org.apache.datasketches.kll.KllPreambleUtil.N_LONG_ADR;
import static org.apache.datasketches.kll.KllSketch.Error.SRC_MUST_BE_DOUBLE;
import static org.apache.datasketches.kll.KllSketch.Error.SRC_MUST_BE_FLOAT;
@@ -38,23 +38,23 @@ import org.apache.datasketches.memory.WritableMemory;
/*
* Sampled stream data (floats or doubles) is stored as an array or as part of a Memory object.
- * This array is partitioned into sections called levels and the indices into the array of items
+ * This array is partitioned into sections called levels and the indices into the array of values
* are tracked by a small integer array called levels or levels array.
* The data for level i lies in positions levelsArray[i] through levelsArray[i + 1] - 1 inclusive.
* Hence, the levelsArray must contain (numLevels + 1) indices.
- * The valid portion of items array is completely packed and sorted, except for level 0,
- * which is filled from the top down. Any items below the index levelsArray[0] is garbage and will be
+ * The valid portion of values array is completely packed and sorted, except for level 0,
+ * which is filled from the top down. Any values below the index levelsArray[0] is garbage and will be
* overwritten by subsequent updates.
*
* Invariants:
* 1) After a compaction, or an update, or a merge, every level is sorted except for level zero.
- * 2) After a compaction, (sum of capacities) - (sum of items) >= 1,
- * so there is room for least 1 more item in level zero.
+ * 2) After a compaction, (sum of capacities) - (sum of values) >= 1,
+ * so there is room for least 1 more value in level zero.
* 3) There are no gaps except at the bottom, so if levels_[0] = 0,
- * the sketch is exactly filled to capacity and must be compacted or the itemsArray and levelsArray
+ * the sketch is exactly filled to capacity and must be compacted or the valuesArray and levelsArray
* must be expanded to include more levels.
- * 4) Sum of weights of all retained items == N.
- * 5) Current total item capacity = itemsArray.length = levelsArray[numLevels].
+ * 4) Sum of weights of all retained values == N.
+ * 5) Current total value capacity = valuesArray.length = levelsArray[numLevels].
*/
/**
@@ -62,10 +62,17 @@ import org.apache.datasketches.memory.WritableMemory;
* of either sketch type (float or double) and independent of whether the sketch is targeted for use on the
* heap or Direct (off-heap).
*
- * <p>Please refer to the documentation in the package-info:<br>
- * {@link org.apache.datasketches.kll}</p>
*
- * @author Lee Rhodes, Kevin Lang
+ * @see <a href="https://datasketches.apache.org/docs/KLL/KLLSketch.html">KLL Sketch</a>
+ * @see <a href="https://datasketches.apache.org/api/java/snapshot/apidocs/org/apache/datasketches/kll/package-summary.html">
+ * KLL package summary</a>
+ * @see <a href="https://datasketches.apache.org/docs/Quantiles/SketchingQuantilesAndRanksTutorial.html">
+ * Sketching Quantiles and Ranks, Tutorial</a>
+ * @see org.apache.datasketches.QuantileSearchCriteria
+ *
+ * @author Lee Rhodes
+ * @author Kevin Lang
+ * @author Alexander Saydakov
*/
public abstract class KllSketch {
@@ -79,9 +86,9 @@ public abstract class KllSketch {
SRC_MUST_BE_DOUBLE("Given sketch must be of type Double."),
SRC_MUST_BE_FLOAT("Given sketch must be of type Float."),
MUST_NOT_CALL("This is an artifact of inheritance and should never be called."),
- SINGLE_ITEM_IMPROPER_CALL("Improper method use for single-item sketch"),
+ SINGLE_VALUE_IMPROPER_CALL("Improper method use for single-value sketch"),
MRS_MUST_NOT_BE_NULL("MemoryRequestServer cannot be null."),
- NOT_SINGLE_ITEM("Sketch is not single item."),
+ NOT_SINGLE_VALUE("Sketch is not single value."),
MUST_NOT_BE_UPDATABLE_FORMAT("Given Memory object must not be in updatableFormat.");
private String msg;
@@ -110,7 +117,7 @@ public abstract class KllSketch {
public static final int MAX_K = (1 << 16) - 1; // serialized as an unsigned short
/**
- * The default value of M. The parameter <i>m</i> is the minimum level size in number of items.
+ * The default value of M. The parameter <i>m</i> is the minimum level size in number of values.
* Currently, the public default is 8, but this can be overridden using Package Private methods to
* 2, 4, 6 or 8, and the sketch works just fine. The value 8 was chosen as a compromise between speed and size.
* Choosing smaller values of <i>m</i> less than 8 will make the sketch slower.
@@ -217,19 +224,19 @@ public abstract class KllSketch {
return KllHelper.getNormalizedRankError(k, pmf);
}
- //numItems can be either numRetained, or current max capacity at given K and numLevels.
- static int getCurrentSerializedSizeBytes(final int numLevels, final int numItems,
+ //numValues can be either numRetained, or current max capacity at given K and numLevels.
+ static int getCurrentSerializedSizeBytes(final int numLevels, final int numValues,
final SketchType sketchType, final boolean updatableMemFormat) {
final int typeBytes = (sketchType == DOUBLES_SKETCH) ? Double.BYTES : Float.BYTES;
int levelsBytes = 0;
if (updatableMemFormat) {
levelsBytes = (numLevels + 1) * Integer.BYTES;
} else {
- if (numItems == 0) { return N_LONG_ADR; }
- if (numItems == 1) { return DATA_START_ADR_SINGLE_ITEM + typeBytes; }
+ if (numValues == 0) { return N_LONG_ADR; }
+ if (numValues == 1) { return DATA_START_ADR_SINGLE_VALUE + typeBytes; }
levelsBytes = numLevels * Integer.BYTES;
}
- return DATA_START_ADR + levelsBytes + (numItems + 2) * typeBytes; //+2 is for min & max
+ return DATA_START_ADR + levelsBytes + (numValues + 2) * typeBytes; //+2 is for min & max
}
/**
@@ -245,8 +252,8 @@ public abstract class KllSketch {
* @return the current number of bytes this sketch would require to store in the updatable Memory Format.
*/
public final int getCurrentUpdatableSerializedSizeBytes() {
- final int itemCap = KllHelper.computeTotalItemCapacity(getK(), getM(), getNumLevels());
- return getCurrentSerializedSizeBytes(getNumLevels(), itemCap, sketchType, true);
+ final int valuesCap = KllHelper.computeTotalValueCapacity(getK(), getM(), getNumLevels());
+ return getCurrentSerializedSizeBytes(getNumLevels(), valuesCap, sketchType, true);
}
/**
@@ -256,7 +263,7 @@ public abstract class KllSketch {
public abstract int getK();
/**
- * Returns the length of the input stream in items.
+ * Returns the length of the input stream in values.
* @return stream length
*/
public abstract long getN();
@@ -278,8 +285,8 @@ public abstract class KllSketch {
}
/**
- * Returns the number of retained items (samples) in the sketch.
- * @return the number of retained items (samples) in the sketch
+ * Returns the number of retained values (samples) in the sketch.
+ * @return the number of retained values (samples) in the sketch
*/
public final int getNumRetained() {
return levelsArr[getNumLevels()] - levelsArr[0];
@@ -378,10 +385,10 @@ public abstract class KllSketch {
if (readOnly) { kllSketchThrow(TGT_IS_READ_ONLY); }
if (sketchType == DOUBLES_SKETCH) {
if (!other.isDoublesSketch()) { kllSketchThrow(SRC_MUST_BE_DOUBLE); }
- KllDoublesHelper.mergeDoubleImpl(this, other);
+ KllDoublesHelper.mergeDoubleImpl((KllDoublesSketch)this, other);
} else {
if (!other.isFloatsSketch()) { kllSketchThrow(SRC_MUST_BE_FLOAT); }
- KllFloatsHelper.mergeFloatImpl(this, other);
+ KllFloatsHelper.mergeFloatImpl((KllFloatsSketch)this, other);
}
}
@@ -442,9 +449,9 @@ public abstract class KllSketch {
/**
* @return full size of internal items array including garbage.
*/
- abstract float[] getFloatItemsArray();
+ abstract float[] getFloatValuesArray();
- abstract float getFloatSingleItem();
+ abstract float getFloatSingleValue();
final int[] getLevelsArray() {
return levelsArr;
diff --git a/src/test/java/org/apache/datasketches/kll/KllDirectCompactFloatsSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllDirectCompactFloatsSketchTest.java
index fcf602c7..c6a29530 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDirectCompactFloatsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectCompactFloatsSketchTest.java
@@ -66,12 +66,12 @@ public class KllDirectCompactFloatsSketchTest {
KllFloatsSketch sk = KllFloatsSketch.newHeapInstance(k);
sk.update(1);
KllFloatsSketch sk2 = KllFloatsSketch.wrap(Memory.wrap(sk.toByteArray()));
- assertEquals(sk2.getFloatSingleItem(), 1.0F);
+ assertEquals(sk2.getFloatSingleValue(), 1.0F);
sk.update(2);
sk2 = KllFloatsSketch.wrap(Memory.wrap(sk.toByteArray()));
assertEquals(sk2.getN(), 2);
try {
- sk2.getFloatSingleItem();
+ sk2.getFloatSingleValue();
fail();
} catch (SketchesArgumentException e) { }
}
@@ -82,18 +82,18 @@ public class KllDirectCompactFloatsSketchTest {
KllFloatsSketch sk = KllFloatsSketch.newHeapInstance(k);
KllFloatsSketch sk2 = KllFloatsSketch.wrap(Memory.wrap(sk.toByteArray()));
- float[] itemsArr = sk2.getFloatItemsArray();
+ float[] itemsArr = sk2.getFloatValuesArray();
for (int i = 0; i < 20; i++) { assertEquals(itemsArr[i], 0F); }
sk.update(1);
sk2 = KllFloatsSketch.wrap(Memory.wrap(sk.toByteArray()));
- itemsArr = sk2.getFloatItemsArray();
+ itemsArr = sk2.getFloatValuesArray();
for (int i = 0; i < 19; i++) { assertEquals(itemsArr[i], 0F); }
assertEquals(itemsArr[19], 1F);
for (int i = 2; i <= 21; i++) { sk.update(i); }
sk2 = KllFloatsSketch.wrap(Memory.wrap(sk.toByteArray()));
- itemsArr = sk2.getFloatItemsArray();
+ itemsArr = sk2.getFloatValuesArray();
assertEquals(itemsArr.length, 33);
assertEquals(itemsArr[22], 21);
//for (int i = 0; i < itemsArr.length; i++) {
diff --git a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
index edc70109..092c77a0 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
@@ -642,7 +642,7 @@ public class KllDirectDoublesSketchTest {
try { sk2.setMinK(idx); fail(); } catch (SketchesArgumentException e) { }
try { sk2.setN(idx); fail(); } catch (SketchesArgumentException e) { }
try { sk2.setNumLevels(idx); fail(); } catch (SketchesArgumentException e) { }
- try { sk2.getFloatSingleItem(); fail(); } catch (SketchesArgumentException e) { }
+ try { sk2.getFloatSingleValue(); fail(); } catch (SketchesArgumentException e) { }
}
@Test(expectedExceptions = SketchesArgumentException.class)
diff --git a/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java
index 40d88dde..8f45e80f 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java
@@ -106,11 +106,8 @@ public class KllDirectFloatsSketchTest {
assertEquals(pmf.length, 2);
assertEquals(pmf[0], 0.5, PMF_EPS_FOR_K_256);
assertEquals(pmf[1], 0.5, PMF_EPS_FOR_K_256);
-
assertEquals(sketch.getMinValue(), 0f); // min value is exact
- assertEquals(sketch.getQuantile(0), 0f); // min value is exact
assertEquals(sketch.getMaxValue(), n - 1f); // max value is exact
- assertEquals(sketch.getQuantile(1), n - 1f); // max value is exact
// check at every 0.1 percentage point
final double[] fractions = new double[1001];
@@ -488,7 +485,7 @@ public class KllDirectFloatsSketchTest {
assertFalse(sk.isEmpty());
assertTrue(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 33);
+ assertEquals(sk.getFloatValuesArray().length, 33);
assertEquals(sk.getLevelsArray().length, 3);
assertEquals(sk.getMaxFloatValue(), 21.0);
assertEquals(sk.getMinFloatValue(), 1.0);
@@ -508,7 +505,7 @@ public class KllDirectFloatsSketchTest {
assertTrue(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), Double.NaN);
assertEquals(sk.getMinFloatValue(), Double.NaN);
@@ -529,7 +526,7 @@ public class KllDirectFloatsSketchTest {
assertFalse(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), 1.0);
assertEquals(sk.getMinFloatValue(), 1.0);
diff --git a/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java
index 55d03b04..13850dc7 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java
@@ -496,7 +496,7 @@ public class KllDoublesSketchTest {
float fltV = 1.0f;
int idx = 1;
KllDoublesSketch sk = KllDoublesSketch.newHeapInstance(20);
- try { sk.getFloatItemsArray(); fail(); } catch (SketchesArgumentException e) { }
+ try { sk.getFloatValuesArray(); fail(); } catch (SketchesArgumentException e) { }
try { sk.getMaxFloatValue(); fail(); } catch (SketchesArgumentException e) { }
try { sk.getMinFloatValue(); fail(); } catch (SketchesArgumentException e) { }
try { sk.setFloatItemsArray(fltArr); fail(); } catch (SketchesArgumentException e) { }
diff --git a/src/test/java/org/apache/datasketches/kll/KllFloatsSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllFloatsSketchTest.java
index fb600ce9..90bcb849 100644
--- a/src/test/java/org/apache/datasketches/kll/KllFloatsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllFloatsSketchTest.java
@@ -19,6 +19,7 @@
package org.apache.datasketches.kll;
+import static org.apache.datasketches.QuantileSearchCriteria.*;
import static org.apache.datasketches.Util.getResourceBytes;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
@@ -80,10 +81,10 @@ public class KllFloatsSketchTest {
assertEquals(sketch.getNumRetained(), 1);
assertEquals(sketch.getRank(1), 0.0);
assertEquals(sketch.getRank(2), 1.0);
- assertEquals(sketch.getRank(1, false), 0.0);
- assertEquals(sketch.getRank(2, false), 1.0);
- assertEquals(sketch.getRank(0, true), 0.0);
- assertEquals(sketch.getRank(1, true), 1.0);
+ assertEquals(sketch.getRank(1, NON_INCLUSIVE), 0.0);
+ assertEquals(sketch.getRank(2, NON_INCLUSIVE), 1.0);
+ assertEquals(sketch.getRank(0, INCLUSIVE), 0.0);
+ assertEquals(sketch.getRank(1, INCLUSIVE), 1.0);
assertEquals(sketch.getMinValue(), 1f);
assertEquals(sketch.getMaxValue(), 1f);
assertEquals(sketch.getQuantile(0.5), 1f);
@@ -93,14 +94,13 @@ public class KllFloatsSketchTest {
public void tenItems() {
final KllFloatsSketch sketch = KllFloatsSketch.newHeapInstance();
for (int i = 1; i <= 10; i++) { sketch.update(i); }
- System.out.println(sketch.toString(true, true)); //TODO
assertFalse(sketch.isEmpty());
assertEquals(sketch.getN(), 10);
assertEquals(sketch.getNumRetained(), 10);
for (int i = 1; i <= 10; i++) {
assertEquals(sketch.getRank(i), (i - 1) / 10.0);
- assertEquals(sketch.getRank(i, false), (i - 1) / 10.0);
- assertEquals(sketch.getRank(i, true), (i) / 10.0);
+ assertEquals(sketch.getRank(i, NON_INCLUSIVE), (i - 1) / 10.0);
+ assertEquals(sketch.getRank(i, INCLUSIVE), (i) / 10.0);
}
// inclusive = false (default)
assertEquals(sketch.getQuantile(0), 1); // always min value
@@ -115,17 +115,17 @@ public class KllFloatsSketchTest {
assertEquals(sketch.getQuantile(0.9), 10);
assertEquals(sketch.getQuantile(1), 10); // always max value
// inclusive = true
- assertEquals(sketch.getQuantile(0, true), 1); // always min value
- assertEquals(sketch.getQuantile(0.1, true), 1);
- assertEquals(sketch.getQuantile(0.2, true), 2);
- assertEquals(sketch.getQuantile(0.3, true), 3);
- assertEquals(sketch.getQuantile(0.4, true), 4);
- assertEquals(sketch.getQuantile(0.5, true), 5);
- assertEquals(sketch.getQuantile(0.6, true), 6);
- assertEquals(sketch.getQuantile(0.7, true), 7);
- assertEquals(sketch.getQuantile(0.8, true), 8);
- assertEquals(sketch.getQuantile(0.9, true), 9);
- assertEquals(sketch.getQuantile(1, true), 10); // always max value TODO
+ assertEquals(sketch.getQuantile(0, INCLUSIVE), 1); // always min value
+ assertEquals(sketch.getQuantile(0.1, INCLUSIVE), 1);
+ assertEquals(sketch.getQuantile(0.2, INCLUSIVE), 2);
+ assertEquals(sketch.getQuantile(0.3, INCLUSIVE), 3);
+ assertEquals(sketch.getQuantile(0.4, INCLUSIVE), 4);
+ assertEquals(sketch.getQuantile(0.5, INCLUSIVE), 5);
+ assertEquals(sketch.getQuantile(0.6, INCLUSIVE), 6);
+ assertEquals(sketch.getQuantile(0.7, INCLUSIVE), 7);
+ assertEquals(sketch.getQuantile(0.8, INCLUSIVE), 8);
+ assertEquals(sketch.getQuantile(0.9, INCLUSIVE), 9);
+ assertEquals(sketch.getQuantile(1, INCLUSIVE), 10); // always max value TODO
// getQuantile() and getQuantiles() equivalence
{
@@ -139,9 +139,9 @@ public class KllFloatsSketchTest {
{
// inclusive = true
final float[] quantiles =
- sketch.getQuantiles(new double[] {0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1}, true);
+ sketch.getQuantiles(new double[] {0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1}, INCLUSIVE);
for (int i = 0; i <= 10; i++) {
- assertEquals(sketch.getQuantile(i / 10.0, true), quantiles[i]);
+ assertEquals(sketch.getQuantile(i / 10.0, INCLUSIVE), quantiles[i]);
}
}
}
@@ -168,10 +168,8 @@ public class KllFloatsSketchTest {
assertEquals(pmf[0], 0.5, PMF_EPS_FOR_K_256);
assertEquals(pmf[1], 0.5, PMF_EPS_FOR_K_256);
- assertEquals(sketch.getMinValue(), 0f); // min value is exact
- assertEquals(sketch.getQuantile(0), 0f); // min value is exact
- assertEquals(sketch.getMaxValue(), n - 1f); // max value is exact
- assertEquals(sketch.getQuantile(1), n - 1f); // max value is exact
+ assertEquals(sketch.getMinValue(), 0f);
+ assertEquals(sketch.getMaxValue(), n - 1f);
// check at every 0.1 percentage point
final double[] fractions = new double[1001];
@@ -216,11 +214,11 @@ public class KllFloatsSketchTest {
assertEquals(ranks[n], 1.0, NUMERIC_NOISE_TOLERANCE);
}
{ // inclusive = false (default)
- final double[] ranks = sketch.getCDF(values, true);
- final double[] pmf = sketch.getPMF(values, true);
+ final double[] ranks = sketch.getCDF(values, INCLUSIVE);
+ final double[] pmf = sketch.getPMF(values, INCLUSIVE);
double sumPmf = 0;
for (int i = 0; i < n; i++) {
- assertEquals(ranks[i], sketch.getRank(values[i], true), NUMERIC_NOISE_TOLERANCE,
+ assertEquals(ranks[i], sketch.getRank(values[i], INCLUSIVE), NUMERIC_NOISE_TOLERANCE,
"rank vs CDF for value " + i);
sumPmf += pmf[i];
assertEquals(ranks[i], sumPmf, NUMERIC_NOISE_TOLERANCE, "CDF vs PMF for value " + i);
@@ -371,7 +369,8 @@ public class KllFloatsSketchTest {
sketch.update(i);
}
assertEquals(sketch.getK(), KllSketch.DEFAULT_M);
- assertEquals(sketch.getQuantile(0.5), 500, 500 * PMF_EPS_FOR_K_8);
+ float q = sketch.getQuantile(.5);
+ assertEquals(q, 500, 500 * PMF_EPS_FOR_K_8);
}
@Test
diff --git a/src/test/java/org/apache/datasketches/kll/KllFloatsValidationTest.java b/src/test/java/org/apache/datasketches/kll/KllFloatsValidationTest.java
index cdb0f0ac..abcd0bfd 100644
--- a/src/test/java/org/apache/datasketches/kll/KllFloatsValidationTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllFloatsValidationTest.java
@@ -219,7 +219,7 @@ public class KllFloatsValidationTest {
int numLevels = sketch.getNumLevels();
int numSamples = sketch.getNumRetained();
int[] levels = sketch.getLevelsArray();
- long hashedSamples = simpleHashOfSubArray(sketch.getFloatItemsArray(), levels[0], numSamples);
+ long hashedSamples = simpleHashOfSubArray(sketch.getFloatValuesArray(), levels[0], numSamples);
System.out.print(testI);
assert correctResultsWithReset[(7 * testI) + 4] == numLevels;
assert correctResultsWithReset[(7 * testI) + 5] == numSamples;
diff --git a/src/test/java/org/apache/datasketches/kll/KllHelperTest.java b/src/test/java/org/apache/datasketches/kll/KllHelperTest.java
index ade348b0..0dd7f103 100644
--- a/src/test/java/org/apache/datasketches/kll/KllHelperTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllHelperTest.java
@@ -79,7 +79,7 @@ public class KllHelperTest {
@Test
public void checkSuperLargeKandLevels() {
//This is beyond what the sketch can be configured for.
- final int size = KllHelper.computeTotalItemCapacity(1 << 29, 8, 61);
+ final int size = KllHelper.computeTotalValueCapacity(1 << 29, 8, 61);
assertEquals(size, 1_610_612_846);
}
diff --git a/src/test/java/org/apache/datasketches/kll/KllMemoryValidateTest.java b/src/test/java/org/apache/datasketches/kll/KllMemoryValidateTest.java
index baa231e0..37819de4 100644
--- a/src/test/java/org/apache/datasketches/kll/KllMemoryValidateTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllMemoryValidateTest.java
@@ -52,7 +52,7 @@ public class KllMemoryValidateTest {
KllFloatsSketch sk = KllFloatsSketch.newHeapInstance();
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
- setMemoryFlags(wmem, EMPTY_BIT_MASK | SINGLE_ITEM_BIT_MASK);
+ setMemoryFlags(wmem, EMPTY_BIT_MASK | SINGLE_VALUE_BIT_MASK);
KllMemoryValidate memVal = new KllMemoryValidate(wmem);
}
diff --git a/src/test/java/org/apache/datasketches/kll/KllMiscDirectFloatsTest.java b/src/test/java/org/apache/datasketches/kll/KllMiscDirectFloatsTest.java
index dacf8497..6407eceb 100644
--- a/src/test/java/org/apache/datasketches/kll/KllMiscDirectFloatsTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllMiscDirectFloatsTest.java
@@ -58,7 +58,7 @@ public class KllMiscDirectFloatsTest {
for (int i = 0; i < 20; i++) { sk.update(i); }
//sk.toString(true, true);
//sk.toByteArray();
- final float[] items = sk.getFloatItemsArray();
+ final float[] items = sk.getFloatValuesArray();
assertEquals(items.length, 16);
final int[] levels = sk.getLevelsArray();
assertEquals(levels.length, 3);
@@ -119,7 +119,7 @@ public class KllMiscDirectFloatsTest {
assertFalse(sk.isEmpty());
assertTrue(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 33);
+ assertEquals(sk.getFloatValuesArray().length, 33);
assertEquals(sk.getLevelsArray().length, 3);
assertEquals(sk.getMaxFloatValue(), 21.0F);
assertEquals(sk.getMinFloatValue(), 1.0F);
@@ -135,7 +135,7 @@ public class KllMiscDirectFloatsTest {
assertTrue(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), Float.NaN);
assertEquals(sk.getMinFloatValue(), Float.NaN);
@@ -152,7 +152,7 @@ public class KllMiscDirectFloatsTest {
assertFalse(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), 1.0F);
assertEquals(sk.getMinFloatValue(), 1.0F);
@@ -182,7 +182,7 @@ public class KllMiscDirectFloatsTest {
assertFalse(sk.isEmpty());
assertTrue(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 33);
+ assertEquals(sk.getFloatValuesArray().length, 33);
assertEquals(sk.getLevelsArray().length, 3);
assertEquals(sk.getMaxFloatValue(), 21.0F);
assertEquals(sk.getMinFloatValue(), 1.0f);
@@ -202,7 +202,7 @@ public class KllMiscDirectFloatsTest {
assertTrue(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), Float.NaN);
assertEquals(sk.getMinFloatValue(), Float.NaN);
@@ -223,7 +223,7 @@ public class KllMiscDirectFloatsTest {
assertFalse(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), 1.0F);
assertEquals(sk.getMinFloatValue(), 1.0F);
@@ -253,7 +253,7 @@ public class KllMiscDirectFloatsTest {
assertFalse(sk.isEmpty());
assertTrue(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 33);
+ assertEquals(sk.getFloatValuesArray().length, 33);
assertEquals(sk.getLevelsArray().length, 3);
assertEquals(sk.getMaxFloatValue(), 21.0F);
assertEquals(sk.getMinFloatValue(), 1.0F);
@@ -273,7 +273,7 @@ public class KllMiscDirectFloatsTest {
assertTrue(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), Float.NaN);
assertEquals(sk.getMinFloatValue(), Float.NaN);
@@ -294,7 +294,7 @@ public class KllMiscDirectFloatsTest {
assertFalse(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), 1.0F);
assertEquals(sk.getMinFloatValue(), 1.0F);
diff --git a/src/test/java/org/apache/datasketches/kll/KllMiscFloatsTest.java b/src/test/java/org/apache/datasketches/kll/KllMiscFloatsTest.java
index cbccca81..8f72d765 100644
--- a/src/test/java/org/apache/datasketches/kll/KllMiscFloatsTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllMiscFloatsTest.java
@@ -118,7 +118,7 @@ public class KllMiscFloatsTest {
for (int i = 0; i < 20; i++) { sk.update(i); }
sk.toString(true, true);
sk.toByteArray();
- final float[] items = sk.getFloatItemsArray();
+ final float[] items = sk.getFloatValuesArray();
assertEquals(items.length, 16);
final int[] levels = sk.getLevelsArray();
assertEquals(levels.length, 3);
@@ -184,7 +184,7 @@ public class KllMiscFloatsTest {
KllFloatsSketch sk = KllFloatsSketch.newHeapInstance(20);
for (int i = 1; i <= 21; i++) { sk.update(i); }
assertEquals(sk.getNumLevels(), 2);
- assertEquals(sk.getFloatItemsArray().length, 33);
+ assertEquals(sk.getFloatValuesArray().length, 33);
assertEquals(sk.getLevelsArray()[2], 33);
}
@@ -203,7 +203,7 @@ public class KllMiscFloatsTest {
assertFalse(sk.isEmpty());
assertTrue(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 33);
+ assertEquals(sk.getFloatValuesArray().length, 33);
assertEquals(sk.getLevelsArray().length, 3);
assertEquals(sk.getMaxFloatValue(), 21.0F);
assertEquals(sk.getMinFloatValue(), 1.0F);
@@ -219,7 +219,7 @@ public class KllMiscFloatsTest {
assertTrue(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), Float.NaN);
assertEquals(sk.getMinFloatValue(), Float.NaN);
@@ -236,7 +236,7 @@ public class KllMiscFloatsTest {
assertFalse(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), 1.0F);
assertEquals(sk.getMinFloatValue(), 1.0F);
@@ -266,7 +266,7 @@ public class KllMiscFloatsTest {
assertFalse(sk.isEmpty());
assertTrue(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 33);
+ assertEquals(sk.getFloatValuesArray().length, 33);
assertEquals(sk.getLevelsArray().length, 3);
assertEquals(sk.getMaxFloatValue(), 21.0F);
assertEquals(sk.getMinFloatValue(), 1.0F);
@@ -286,7 +286,7 @@ public class KllMiscFloatsTest {
assertTrue(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), Float.NaN);
assertEquals(sk.getMinFloatValue(), Float.NaN);
@@ -307,7 +307,7 @@ public class KllMiscFloatsTest {
assertFalse(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), 1.0F);
assertEquals(sk.getMinFloatValue(), 1.0F);
@@ -337,7 +337,7 @@ public class KllMiscFloatsTest {
assertFalse(sk.isEmpty());
assertTrue(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 33);
+ assertEquals(sk.getFloatValuesArray().length, 33);
assertEquals(sk.getLevelsArray().length, 3);
assertEquals(sk.getMaxFloatValue(), 21.0F);
assertEquals(sk.getMinFloatValue(), 1.0F);
@@ -357,7 +357,7 @@ public class KllMiscFloatsTest {
assertTrue(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), Float.NaN);
assertEquals(sk.getMinFloatValue(), Float.NaN);
@@ -378,7 +378,7 @@ public class KllMiscFloatsTest {
assertFalse(sk.isEmpty());
assertFalse(sk.isEstimationMode());
assertEquals(sk.getMinK(), k);
- assertEquals(sk.getFloatItemsArray().length, 20);
+ assertEquals(sk.getFloatValuesArray().length, 20);
assertEquals(sk.getLevelsArray().length, 2);
assertEquals(sk.getMaxFloatValue(), 1.0F);
assertEquals(sk.getMinFloatValue(), 1.0F);
@@ -532,17 +532,17 @@ public class KllMiscFloatsTest {
KllFloatsSketch skHeap = KllFloatsSketch.newHeapInstance(k);
skHeap.update(1);
assertTrue(skHeap instanceof KllHeapFloatsSketch);
- assertEquals(skHeap.getFloatSingleItem(), 1.0F);
+ assertEquals(skHeap.getFloatSingleValue(), 1.0F);
WritableMemory srcMem = WritableMemory.writableWrap(KllHelper.toUpdatableByteArrayImpl(skHeap));
KllFloatsSketch skDirect = KllFloatsSketch.writableWrap(srcMem, memReqSvr);
assertTrue(skDirect instanceof KllDirectFloatsSketch);
- assertEquals(skDirect.getFloatSingleItem(), 1.0F);
+ assertEquals(skDirect.getFloatSingleValue(), 1.0F);
Memory srcMem2 = Memory.wrap(skHeap.toByteArray());
KllFloatsSketch skCompact = KllFloatsSketch.wrap(srcMem2);
assertTrue(skCompact instanceof KllDirectCompactFloatsSketch);
- assertEquals(skCompact.getFloatSingleItem(), 1.0F);
+ assertEquals(skCompact.getFloatSingleValue(), 1.0F);
}
@Test
@@ -552,7 +552,7 @@ public class KllMiscFloatsTest {
printf("%s\n", s);
}
- private final static boolean enablePrinting = true;
+ private final static boolean enablePrinting = false;
/**
* @param format the format
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org