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:52 UTC
[datasketches-java] branch Changes_to_kll created (now 851ec937)
This is an automated email from the ASF dual-hosted git repository.
leerho pushed a change to branch Changes_to_kll
in repository https://gitbox.apache.org/repos/asf/datasketches-java.git
at 851ec937 Interim 1 for KLL
This branch includes the following new commits:
new 851ec937 Interim 1 for KLL
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org
[datasketches-java] 01/01: Interim 1 for KLL
Posted by le...@apache.org.
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