Merge pull request #448 from apache/revert_items_changes_prepare4.1.0
Revert items changes prepare4.1.0
diff --git a/src/main/java/org/apache/datasketches/hll/DirectCouponList.java b/src/main/java/org/apache/datasketches/hll/DirectCouponList.java
index b6cc64f..008aac1 100644
--- a/src/main/java/org/apache/datasketches/hll/DirectCouponList.java
+++ b/src/main/java/org/apache/datasketches/hll/DirectCouponList.java
@@ -122,7 +122,7 @@
insertInt(wmem, LIST_INT_ARR_START + (i << 2), coupon);
int couponCount = extractListCount(mem);
insertListCount(wmem, ++couponCount);
- insertEmptyFlag(wmem, false); //TODO only first time
+ insertEmptyFlag(wmem, false); //only first time
if (couponCount >= len) { //array full
if (lgConfigK < 8) {
return promoteListOrSetToHll(this);//oooFlag = false
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
index d9d8925..8ee358b 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
@@ -20,7 +20,6 @@
package org.apache.datasketches.kll;
import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR;
-import static org.apache.datasketches.kll.KllPreambleUtil.DOUBLES_SKETCH_BIT_MASK;
import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_FULL;
import static org.apache.datasketches.kll.KllPreambleUtil.SERIAL_VERSION_UPDATABLE;
import static org.apache.datasketches.kll.KllPreambleUtil.UPDATABLE_BIT_MASK;
@@ -40,10 +39,10 @@
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.TGT_IS_READ_ONLY;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
+import static org.apache.datasketches.kll.KllSketch.SketchType.DOUBLES_SKETCH;
import org.apache.datasketches.common.Family;
import org.apache.datasketches.memory.MemoryRequestServer;
@@ -84,7 +83,7 @@
setMemoryPreInts(dstMem, PREAMBLE_INTS_FULL);
setMemorySerVer(dstMem, SERIAL_VERSION_UPDATABLE);
setMemoryFamilyID(dstMem, Family.KLL.getID());
- setMemoryFlags(dstMem, DOUBLES_SKETCH_BIT_MASK | UPDATABLE_BIT_MASK);
+ setMemoryFlags(dstMem, UPDATABLE_BIT_MASK);
setMemoryK(dstMem, k);
setMemoryM(dstMem, m);
setMemoryN(dstMem, 0);
@@ -96,7 +95,7 @@
dstMem.putDoubleArray(offset, new double[] {Double.NaN, Double.NaN}, 0, 2);
offset += 2 * Double.BYTES;
dstMem.putDoubleArray(offset, new double[k], 0, k);
- final KllMemoryValidate memVal = new KllMemoryValidate(dstMem);
+ final KllMemoryValidate memVal = new KllMemoryValidate(dstMem, DOUBLES_SKETCH);
return new KllDirectDoublesSketch(dstMem, memReqSvr, memVal);
}
@@ -129,9 +128,6 @@
}
@Override
- float getFloatSingleItem() { kllSketchThrow(MUST_NOT_CALL); return Float.NaN; }
-
- @Override
int getM() {
return getMemoryM(wmem);
}
@@ -183,7 +179,7 @@
void setDoubleItemsArrayAt(final int index, final double item) {
if (readOnly) { kllSketchThrow(TGT_IS_READ_ONLY); }
final int offset =
- DATA_START_ADR + getLevelsArray().length * Integer.BYTES + 2 * Double.BYTES + index * Double.BYTES;
+ DATA_START_ADR + getLevelsArray().length * Integer.BYTES + (index + 2) * Double.BYTES;
wmem.putDouble(offset, item);
}
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
index cbb6347..4d3fb54 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
@@ -39,16 +39,15 @@
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.TGT_IS_READ_ONLY;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
+import static org.apache.datasketches.kll.KllSketch.SketchType.FLOATS_SKETCH;
import org.apache.datasketches.common.Family;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableMemory;
-//intentional extra line
/**
* This class implements an off-heap floats KllSketch via a WritableMemory instance of the sketch.
*
@@ -96,7 +95,7 @@
dstMem.putFloatArray(offset, new float[] {Float.NaN, Float.NaN}, 0, 2);
offset += 2 * Float.BYTES;
dstMem.putFloatArray(offset, new float[k], 0, k);
- final KllMemoryValidate memVal = new KllMemoryValidate(dstMem);
+ final KllMemoryValidate memVal = new KllMemoryValidate(dstMem, FLOATS_SKETCH);
return new KllDirectFloatsSketch(dstMem, memReqSvr, memVal);
}
@@ -110,9 +109,6 @@
return getMemoryN(wmem);
}
- @Override
- double getDoubleSingleItem() { kllSketchThrow(MUST_NOT_CALL); return Double.NaN; }
-
@Override //returns entire array including empty space at bottom
float[] getFloatItemsArray() {
final int capacityItems = levelsArr[getNumLevels()];
diff --git a/src/main/java/org/apache/datasketches/kll/KllDoublesHelper.java b/src/main/java/org/apache/datasketches/kll/KllDoublesHelper.java
index 236b4c4..2006155 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDoublesHelper.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDoublesHelper.java
@@ -35,39 +35,41 @@
final class KllDoublesHelper {
//Called from KllSketch
- static void mergeDoubleImpl(final KllDoublesSketch sketch, final KllSketch other) {
- if (other.isEmpty()) { return; }
- sketch.nullSortedView();
- final long finalN = sketch.getN() + other.getN();
- final int otherNumLevels = other.getNumLevels();
- final int[] otherLevelsArr = other.getLevelsArray();
+ static void mergeDoubleImpl(final KllDoublesSketch mySketch, final KllSketch other) {
+ final KllDoublesSketch otherDblSk = (KllDoublesSketch) other;
+ if (otherDblSk.isEmpty()) { return; }
+ mySketch.nullSortedView();
+ final long finalN = mySketch.getN() + otherDblSk.getN();
+ final int otherNumLevels = otherDblSk.getNumLevels();
+ final int[] otherLevelsArr = otherDblSk.getLevelsArray();
final double[] otherDoubleItemsArr;
//capture my min & max, minK
- final double myMin = sketch.isEmpty() ? Double.NaN : sketch.getMinDoubleItem();
- final double myMax = sketch.isEmpty() ? Double.NaN : sketch.getMaxDoubleItem();
- final int myMinK = sketch.getMinK();
+ final double myMin = mySketch.isEmpty() ? Double.NaN : mySketch.getMinDoubleItem();
+ final double myMax = mySketch.isEmpty() ? Double.NaN : mySketch.getMaxDoubleItem();
+ final int myMinK = mySketch.getMinK();
//update this sketch with level0 items from the other sketch
- if (other.isCompactSingleItem()) {
- updateDouble(sketch, other.getDoubleSingleItem());
+
+ if (otherDblSk.isCompactSingleItem()) {
+ updateDouble(mySketch, otherDblSk.getDoubleSingleItem());
otherDoubleItemsArr = new double[0];
} else {
- otherDoubleItemsArr = other.getDoubleItemsArray();
+ otherDoubleItemsArr = otherDblSk.getDoubleItemsArray();
for (int i = otherLevelsArr[0]; i < otherLevelsArr[1]; i++) {
- KllDoublesHelper.updateDouble(sketch, otherDoubleItemsArr[i]);
+ KllDoublesHelper.updateDouble(mySketch, otherDoubleItemsArr[i]);
}
}
// 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 double[] myCurDoubleItemsArr = sketch.getDoubleItemsArray();
+ final int myCurNumLevels = mySketch.getNumLevels();
+ final int[] myCurLevelsArr = mySketch.getLevelsArray();
+ final double[] myCurDoubleItemsArr = mySketch.getDoubleItemsArray();
int myNewNumLevels = myCurNumLevels;
int[] myNewLevelsArr = myCurLevelsArr;
double[] myNewDoubleItemsArr = myCurDoubleItemsArr;
- if (otherNumLevels > 1 && !other.isCompactSingleItem()) { //now merge other levels if they exist
- final int tmpSpaceNeeded = sketch.getNumRetained()
+ if (otherNumLevels > 1 && !otherDblSk.isCompactSingleItem()) { //now merge other levels if they exist
+ final int tmpSpaceNeeded = mySketch.getNumRetained()
+ KllHelper.getNumRetainedAboveLevelZero(otherNumLevels, otherLevelsArr);
final double[] workbuf = new double[tmpSpaceNeeded];
final int ub = KllHelper.ubOnNumLevels(finalN);
@@ -81,8 +83,8 @@
otherNumLevels, otherLevelsArr, otherDoubleItemsArr);
// notice that workbuf is being used as both the input and output
- final int[] result = generalDoublesCompress(sketch.getK(), sketch.getM(), provisionalNumLevels,
- workbuf, worklevels, workbuf, outlevels, sketch.isLevelZeroSorted(), KllSketch.random);
+ final int[] result = generalDoublesCompress(mySketch.getK(), mySketch.getM(), provisionalNumLevels,
+ workbuf, worklevels, workbuf, outlevels, mySketch.isLevelZeroSorted(), KllSketch.random);
final int targetItemCount = result[1]; //was finalCapacity. Max size given k, m, numLevels
final int curItemCount = result[2]; //was finalPop
@@ -113,28 +115,28 @@
}
//MEMORY SPACE MANAGEMENT
- if (sketch.updatableMemFormat) {
- sketch.wmem = KllHelper.memorySpaceMgmt(sketch, myNewLevelsArr.length, myNewDoubleItemsArr.length);
+ if (mySketch.updatableMemFormat) {
+ mySketch.wmem = KllHelper.memorySpaceMgmt(mySketch, myNewLevelsArr.length, myNewDoubleItemsArr.length);
}
}
//Update Preamble:
- sketch.setN(finalN);
- if (other.isEstimationMode()) { //otherwise the merge brings over exact items.
- sketch.setMinK(min(myMinK, other.getMinK()));
+ mySketch.setN(finalN);
+ if (otherDblSk.isEstimationMode()) { //otherwise the merge brings over exact items.
+ mySketch.setMinK(min(myMinK, otherDblSk.getMinK()));
}
//Update numLevels, levelsArray, items
- sketch.setNumLevels(myNewNumLevels);
- sketch.setLevelsArray(myNewLevelsArr);
- sketch.setDoubleItemsArray(myNewDoubleItemsArr);
+ mySketch.setNumLevels(myNewNumLevels);
+ mySketch.setLevelsArray(myNewLevelsArr);
+ mySketch.setDoubleItemsArray(myNewDoubleItemsArr);
//Update min, max items
- final double otherMin = other.getMinDoubleItem();
- final double otherMax = other.getMaxDoubleItem();
- sketch.setMinDoubleItem(resolveDoubleMinItem(myMin, otherMin));
- sketch.setMaxDoubleItem(resolveDoubleMaxItem(myMax, otherMax));
- assert KllHelper.sumTheSampleWeights(sketch.getNumLevels(), sketch.getLevelsArray()) == sketch.getN();
+ final double otherMin = otherDblSk.getMinDoubleItem();
+ final double otherMax = otherDblSk.getMaxDoubleItem();
+ mySketch.setMinDoubleItem(resolveDoubleMinItem(myMin, otherMin));
+ mySketch.setMaxDoubleItem(resolveDoubleMaxItem(myMax, otherMax));
+ assert KllHelper.sumTheSampleWeights(mySketch.getNumLevels(), mySketch.getLevelsArray()) == mySketch.getN();
}
//Called from KllHelper and this.generalDoublesCompress(...), this.populateDoubleWorkArrays(...)
@@ -170,13 +172,13 @@
}
/**
- * Validation Method. This must be modified to test validation
+ * Validation Method. This must be modified to use the validation test
* @param buf the items array
* @param start data start
* @param length items array length
* @param random instance of Random
*/
- //NOTE Validation Method: Need to modify.
+ //NOTE Validation Method: Need to modify to run.
//Called from KllHelper, this.generalDoublesCompress(...)
static void randomlyHalveDownDoubles(final double[] buf, final int start, final int length, final Random random) {
assert isEven(length);
@@ -191,13 +193,13 @@
}
/**
- * Validation Method. This must be modified to test validation
+ * Validation Method. This must be modified to use the validation test
* @param buf the items array
* @param start data start
* @param length items array length
* @param random instance of Random
*/
- //NOTE Validation Method: Need to modify.
+ //NOTE Validation Method: Need to modify to run.
//Called from KllHelper, this.generalDoublesCompress(...)
static void randomlyHalveUpDoubles(final double[] buf, final int start, final int length, final Random random) {
assert isEven(length);
@@ -212,20 +214,20 @@
}
//Called from KllDoublesSketch, this.mergeDoubleImpl(...)
- static void updateDouble(final KllSketch sketch, final double item) {
+ static void updateDouble(final KllDoublesSketch dblSk, final double item) {
if (Double.isNaN(item)) { return; }
- final double prevMin = sketch.getMinDoubleItem();
- final double prevMax = sketch.getMaxDoubleItem();
- sketch.setMinDoubleItem(resolveDoubleMinItem(prevMin, item));
- sketch.setMaxDoubleItem(resolveDoubleMaxItem(prevMax, item));
- if (sketch.getLevelsArray()[0] == 0) { KllHelper.compressWhileUpdatingSketch(sketch); }
- final int myLevelsArrAtZero = sketch.getLevelsArray()[0]; //LevelsArr could be expanded
- sketch.incN();
- sketch.setLevelZeroSorted(false);
+ final double prevMin = dblSk.getMinDoubleItem();
+ final double prevMax = dblSk.getMaxDoubleItem();
+ dblSk.setMinDoubleItem(resolveDoubleMinItem(prevMin, item));
+ dblSk.setMaxDoubleItem(resolveDoubleMaxItem(prevMax, item));
+ if (dblSk.getLevelsArray()[0] == 0) { KllHelper.compressWhileUpdatingSketch(dblSk); }
+ final int myLevelsArrAtZero = dblSk.getLevelsArray()[0]; //LevelsArr could be expanded
+ dblSk.incN();
+ dblSk.setLevelZeroSorted(false);
final int nextPos = myLevelsArrAtZero - 1;
assert myLevelsArrAtZero >= 0;
- sketch.setLevelsArrayAt(0, nextPos);
- sketch.setDoubleItemsArrayAt(nextPos, item);
+ dblSk.setLevelsArrayAt(0, nextPos);
+ dblSk.setDoubleItemsArrayAt(nextPos, item);
}
/**
@@ -395,7 +397,7 @@
* The following must be enabled for use with the KllDoublesValidationTest,
* which is only enabled for manual testing. In addition, two Validation Methods
* above need to be modified.
- */ //NOTE Validation Method: Need to uncomment
+ */ //NOTE Validation Method: Need to uncomment to use
// static int nextOffset = 0;
//
// private static int deterministicOffset() {
diff --git a/src/main/java/org/apache/datasketches/kll/KllDoublesSketch.java b/src/main/java/org/apache/datasketches/kll/KllDoublesSketch.java
index dbba6d1..47e86aa 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDoublesSketch.java
@@ -23,9 +23,9 @@
import static java.lang.Math.min;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryUpdatableFormatFlag;
import static org.apache.datasketches.kll.KllSketch.Error.MUST_NOT_BE_UPDATABLE_FORMAT;
-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.kll.KllSketch.SketchType.DOUBLES_SKETCH;
import static org.apache.datasketches.quantilescommon.QuantilesUtil.THROWS_EMPTY;
import static org.apache.datasketches.quantilescommon.QuantilesUtil.equallyWeightedRanks;
@@ -53,20 +53,9 @@
}
/**
- * Returns upper bound on the serialized size of a KllDoublesSketch given the following parameters.
- * @param k parameter that controls size of the sketch and accuracy of estimates
- * @param n stream length
- * @param updatableMemoryFormat true if updatable Memory format, otherwise the standard compact format.
- * @return upper bound on the serialized size of a KllSketch.
- */
- public static int getMaxSerializedSizeBytes(final int k, final long n, final boolean updatableMemoryFormat) {
- return getMaxSerializedSizeBytes(k, n, SketchType.DOUBLES_SKETCH, updatableMemoryFormat);
- }
-
- /**
- * Factory heapify takes the sketch image in Memory and instantiates an on-heap sketch.
+ * Factory heapify takes a compact sketch image in Memory and instantiates an on-heap sketch.
* The resulting sketch will not retain any link to the source Memory.
- * @param srcMem a Memory image of a sketch serialized by this sketch.
+ * @param srcMem a compact Memory image of a sketch serialized by this sketch.
* <a href="{@docRoot}/resources/dictionary.html#mem">See Memory</a>
* @return a heap-based sketch based on the given Memory.
*/
@@ -111,7 +100,7 @@
/**
* Create a new heap instance of this sketch with the default <em>k = 200</em>.
* The default <em>k</em> = 200 results in a normalized rank error of about
- * 1.65%. Larger of K will have smaller error but the sketch will be larger (and slower).
+ * 1.65%. Larger K will have smaller error but the sketch will be larger (and slower).
* This will have a rank error of about 1.65%.
* @return new KllDoublesSketch on the heap.
*/
@@ -123,7 +112,7 @@
* Create a new heap instance of this sketch with a given parameter <em>k</em>.
* <em>k</em> can be between DEFAULT_M and 65535, inclusive.
* The default <em>k</em> = 200 results in a normalized rank error of about
- * 1.65%. Larger of K will have smaller error but the sketch will be larger (and slower).
+ * 1.65%. Larger K will have smaller error but the sketch will be larger (and slower).
* @param k parameter that controls size of the sketch and accuracy of estimates.
* @return new KllDoublesSketch on the heap.
*/
@@ -132,14 +121,14 @@
}
/**
- * Wrap a sketch around the given read only source Memory containing sketch data
+ * Wrap a sketch around the given read only compact source Memory containing sketch data
* that originated from this sketch.
* @param srcMem the read only source Memory
* @return instance of this sketch
*/
public static KllDoublesSketch wrap(final Memory srcMem) {
Objects.requireNonNull(srcMem, "Parameter 'srcMem' must not be null");
- final KllMemoryValidate memVal = new KllMemoryValidate(srcMem);
+ final KllMemoryValidate memVal = new KllMemoryValidate(srcMem, DOUBLES_SKETCH);
if (memVal.updatableMemFormat) {
return new KllDirectDoublesSketch((WritableMemory) srcMem, null, memVal);
} else {
@@ -148,8 +137,8 @@
}
/**
- * Wrap a sketch around the given source Memory containing sketch data that originated from
- * this sketch.
+ * Wrap a sketch around the given source Writable Memory containing sketch data
+ * that originated from this sketch.
* @param srcMem a WritableMemory that contains data.
* @param memReqSvr the given MemoryRequestServer to request a larger WritableMemory
* @return instance of this sketch
@@ -158,7 +147,7 @@
final WritableMemory srcMem,
final MemoryRequestServer memReqSvr) {
Objects.requireNonNull(srcMem, "Parameter 'srcMem' must not be null");
- final KllMemoryValidate memVal = new KllMemoryValidate(srcMem);
+ final KllMemoryValidate memVal = new KllMemoryValidate(srcMem, DOUBLES_SKETCH);
if (memVal.updatableMemFormat) {
if (!memVal.readOnly) {
Objects.requireNonNull(memReqSvr, "Parameter 'memReqSvr' must not be null");
@@ -169,6 +158,17 @@
}
}
+ /**
+ * Returns upper bound on the serialized size of a KllDoublesSketch given the following parameters.
+ * @param k parameter that controls size of the sketch and accuracy of estimates
+ * @param n stream length
+ * @param updatableMemoryFormat true if updatable Memory format, otherwise the standard compact format.
+ * @return upper bound on the serialized size of a KllSketch.
+ */
+ public static int getMaxSerializedSizeBytes(final int k, final long n, final boolean updatableMemoryFormat) {
+ return getMaxSerializedSizeBytes(k, n, SketchType.DOUBLES_SKETCH, updatableMemoryFormat);
+ }
+
@Override
public double[] getCDF(final double[] splitPoints, final QuantileSearchCriteria searchCrit) {
if (isEmpty()) { throw new IllegalArgumentException(THROWS_EMPTY); }
@@ -289,10 +289,35 @@
}
@Override
+ @SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "OK in this case.")
+ public DoublesSortedView getSortedView() {
+ refreshSortedView();
+ return kllDoublesSV;
+ }
+
+ @Override
public QuantilesDoublesSketchIterator iterator() {
return new KllDoublesSketchIterator(getDoubleItemsArray(), getLevelsArray(), getNumLevels());
}
+ /**
+ * {@inheritDoc}
+ * <p>The parameter <i>k</i> will not change.</p>
+ */
+ @Override
+ public final void reset() {
+ if (readOnly) { kllSketchThrow(TGT_IS_READ_ONLY); }
+ final int k = getK();
+ setN(0);
+ setMinK(k);
+ setNumLevels(1);
+ setLevelZeroSorted(false);
+ setLevelsArray(new int[] {k, k});
+ setMinDoubleItem(Double.NaN);
+ setMaxDoubleItem(Double.NaN);
+ setDoubleItemsArray(new double[k]);
+ }
+
@Override
public byte[] toByteArray() {
return KllHelper.toCompactByteArrayImpl(this);
@@ -305,38 +330,31 @@
kllDoublesSV = null;
}
- @Override
- @SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "OK in this case.")
- public DoublesSortedView getSortedView() {
- refreshSortedView();
- return kllDoublesSV;
- }
+ //restricted
- void nullSortedView() { kllDoublesSV = null; }
+ /**
+ * @return full size of internal items array including garbage.
+ */
+ abstract double[] getDoubleItemsArray();
- @Override //Artifact of inheritance
- float[] getFloatItemsArray() { kllSketchThrow(MUST_NOT_CALL); return null; }
+ abstract double getDoubleSingleItem();
- @Override //Artifact of inheritance
- float getMaxFloatItem() { kllSketchThrow(MUST_NOT_CALL); return Float.NaN; }
+ abstract double getMaxDoubleItem();
- @Override //Artifact of inheritance
- float getMinFloatItem() { kllSketchThrow(MUST_NOT_CALL); return Float.NaN; }
-
- @Override //Artifact of inheritance
- void setFloatItemsArray(final float[] floatItems) { kllSketchThrow(MUST_NOT_CALL); }
-
- @Override //Artifact of inheritance
- void setFloatItemsArrayAt(final int index, final float item) { kllSketchThrow(MUST_NOT_CALL); }
-
- @Override //Artifact of inheritance
- void setMaxFloatItem(final float item) { kllSketchThrow(MUST_NOT_CALL); }
-
- @Override //Artifact of inheritance
- void setMinFloatItem(final float item) { kllSketchThrow(MUST_NOT_CALL); }
+ abstract double getMinDoubleItem();
private final void refreshSortedView() {
kllDoublesSV = (kllDoublesSV == null) ? new KllDoublesSketchSortedView(this) : kllDoublesSV;
}
+ abstract void setDoubleItemsArray(double[] doubleItems);
+
+ abstract void setDoubleItemsArrayAt(int index, double item);
+
+ abstract void setMaxDoubleItem(double item);
+
+ abstract void setMinDoubleItem(double item);
+
+ void nullSortedView() { kllDoublesSV = null; }
+
}
diff --git a/src/main/java/org/apache/datasketches/kll/KllFloatsHelper.java b/src/main/java/org/apache/datasketches/kll/KllFloatsHelper.java
index 321e152..1e399ab 100644
--- a/src/main/java/org/apache/datasketches/kll/KllFloatsHelper.java
+++ b/src/main/java/org/apache/datasketches/kll/KllFloatsHelper.java
@@ -35,39 +35,40 @@
final class KllFloatsHelper {
//Called from KllSketch
- static void mergeFloatImpl(final KllFloatsSketch sketch, final KllSketch other) {
- if (other.isEmpty()) { return; }
- sketch.nullSortedView();
- final long finalN = sketch.getN() + other.getN();
- final int otherNumLevels = other.getNumLevels();
- final int[] otherLevelsArr = other.getLevelsArray();
+ static void mergeFloatImpl(final KllFloatsSketch mySketch, final KllSketch other) {
+ final KllFloatsSketch otherFltSk = (KllFloatsSketch) other;
+ if (otherFltSk.isEmpty()) { return; }
+ mySketch.nullSortedView();
+ final long finalN = mySketch.getN() + otherFltSk.getN();
+ final int otherNumLevels = otherFltSk.getNumLevels();
+ final int[] otherLevelsArr = otherFltSk.getLevelsArray();
final float[] otherFloatItemsArr;
//capture my min & max, minK
- final float myMin = sketch.isEmpty() ? Float.NaN : sketch.getMinFloatItem();
- final float myMax = sketch.isEmpty() ? Float.NaN : sketch.getMaxFloatItem();
- final int myMinK = sketch.getMinK();
+ final float myMin = mySketch.isEmpty() ? Float.NaN : mySketch.getMinFloatItem();
+ final float myMax = mySketch.isEmpty() ? Float.NaN : mySketch.getMaxFloatItem();
+ final int myMinK = mySketch.getMinK();
//update this sketch with level0 items from the other sketch
- if (other.isCompactSingleItem()) {
- updateFloat(sketch, other.getFloatSingleItem());
+ if (otherFltSk.isCompactSingleItem()) {
+ updateFloat(mySketch, otherFltSk.getFloatSingleItem());
otherFloatItemsArr = new float[0];
} else {
- otherFloatItemsArr = other.getFloatItemsArray();
+ otherFloatItemsArr = otherFltSk.getFloatItemsArray();
for (int i = otherLevelsArr[0]; i < otherLevelsArr[1]; i++) {
- updateFloat(sketch, otherFloatItemsArr[i]);
+ updateFloat(mySketch, otherFloatItemsArr[i]);
}
}
// 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 int myCurNumLevels = mySketch.getNumLevels();
+ final int[] myCurLevelsArr = mySketch.getLevelsArray();
+ final float[] myCurFloatItemsArr = mySketch.getFloatItemsArray();
int myNewNumLevels = myCurNumLevels;
int[] myNewLevelsArr = myCurLevelsArr;
float[] myNewFloatItemsArr = myCurFloatItemsArr;
- if (otherNumLevels > 1 && !other.isCompactSingleItem()) { //now merge higher levels if they exist
- final int tmpSpaceNeeded = sketch.getNumRetained()
+ if (otherNumLevels > 1 && !otherFltSk.isCompactSingleItem()) { //now merge higher levels if they exist
+ final int tmpSpaceNeeded = mySketch.getNumRetained()
+ KllHelper.getNumRetainedAboveLevelZero(otherNumLevels, otherLevelsArr);
final float[] workbuf = new float[tmpSpaceNeeded];
final int ub = KllHelper.ubOnNumLevels(finalN);
@@ -81,8 +82,8 @@
otherNumLevels, otherLevelsArr, otherFloatItemsArr);
// notice that workbuf is being used as both the input and output
- final int[] result = generalFloatsCompress(sketch.getK(), sketch.getM(), provisionalNumLevels,
- workbuf, worklevels, workbuf, outlevels, sketch.isLevelZeroSorted(), KllSketch.random);
+ final int[] result = generalFloatsCompress(mySketch.getK(), mySketch.getM(), provisionalNumLevels,
+ workbuf, worklevels, workbuf, outlevels, mySketch.isLevelZeroSorted(), KllSketch.random);
final int targetItemCount = result[1]; //was finalCapacity. Max size given k, m, numLevels
final int curItemCount = result[2]; //was finalPop
@@ -113,28 +114,28 @@
}
//MEMORY SPACE MANAGEMENT
- if (sketch.updatableMemFormat) {
- sketch.wmem = KllHelper.memorySpaceMgmt(sketch, myNewLevelsArr.length, myNewFloatItemsArr.length);
+ if (mySketch.updatableMemFormat) {
+ mySketch.wmem = KllHelper.memorySpaceMgmt(mySketch, myNewLevelsArr.length, myNewFloatItemsArr.length);
}
}
//Update Preamble:
- sketch.setN(finalN);
- if (other.isEstimationMode()) { //otherwise the merge brings over exact items.
- sketch.setMinK(min(myMinK, other.getMinK()));
+ mySketch.setN(finalN);
+ if (otherFltSk.isEstimationMode()) { //otherwise the merge brings over exact items.
+ mySketch.setMinK(min(myMinK, otherFltSk.getMinK()));
}
//Update numLevels, levelsArray, items
- sketch.setNumLevels(myNewNumLevels);
- sketch.setLevelsArray(myNewLevelsArr);
- sketch.setFloatItemsArray(myNewFloatItemsArr);
+ mySketch.setNumLevels(myNewNumLevels);
+ mySketch.setLevelsArray(myNewLevelsArr);
+ mySketch.setFloatItemsArray(myNewFloatItemsArr);
//Update min, max items
- final float otherMin = other.getMinFloatItem();
- final float otherMax = other.getMaxFloatItem();
- sketch.setMinFloatItem(resolveFloatMinItem(myMin, otherMin));
- sketch.setMaxFloatItem(resolveFloatMaxItem(myMax, otherMax));
- assert KllHelper.sumTheSampleWeights(sketch.getNumLevels(), sketch.getLevelsArray()) == sketch.getN();
+ final float otherMin = otherFltSk.getMinFloatItem();
+ final float otherMax = otherFltSk.getMaxFloatItem();
+ mySketch.setMinFloatItem(resolveFloatMinItem(myMin, otherMin));
+ mySketch.setMaxFloatItem(resolveFloatMaxItem(myMax, otherMax));
+ assert KllHelper.sumTheSampleWeights(mySketch.getNumLevels(), mySketch.getLevelsArray()) == mySketch.getN();
}
//Called from KllHelper and this.generalFloatssCompress(...), this.populateFloatWorkArrays(...)
@@ -176,7 +177,7 @@
* @param length items array length
* @param random instance of Random
*/
- //NOTE: Validation Method: Need to modify to run.
+ //NOTE Validation Method: Need to modify to run.
//Called from KllHelper, this.generalFloatsCompress(...)
static void randomlyHalveDownFloats(final float[] buf, final int start, final int length, final Random random) {
assert isEven(length);
@@ -212,20 +213,20 @@
}
//Called from KllFloatsSketch, this.mergeFloatImpl(...)
- static void updateFloat(final KllSketch sketch, final float item) {
+ static void updateFloat(final KllFloatsSketch fltSk, final float item) {
if (Float.isNaN(item)) { return; }
- final float prevMin = sketch.getMinFloatItem();
- final float prevMax = sketch.getMaxFloatItem();
- sketch.setMinFloatItem(resolveFloatMinItem(prevMin, item));
- sketch.setMaxFloatItem(resolveFloatMaxItem(prevMax, item));
- if (sketch.getLevelsArray()[0] == 0) { KllHelper.compressWhileUpdatingSketch(sketch); }
- final int myLevelsArrAtZero = sketch.getLevelsArray()[0]; //LevelsArr could be expanded
- sketch.incN();
- sketch.setLevelZeroSorted(false);
+ final float prevMin = fltSk.getMinFloatItem();
+ final float prevMax = fltSk.getMaxFloatItem();
+ fltSk.setMinFloatItem(resolveFloatMinItem(prevMin, item));
+ fltSk.setMaxFloatItem(resolveFloatMaxItem(prevMax, item));
+ if (fltSk.getLevelsArray()[0] == 0) { KllHelper.compressWhileUpdatingSketch(fltSk); }
+ final int myLevelsArrAtZero = fltSk.getLevelsArray()[0]; //LevelsArr could be expanded
+ fltSk.incN();
+ fltSk.setLevelZeroSorted(false);
final int nextPos = myLevelsArrAtZero - 1;
assert myLevelsArrAtZero >= 0;
- sketch.setLevelsArrayAt(0, nextPos);
- sketch.setFloatItemsArrayAt(nextPos, item);
+ fltSk.setLevelsArrayAt(0, nextPos);
+ fltSk.setFloatItemsArrayAt(nextPos, item);
}
/**
@@ -393,7 +394,7 @@
/*
* Validation Method.
* The following must be enabled for use with the KllFloatsValidationTest,
- * which is only enabled for manual testing. In addition, two methods
+ * which is only enabled for manual testing. In addition, two Validation Methods
* above need to be modified.
*/ //NOTE Validation Method: Need to uncomment to use
// static int nextOffset = 0;
diff --git a/src/main/java/org/apache/datasketches/kll/KllFloatsSketch.java b/src/main/java/org/apache/datasketches/kll/KllFloatsSketch.java
index eed0e4f..8ff0ccf 100644
--- a/src/main/java/org/apache/datasketches/kll/KllFloatsSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllFloatsSketch.java
@@ -23,9 +23,9 @@
import static java.lang.Math.min;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryUpdatableFormatFlag;
import static org.apache.datasketches.kll.KllSketch.Error.MUST_NOT_BE_UPDATABLE_FORMAT;
-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.kll.KllSketch.SketchType.FLOATS_SKETCH;
import static org.apache.datasketches.quantilescommon.QuantilesUtil.THROWS_EMPTY;
import static org.apache.datasketches.quantilescommon.QuantilesUtil.equallyWeightedRanks;
@@ -53,20 +53,9 @@
}
/**
- * Returns upper bound on the serialized size of a KllFloatsSketch given the following parameters.
- * @param k parameter that controls size of the sketch and accuracy of estimates
- * @param n stream length
- * @param updatableMemoryFormat true if updatable Memory format, otherwise the standard compact format.
- * @return upper bound on the serialized size of a KllSketch.
- */
- public static int getMaxSerializedSizeBytes(final int k, final long n, final boolean updatableMemoryFormat) {
- return getMaxSerializedSizeBytes(k, n, SketchType.FLOATS_SKETCH, updatableMemoryFormat);
- }
-
- /**
- * Factory heapify takes the sketch image in Memory and instantiates an on-heap sketch.
+ * Factory heapify takes a compact sketch image in Memory and instantiates an on-heap sketch.
* The resulting sketch will not retain any link to the source Memory.
- * @param srcMem a Memory image of a sketch serialized by this sketch.
+ * @param srcMem a compact Memory image of a sketch serialized by this sketch.
* <a href="{@docRoot}/resources/dictionary.html#mem">See Memory</a>
* @return a heap-based sketch based on the given Memory.
*/
@@ -132,14 +121,14 @@
}
/**
- * Wrap a sketch around the given read only source Memory containing sketch data
+ * Wrap a sketch around the given read only compact source Memory containing sketch data
* that originated from this sketch.
* @param srcMem the read only source Memory
* @return instance of this sketch
*/
public static KllFloatsSketch wrap(final Memory srcMem) {
Objects.requireNonNull(srcMem, "Parameter 'srcMem' must not be null");
- final KllMemoryValidate memVal = new KllMemoryValidate(srcMem);
+ final KllMemoryValidate memVal = new KllMemoryValidate(srcMem, FLOATS_SKETCH);
if (memVal.updatableMemFormat) {
return new KllDirectFloatsSketch((WritableMemory) srcMem, null, memVal);
} else {
@@ -158,7 +147,7 @@
final WritableMemory srcMem,
final MemoryRequestServer memReqSvr) {
Objects.requireNonNull(srcMem, "Parameter 'srcMem' must not be null");
- final KllMemoryValidate memVal = new KllMemoryValidate(srcMem);
+ final KllMemoryValidate memVal = new KllMemoryValidate(srcMem, FLOATS_SKETCH);
if (memVal.updatableMemFormat) {
if (!memVal.readOnly) {
Objects.requireNonNull(memReqSvr, "Parameter 'memReqSvr' must not be null");
@@ -169,6 +158,17 @@
}
}
+ /**
+ * Returns upper bound on the serialized size of a KllFloatsSketch given the following parameters.
+ * @param k parameter that controls size of the sketch and accuracy of estimates
+ * @param n stream length
+ * @param updatableMemoryFormat true if updatable Memory format, otherwise the standard compact format.
+ * @return upper bound on the serialized size of a KllSketch.
+ */
+ public static int getMaxSerializedSizeBytes(final int k, final long n, final boolean updatableMemoryFormat) {
+ return getMaxSerializedSizeBytes(k, n, SketchType.FLOATS_SKETCH, updatableMemoryFormat);
+ }
+
@Override
public double[] getCDF(final float[] splitPoints, final QuantileSearchCriteria searchCrit) {
if (isEmpty()) { throw new IllegalArgumentException(THROWS_EMPTY); }
@@ -289,10 +289,35 @@
}
@Override
+ @SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "OK in this case.")
+ public FloatsSortedView getSortedView() {
+ refreshSortedView();
+ return kllFloatsSV;
+ }
+
+ @Override
public QuantilesFloatsSketchIterator iterator() {
return new KllFloatsSketchIterator(getFloatItemsArray(), getLevelsArray(), getNumLevels());
}
+ /**
+ * {@inheritDoc}
+ * <p>The parameter <i>k</i> will not change.</p>
+ */
+ @Override
+ public final void reset() {
+ if (readOnly) { kllSketchThrow(TGT_IS_READ_ONLY); }
+ final int k = getK();
+ setN(0);
+ setMinK(k);
+ setNumLevels(1);
+ setLevelZeroSorted(false);
+ setLevelsArray(new int[] {k, k});
+ setMinFloatItem(Float.NaN);
+ setMaxFloatItem(Float.NaN);
+ setFloatItemsArray(new float[k]);
+ }
+
@Override
public byte[] toByteArray() {
return KllHelper.toCompactByteArrayImpl(this);
@@ -305,38 +330,31 @@
kllFloatsSV = null;
}
- @Override
- @SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "OK in this case.")
- public FloatsSortedView getSortedView() {
- refreshSortedView();
- return kllFloatsSV;
- }
+ //restricted
- void nullSortedView() { kllFloatsSV = null; }
+ /**
+ * @return full size of internal items array including garbage.
+ */
+ abstract float[] getFloatItemsArray();
- @Override //Artifact of inheritance
- double[] getDoubleItemsArray() { kllSketchThrow(MUST_NOT_CALL); return null; }
+ abstract float getFloatSingleItem();
- @Override //Artifact of inheritance
- double getMaxDoubleItem() { kllSketchThrow(MUST_NOT_CALL); return Double.NaN; }
+ abstract float getMaxFloatItem();
- @Override //Artifact of inheritance
- double getMinDoubleItem() { kllSketchThrow(MUST_NOT_CALL); return Double.NaN; }
-
- @Override //Artifact of inheritance
- void setDoubleItemsArray(final double[] doubleItems) { kllSketchThrow(MUST_NOT_CALL); }
-
- @Override //Artifact of inheritance
- void setDoubleItemsArrayAt(final int index, final double item) { kllSketchThrow(MUST_NOT_CALL); }
-
- @Override //Artifact of inheritance
- void setMaxDoubleItem(final double item) { kllSketchThrow(MUST_NOT_CALL); }
-
- @Override //Artifact of inheritance
- void setMinDoubleItem(final double item) { kllSketchThrow(MUST_NOT_CALL); }
+ abstract float getMinFloatItem();
private final void refreshSortedView() {
kllFloatsSV = (kllFloatsSV == null) ? new KllFloatsSketchSortedView(this) : kllFloatsSV;
}
+ abstract void setFloatItemsArray(float[] floatItems);
+
+ abstract void setFloatItemsArrayAt(int index, float item);
+
+ abstract void setMaxFloatItem(float item);
+
+ abstract void setMinFloatItem(float item);
+
+ void nullSortedView() { kllFloatsSV = null; }
+
}
diff --git a/src/main/java/org/apache/datasketches/kll/KllFloatsSketchSortedView.java b/src/main/java/org/apache/datasketches/kll/KllFloatsSketchSortedView.java
index 5a7f0e8..185f216 100644
--- a/src/main/java/org/apache/datasketches/kll/KllFloatsSketchSortedView.java
+++ b/src/main/java/org/apache/datasketches/kll/KllFloatsSketchSortedView.java
@@ -82,7 +82,7 @@
final InequalitySearch crit = (searchCrit == INCLUSIVE) ? InequalitySearch.GE : InequalitySearch.GT;
final int index = InequalitySearch.find(cumWeights, 0, len - 1, naturalRank, crit);
if (index == -1) {
- return quantiles[quantiles.length - 1]; ///EXCLUSIVE (GT) case: normRank == 1.0;
+ return quantiles[quantiles.length - 1]; //EXCLUSIVE (GT) case: normRank == 1.0;
}
return quantiles[index];
}
diff --git a/src/main/java/org/apache/datasketches/kll/KllHeapDoublesSketch.java b/src/main/java/org/apache/datasketches/kll/KllHeapDoublesSketch.java
index 1882b0e..2b18fe2 100644
--- a/src/main/java/org/apache/datasketches/kll/KllHeapDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllHeapDoublesSketch.java
@@ -21,10 +21,9 @@
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.KllSketch.Error.MUST_NOT_CALL;
import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_ITEM;
-import static org.apache.datasketches.kll.KllSketch.Error.SRC_MUST_BE_DOUBLE;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
+import static org.apache.datasketches.kll.KllSketch.SketchType.DOUBLES_SKETCH;
import java.util.Objects;
@@ -39,14 +38,14 @@
* @author Lee Rhodes, Kevin Lang
*/
final class KllHeapDoublesSketch extends KllDoublesSketch {
- private final int k_; // configured size of K.
- private final int m_; // configured size of M.
- private long n_; // number of items input into this sketch.
+ private final int k_; // configured size of K.
+ private final int m_; // configured size of M.
+ private long n_; // number of items input into this sketch.
private int minK_; // dynamic minK for error estimation after merging with different k.
private boolean isLevelZeroSorted_;
- private double minItem_;
- private double maxItem_;
- private double[] quantiles_;
+ private double minDoubleItem_;
+ private double maxDoubleItem_;
+ private double[] doubleItems_;
/**
* New instance heap constructor with a given parameters <em>k</em> and <em>m</em>.
@@ -69,18 +68,18 @@
minK_ = k;
isLevelZeroSorted_ = false;
levelsArr = new int[] {k, k};
- minItem_ = Double.NaN;
- maxItem_ = Double.NaN;
- quantiles_ = new double[k];
+ minDoubleItem_ = Double.NaN;
+ maxDoubleItem_ = Double.NaN;
+ doubleItems_ = new double[k];
}
/**
* Heapify constructor.
* @param srcMem Memory object that contains data serialized by this sketch.
- * @param memValidate the MemoryVaidate object
+ * @param memValidate the MemoryValidate object
*/
private KllHeapDoublesSketch(final Memory srcMem, final KllMemoryValidate memValidate) {
- super(null, null );
+ super(null, null);
k_ = memValidate.k;
m_ = memValidate.m;
n_ = memValidate.n;
@@ -90,40 +89,39 @@
final boolean updatableMemFormat = memValidate.updatableMemFormat;
if (memValidate.empty && !updatableMemFormat) {
- minItem_ = Double.NaN;
- maxItem_ = Double.NaN;
- quantiles_ = new double[k_];
+ minDoubleItem_ = Double.NaN;
+ maxDoubleItem_ = Double.NaN;
+ doubleItems_ = new double[k_];
}
else if (memValidate.singleItem && !updatableMemFormat) {
final double item = srcMem.getDouble(DATA_START_ADR_SINGLE_ITEM);
- minItem_ = maxItem_ = item;
- quantiles_ = new double[k_];
- quantiles_[k_ - 1] = item;
+ minDoubleItem_ = maxDoubleItem_ = item;
+ doubleItems_ = new double[k_];
+ doubleItems_[k_ - 1] = item;
}
else { //Full or updatableMemFormat
int offsetBytes = DATA_START_ADR;
offsetBytes += (updatableMemFormat ? levelsArr.length * Integer.BYTES : (levelsArr.length - 1) * Integer.BYTES);
- minItem_ = srcMem.getDouble(offsetBytes);
+ minDoubleItem_ = srcMem.getDouble(offsetBytes);
offsetBytes += Double.BYTES;
- maxItem_ = srcMem.getDouble(offsetBytes);
+ maxDoubleItem_ = srcMem.getDouble(offsetBytes);
offsetBytes += Double.BYTES;
final int capacityItems = levelsArr[getNumLevels()];
final int retainedItems = capacityItems - levelsArr[0];
- quantiles_ = new double[capacityItems];
+ doubleItems_ = new double[capacityItems];
final int shift = levelsArr[0];
if (updatableMemFormat) {
offsetBytes += shift * Double.BYTES;
- srcMem.getDoubleArray(offsetBytes, quantiles_, shift, retainedItems);
+ srcMem.getDoubleArray(offsetBytes, doubleItems_, shift, retainedItems);
} else {
- srcMem.getDoubleArray(offsetBytes, quantiles_, shift, retainedItems);
+ srcMem.getDoubleArray(offsetBytes, doubleItems_, shift, retainedItems);
}
}
}
static KllHeapDoublesSketch heapifyImpl(final Memory srcMem) {
Objects.requireNonNull(srcMem, "Parameter 'srcMem' must not be null");
- final KllMemoryValidate memVal = new KllMemoryValidate(srcMem);
- if (!memVal.doublesSketch) { Error.kllSketchThrow(SRC_MUST_BE_DOUBLE); }
+ final KllMemoryValidate memVal = new KllMemoryValidate(srcMem, DOUBLES_SKETCH);
return new KllHeapDoublesSketch(srcMem, memVal);
}
@@ -134,25 +132,22 @@
public long getN() { return n_; }
@Override
- double[] getDoubleItemsArray() { return quantiles_; }
+ double[] getDoubleItemsArray() { return doubleItems_; }
@Override
double getDoubleSingleItem() {
if (n_ != 1L) { kllSketchThrow(NOT_SINGLE_ITEM); return Double.NaN; }
- return quantiles_[k_ - 1];
+ return doubleItems_[k_ - 1];
}
@Override
- float getFloatSingleItem() { kllSketchThrow(MUST_NOT_CALL); return Float.NaN; }
-
- @Override
int getM() { return m_; }
@Override
- double getMaxDoubleItem() { return maxItem_; }
+ double getMaxDoubleItem() { return maxDoubleItem_; }
@Override
- double getMinDoubleItem() { return minItem_; }
+ double getMinDoubleItem() { return minDoubleItem_; }
@Override
int getMinK() { return minK_; }
@@ -167,19 +162,19 @@
boolean isLevelZeroSorted() { return isLevelZeroSorted_; }
@Override
- void setDoubleItemsArray(final double[] doubleItems) { quantiles_ = doubleItems; }
+ void setDoubleItemsArray(final double[] doubleItems) { doubleItems_ = doubleItems; }
@Override
- void setDoubleItemsArrayAt(final int index, final double item) { quantiles_[index] = item; }
+ void setDoubleItemsArrayAt(final int index, final double item) { doubleItems_[index] = item; }
@Override
void setLevelZeroSorted(final boolean sorted) { this.isLevelZeroSorted_ = sorted; }
@Override
- void setMaxDoubleItem(final double item) { maxItem_ = item; }
+ void setMaxDoubleItem(final double item) { maxDoubleItem_ = item; }
@Override
- void setMinDoubleItem(final double item) { minItem_ = item; }
+ void setMinDoubleItem(final double item) { minDoubleItem_ = item; }
@Override
void setMinK(final int minK) { minK_ = minK; }
diff --git a/src/main/java/org/apache/datasketches/kll/KllHeapFloatsSketch.java b/src/main/java/org/apache/datasketches/kll/KllHeapFloatsSketch.java
index f1ebb91..73aefdb 100644
--- a/src/main/java/org/apache/datasketches/kll/KllHeapFloatsSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllHeapFloatsSketch.java
@@ -21,10 +21,9 @@
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.KllSketch.Error.MUST_NOT_CALL;
import static org.apache.datasketches.kll.KllSketch.Error.NOT_SINGLE_ITEM;
-import static org.apache.datasketches.kll.KllSketch.Error.SRC_MUST_BE_FLOAT;
import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
+import static org.apache.datasketches.kll.KllSketch.SketchType.FLOATS_SKETCH;
import java.util.Objects;
@@ -39,9 +38,9 @@
* @author Lee Rhodes, Kevin Lang
*/
final class KllHeapFloatsSketch extends KllFloatsSketch {
- private final int k_; // configured size of K.
- private final int m_; // configured size of M.
- private long n_; // number of items input into this sketch.
+ private final int k_; // configured size of K.
+ private final int m_; // configured size of M.
+ private long n_; // number of items input into this sketch.
private int minK_; // dynamic minK for error estimation after merging with different k.
private boolean isLevelZeroSorted_;
private float minFloatItem_;
@@ -55,7 +54,7 @@
* <em>k</em> can be between <em>m</em> and 65535, inclusive.
* The default <em>k</em> = 200 results in a normalized rank error of about 1.65%.
* Larger <em>k</em> will have smaller error but the sketch will be larger (and slower).
- * @param m parameter that controls the minimum level width in items. It can be 2, 4, 6 or 8.
+ * @param m parameter controls the minimum level width in items. It can be 2, 4, 6 or 8.
* The DEFAULT_M, which is 8 is recommended. Other sizes of <em>m</em> should be considered
* experimental as they have not been as well characterized.
*/
@@ -77,24 +76,24 @@
/**
* Heapify constructor.
* @param srcMem Memory object that contains data serialized by this sketch.
- * @param memVal the MemoryValidate object
+ * @param memValidate the MemoryValidate object
*/
- private KllHeapFloatsSketch(final Memory srcMem, final KllMemoryValidate memVal) {
+ private KllHeapFloatsSketch(final Memory srcMem, final KllMemoryValidate memValidate) {
super(null, null);
- k_ = memVal.k;
- m_ = memVal.m;
- n_ = memVal.n;
- minK_ = memVal.minK;
- levelsArr = memVal.levelsArr;
- isLevelZeroSorted_ = memVal.level0Sorted;
- final boolean updatableMemFormat = memVal.updatableMemFormat;
+ k_ = memValidate.k;
+ m_ = memValidate.m;
+ n_ = memValidate.n;
+ minK_ = memValidate.minK;
+ levelsArr = memValidate.levelsArr;
+ isLevelZeroSorted_ = memValidate.level0Sorted;
+ final boolean updatableMemFormat = memValidate.updatableMemFormat;
- if (memVal.empty && !updatableMemFormat) {
+ if (memValidate.empty && !updatableMemFormat) {
minFloatItem_ = Float.NaN;
maxFloatItem_ = Float.NaN;
floatItems_ = new float[k_];
}
- else if (memVal.singleItem && !updatableMemFormat) {
+ else if (memValidate.singleItem && !updatableMemFormat) {
final float item = srcMem.getFloat(DATA_START_ADR_SINGLE_ITEM);
minFloatItem_ = maxFloatItem_ = item;
floatItems_ = new float[k_];
@@ -122,8 +121,7 @@
static KllHeapFloatsSketch heapifyImpl(final Memory srcMem) {
Objects.requireNonNull(srcMem, "Parameter 'srcMem' must not be null");
- final KllMemoryValidate memVal = new KllMemoryValidate(srcMem);
- if (memVal.doublesSketch) { Error.kllSketchThrow(SRC_MUST_BE_FLOAT); }
+ final KllMemoryValidate memVal = new KllMemoryValidate(srcMem, FLOATS_SKETCH);
return new KllHeapFloatsSketch(srcMem, memVal);
}
@@ -134,9 +132,6 @@
public long getN() { return n_; }
@Override
- double getDoubleSingleItem() { kllSketchThrow(MUST_NOT_CALL); return Double.NaN; }
-
- @Override
float[] getFloatItemsArray() { return floatItems_; }
@Override
diff --git a/src/main/java/org/apache/datasketches/kll/KllHelper.java b/src/main/java/org/apache/datasketches/kll/KllHelper.java
index d27760f..1384e11 100644
--- a/src/main/java/org/apache/datasketches/kll/KllHelper.java
+++ b/src/main/java/org/apache/datasketches/kll/KllHelper.java
@@ -31,19 +31,21 @@
import static org.apache.datasketches.common.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.DOUBLES_SKETCH_BIT_MASK;
import static org.apache.datasketches.kll.KllPreambleUtil.EMPTY_BIT_MASK;
+import static org.apache.datasketches.kll.KllPreambleUtil.FAMILY_BYTE_ADR;
import static org.apache.datasketches.kll.KllPreambleUtil.FLAGS_BYTE_ADR;
import static org.apache.datasketches.kll.KllPreambleUtil.KLL_FAMILY;
import static org.apache.datasketches.kll.KllPreambleUtil.K_SHORT_ADR;
+import static org.apache.datasketches.kll.KllPreambleUtil.M_BYTE_ADR;
+import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_BYTE_ADR;
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;
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.SER_VER_BYTE_ADR;
import static org.apache.datasketches.kll.KllPreambleUtil.SINGLE_ITEM_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;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryFamilyID;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryK;
@@ -57,6 +59,7 @@
import static org.apache.datasketches.kll.KllPreambleUtil.setMemorySingleItemFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryUpdatableFlag;
import static org.apache.datasketches.kll.KllSketch.SketchType.DOUBLES_SKETCH;
+import static org.apache.datasketches.kll.KllSketch.SketchType.FLOATS_SKETCH;
import java.util.Arrays;
@@ -140,6 +143,7 @@
* @param sketch the current sketch
*/
static void compressWhileUpdatingSketch(final KllSketch sketch) {
+ final SketchType sketchType = sketch.sketchType;
final int level =
findLevelToCompact(sketch.getK(), sketch.getM(), sketch.getNumLevels(), sketch.getLevelsArray());
if (level == sketch.getNumLevels() - 1) {
@@ -161,8 +165,9 @@
final int adjPop = oddPop ? rawPop - 1 : rawPop;
final int halfAdjPop = adjPop / 2;
- if (sketch.sketchType == DOUBLES_SKETCH) {
- final double[] myDoubleItemsArr = sketch.getDoubleItemsArray();
+ if (sketchType == DOUBLES_SKETCH) {
+ final KllDoublesSketch dblSk = (KllDoublesSketch) sketch;
+ final double[] myDoubleItemsArr = dblSk.getDoubleItemsArray();
if (level == 0) { // level zero might not be sorted, so we must sort it if we wish to compact it
Arrays.sort(myDoubleItemsArr, adjBeg, adjBeg + adjPop);
}
@@ -177,13 +182,13 @@
}
int newIndex = myLevelsArr[level + 1] - halfAdjPop; // adjust boundaries of the level above
- sketch.setLevelsArrayAt(level + 1, newIndex);
+ dblSk.setLevelsArrayAt(level + 1, newIndex);
if (oddPop) {
- sketch.setLevelsArrayAt(level, myLevelsArr[level + 1] - 1); // the current level now contains one item
+ dblSk.setLevelsArrayAt(level, myLevelsArr[level + 1] - 1); // the current level now contains one item
myDoubleItemsArr[myLevelsArr[level]] = myDoubleItemsArr[rawBeg]; // namely this leftover guy
} else {
- sketch.setLevelsArrayAt(level, myLevelsArr[level + 1]); // the current level is now empty
+ dblSk.setLevelsArrayAt(level, myLevelsArr[level + 1]); // the current level is now empty
}
// verify that we freed up halfAdjPop array slots just below the current level
@@ -197,12 +202,13 @@
}
for (int lvl = 0; lvl < level; lvl++) {
newIndex = myLevelsArr[lvl] + halfAdjPop; //adjust boundary
- sketch.setLevelsArrayAt(lvl, newIndex);
+ dblSk.setLevelsArrayAt(lvl, newIndex);
}
- sketch.setDoubleItemsArray(myDoubleItemsArr);
+ dblSk.setDoubleItemsArray(myDoubleItemsArr);
}
- else { //Float sketch
- final float[] myFloatItemsArr = sketch.getFloatItemsArray();
+ else if (sketchType == FLOATS_SKETCH) {
+ final KllFloatsSketch fltSk = (KllFloatsSketch) sketch;
+ final float[] myFloatItemsArr = fltSk.getFloatItemsArray();
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);
}
@@ -217,13 +223,13 @@
}
int newIndex = myLevelsArr[level + 1] - halfAdjPop; // adjust boundaries of the level above
- sketch.setLevelsArrayAt(level + 1, newIndex);
+ fltSk.setLevelsArrayAt(level + 1, newIndex);
if (oddPop) {
- sketch.setLevelsArrayAt(level, myLevelsArr[level + 1] - 1); // the current level now contains one item
+ fltSk.setLevelsArrayAt(level, myLevelsArr[level + 1] - 1); // the current level now contains one item
myFloatItemsArr[myLevelsArr[level]] = myFloatItemsArr[rawBeg]; // namely this leftover guy
} else {
- sketch.setLevelsArrayAt(level, myLevelsArr[level + 1]); // the current level is now empty
+ fltSk.setLevelsArrayAt(level, myLevelsArr[level + 1]); // the current level is now empty
}
// verify that we freed up halfAdjPop array slots just below the current level
@@ -237,10 +243,11 @@
}
for (int lvl = 0; lvl < level; lvl++) {
newIndex = myLevelsArr[lvl] + halfAdjPop; //adjust boundary
- sketch.setLevelsArrayAt(lvl, newIndex);
+ fltSk.setLevelsArrayAt(lvl, newIndex);
}
- sketch.setFloatItemsArray(myFloatItemsArr);
+ fltSk.setFloatItemsArray(myFloatItemsArr);
}
+ //TODO add items
}
/**
@@ -347,11 +354,11 @@
println("Given N : " + gStats.givenN);
printf("%10s %10s %20s %13s %15s\n", "NumLevels", "MaxItems", "MaxN", "CompactBytes", "UpdatableBytes");
}
- final int typeBytes = (sketchType == DOUBLES_SKETCH) ? Double.BYTES : Float.BYTES;
+ final int typeBytes = sketchType == DOUBLES_SKETCH ? Double.BYTES : Float.BYTES;
do {
gStats.numLevels++; //
lvlStats = getFinalSketchStatsAtNumLevels(gStats.k, gStats.m, gStats.numLevels, false);
- gStats.maxItems = lvlStats.numItems; //
+ gStats.maxItems = lvlStats.numItems;
gStats.maxN = lvlStats.n; //
gStats.compactBytes =
gStats.maxItems * typeBytes + gStats.numLevels * Integer.BYTES + 2 * typeBytes + DATA_START_ADR;
@@ -460,8 +467,7 @@
final int newItemsArrLen) {
final KllSketch.SketchType sketchType = sketch.sketchType;
final WritableMemory oldWmem = sketch.wmem;
- final int typeBytes = (sketchType == DOUBLES_SKETCH) ? Double.BYTES : Float.BYTES;
-
+ final int typeBytes = sketchType == DOUBLES_SKETCH ? Double.BYTES : Float.BYTES;
final int requiredSketchBytes = DATA_START_ADR
+ newLevelsArrLen * Integer.BYTES
+ 2 * typeBytes
@@ -479,57 +485,61 @@
return newWmem;
}
- static String outputData(final boolean doubleType, final int numLevels, final int[] levelsArr,
- final float[] floatItemsArr, final double[] doubleItemsArr) {
+ private static String outputDoublesData(final int numLevels, final int[] levelsArr, final double[] doubleItemsArr) {
final StringBuilder sb = new StringBuilder();
sb.append("### KLL items data {index, item}:").append(Util.LS);
if (levelsArr[0] > 0) {
sb.append(" Garbage:" + Util.LS);
- if (doubleType) {
- for (int i = 0; i < levelsArr[0]; i++) {
- sb.append(" ").append(i + ", ").append(doubleItemsArr[i]).append(Util.LS);
- }
- } else {
- for (int i = 0; i < levelsArr[0]; i++) {
- sb.append(" ").append(i + ", ").append(floatItemsArr[i]).append(Util.LS);
- }
+ for (int i = 0; i < levelsArr[0]; i++) {
+ sb.append(" ").append(i + ", ").append(doubleItemsArr[i]).append(Util.LS);
}
}
int level = 0;
- if (doubleType) {
- while (level < numLevels) {
- final int fromIndex = levelsArr[level];
- final int toIndex = levelsArr[level + 1]; // exclusive
- if (fromIndex < toIndex) {
- sb.append(" level[").append(level).append("]: offset: " + levelsArr[level] + " wt: " + (1 << level));
- sb.append(Util.LS);
- }
-
- for (int i = fromIndex; i < toIndex; i++) {
- sb.append(" ").append(i + ", ").append(doubleItemsArr[i]).append(Util.LS);
- }
- level++;
+ while (level < numLevels) {
+ final int fromIndex = levelsArr[level];
+ final int toIndex = levelsArr[level + 1]; // exclusive
+ if (fromIndex < toIndex) {
+ sb.append(" level[").append(level).append("]: offset: " + levelsArr[level] + " wt: " + (1 << level));
+ sb.append(Util.LS);
}
- }
- else {
- while (level < numLevels) {
- final int fromIndex = levelsArr[level];
- final int toIndex = levelsArr[level + 1]; // exclusive
- if (fromIndex <= toIndex) {
- sb.append(" level[").append(level).append("]: offset: " + levelsArr[level] + " wt: " + (1 << level));
- sb.append(Util.LS);
- }
- for (int i = fromIndex; i < toIndex; i++) {
- sb.append(" ").append(i + ", ").append(floatItemsArr[i]).append(Util.LS);
- }
- level++;
+ for (int i = fromIndex; i < toIndex; i++) {
+ sb.append(" ").append(i + ", ").append(doubleItemsArr[i]).append(Util.LS);
}
+ level++;
}
sb.append(" level[" + level + "]: offset: " + levelsArr[level] + " (Exclusive)");
sb.append(Util.LS);
sb.append("### End items data").append(Util.LS);
+ return sb.toString();
+ }
+ private static String outputFloatsData(final int numLevels, final int[] levelsArr, final float[] floatsItemsArr) {
+ final StringBuilder sb = new StringBuilder();
+ sb.append("### KLL items data {index, item}:").append(Util.LS);
+ if (levelsArr[0] > 0) {
+ sb.append(" Garbage:" + Util.LS);
+ for (int i = 0; i < levelsArr[0]; i++) {
+ sb.append(" ").append(i + ", ").append(floatsItemsArr[i]).append(Util.LS);
+ }
+ }
+ int level = 0;
+ while (level < numLevels) {
+ final int fromIndex = levelsArr[level];
+ final int toIndex = levelsArr[level + 1]; // exclusive
+ if (fromIndex < toIndex) {
+ sb.append(" level[").append(level).append("]: offset: " + levelsArr[level] + " wt: " + (1 << level));
+ sb.append(Util.LS);
+ }
+
+ for (int i = fromIndex; i < toIndex; i++) {
+ sb.append(" ").append(i + ", ").append(floatsItemsArr[i]).append(Util.LS);
+ }
+ level++;
+ }
+ sb.append(" level[" + level + "]: offset: " + levelsArr[level] + " (Exclusive)");
+ sb.append(Util.LS);
+ sb.append("### End items data").append(Util.LS);
return sb.toString();
}
@@ -562,83 +572,95 @@
static byte[] toCompactByteArrayImpl(final KllSketch sketch) {
if (sketch.isEmpty()) { return fastEmptyCompactByteArray(sketch); }
if (sketch.isSingleItem()) { return fastSingleItemCompactByteArray(sketch); }
+ //n > 1
final byte[] byteArr = new byte[sketch.getCurrentCompactSerializedSizeBytes()];
final WritableMemory wmem = WritableMemory.writableWrap(byteArr);
loadFirst8Bytes(sketch, wmem, false);
- if (sketch.getN() == 0) { return byteArr; } //empty
- final boolean doubleType = (sketch.sketchType == DOUBLES_SKETCH);
- //load data
- int offset = DATA_START_ADR_SINGLE_ITEM;
+ //remainder of preamble after first 8 bytes
+ setMemoryN(wmem, sketch.getN());
+ setMemoryMinK(wmem, sketch.getMinK());
+ setMemoryNumLevels(wmem, sketch.getNumLevels());
+
+ int offset = DATA_START_ADR;
+
+ //LOAD LEVELS ARR: the last integer in levels_ is NOT serialized
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]]);
- }
- } else { // n > 1
- //remainder of preamble after first 8 bytes
- setMemoryN(wmem, sketch.getN());
- setMemoryMinK(wmem, sketch.getMinK());
- setMemoryNumLevels(wmem, sketch.getNumLevels());
- offset = DATA_START_ADR;
+ final int len = myLevelsArr.length - 1;
+ wmem.putIntArray(offset, myLevelsArr, 0, len);
- //LOAD LEVELS ARR the last integer in levels_ is NOT serialized
- final int len = myLevelsArr.length - 1;
- wmem.putIntArray(offset, myLevelsArr, 0, len);
- offset += len * Integer.BYTES;
+ offset += len * Integer.BYTES;
- //LOAD MIN, MAX Items FOLLOWED BY ITEMS ARRAY
- if (doubleType) {
- wmem.putDouble(offset,sketch.getMinDoubleItem());
+ //LOAD MIN, MAX Items FOLLOWED BY ITEMS ARRAY
+ switch (sketch.sketchType) {
+ case DOUBLES_SKETCH : {
+ final KllDoublesSketch dblSk = (KllDoublesSketch)sketch;
+ wmem.putDouble(offset,dblSk.getMinDoubleItem());
offset += Double.BYTES;
- wmem.putDouble(offset, sketch.getMaxDoubleItem());
+ wmem.putDouble(offset, dblSk.getMaxDoubleItem());
offset += Double.BYTES;
- wmem.putDoubleArray(offset, sketch.getDoubleItemsArray(), myLevelsArr[0], sketch.getNumRetained());
- } else {
- wmem.putFloat(offset, sketch.getMinFloatItem());
- offset += Float.BYTES;
- wmem.putFloat(offset, sketch.getMaxFloatItem());
- offset += Float.BYTES;
- wmem.putFloatArray(offset, sketch.getFloatItemsArray(), myLevelsArr[0], sketch.getNumRetained());
+ wmem.putDoubleArray(offset, dblSk.getDoubleItemsArray(), myLevelsArr[0], sketch.getNumRetained());
+ break;
}
+ case FLOATS_SKETCH : {
+ final KllFloatsSketch fltSk = (KllFloatsSketch)sketch;
+ wmem.putFloat(offset, fltSk.getMinFloatItem());
+ offset += Float.BYTES;
+ wmem.putFloat(offset, fltSk.getMaxFloatItem());
+ offset += Float.BYTES;
+ wmem.putFloatArray(offset, fltSk.getFloatItemsArray(), myLevelsArr[0], sketch.getNumRetained());
+ break;
+ }
+ //case ITEMS_SKETCH : break; //TODO
+ default: throw new IllegalStateException("Unknown Sketch Type");
}
return byteArr;
}
static byte[] fastEmptyCompactByteArray(final KllSketch sketch) {
- final int doubleFlagBit = (sketch.sketchType == DOUBLES_SKETCH) ? DOUBLES_SKETCH_BIT_MASK : 0;
final byte[] byteArr = new byte[8];
byteArr[0] = PREAMBLE_INTS_EMPTY_SINGLE; //2
byteArr[1] = SERIAL_VERSION_EMPTY_FULL; //1
- byteArr[2] = KLL_FAMILY; //15
- byteArr[3] = (byte) (EMPTY_BIT_MASK | doubleFlagBit);
+ byteArr[2] = KLL_FAMILY; //15
+ byteArr[3] = (byte) (EMPTY_BIT_MASK);
ByteArrayUtil.putShortLE(byteArr, K_SHORT_ADR, (short)sketch.getK());
byteArr[6] = (byte)sketch.getM();
return byteArr;
}
static byte[] fastSingleItemCompactByteArray(final KllSketch sketch) {
- final boolean doubleSketch = sketch.sketchType == DOUBLES_SKETCH;
- final int doubleFlagBit = doubleSketch ? DOUBLES_SKETCH_BIT_MASK : 0;
- final byte[] byteArr = new byte[8 + (doubleSketch ? Double.BYTES : Float.BYTES)];
- 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);
- 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());
- } else {
- ByteArrayUtil.putFloatLE(byteArr, DATA_START_ADR_SINGLE_ITEM, sketch.getFloatSingleItem());
+ final SketchType sketchType = sketch.sketchType;
+ final byte[] byteArr;
+ switch (sketchType) {
+ case FLOATS_SKETCH: {
+ final KllFloatsSketch fltSk = (KllFloatsSketch) sketch;
+ byteArr = new byte[8 + Float.BYTES]; //12 bytes total
+ ByteArrayUtil.putFloatLE(byteArr, DATA_START_ADR_SINGLE_ITEM, fltSk.getFloatSingleItem());
+ break;
+ }
+ case DOUBLES_SKETCH: {
+ final KllDoublesSketch dblSk = (KllDoublesSketch) sketch;
+ byteArr = new byte[8 + Double.BYTES]; //16 bytes total
+ ByteArrayUtil.putDoubleLE(byteArr, DATA_START_ADR_SINGLE_ITEM, dblSk.getDoubleSingleItem());
+ break;
+ }
+// case ITEMS_SKETCH: {
+// byteArr = null; //TODO
+// break;
+// }
+ default: return null; //can't happen
}
+ byteArr[PREAMBLE_INTS_BYTE_ADR] = PREAMBLE_INTS_EMPTY_SINGLE; //2
+ byteArr[SER_VER_BYTE_ADR] = SERIAL_VERSION_SINGLE; //2
+ byteArr[FAMILY_BYTE_ADR] = KLL_FAMILY; //15
+ byteArr[FLAGS_BYTE_ADR] = (byte) SINGLE_ITEM_BIT_MASK; //4
+ ByteArrayUtil.putShortLE(byteArr, K_SHORT_ADR, (short)sketch.getK());
+ byteArr[M_BYTE_ADR] = (byte)sketch.getM();
return byteArr;
}
static String toStringImpl(final KllSketch sketch, final boolean withLevels, final boolean withData) {
- final boolean doubleType = (sketch.sketchType == DOUBLES_SKETCH);
+ final SketchType sketchType = sketch.sketchType;
final int k = sketch.getK();
final int m = sketch.getM();
final int numLevels = sketch.getNumLevels();
@@ -646,7 +668,9 @@
final String epsPct = String.format("%.3f%%", sketch.getNormalizedRankError(false) * 100);
final String epsPMFPct = String.format("%.3f%%", sketch.getNormalizedRankError(true) * 100);
final StringBuilder sb = new StringBuilder();
- final String skType = (sketch.updatableMemFormat ? "Direct" : "") + (doubleType ? "Doubles" : "Floats");
+ final String directStr = sketch.updatableMemFormat ? "Direct" : "";
+ final String skType = sketchType == DOUBLES_SKETCH ? directStr + "Doubles" :
+ sketchType == FLOATS_SKETCH ? directStr + "Floats" : directStr + "Items";
sb.append(Util.LS).append("### Kll").append(skType).append("Sketch Summary:").append(Util.LS);
sb.append(" K : ").append(k).append(Util.LS);
sb.append(" Dynamic min K : ").append(sketch.getMinK()).append(Util.LS);
@@ -666,27 +690,43 @@
sb.append(" Compact Storage Bytes : ").append(sketch.getCurrentCompactSerializedSizeBytes()).append(Util.LS);
}
- if (doubleType) {
- sb.append(" Min Item : ").append(sketch.getMinDoubleItem()).append(Util.LS);
- sb.append(" Max Item : ").append(sketch.getMaxDoubleItem()).append(Util.LS);
- } else {
- sb.append(" Min Item : ").append(sketch.getMinFloatItem()).append(Util.LS);
- sb.append(" Max Item : ").append(sketch.getMaxFloatItem()).append(Util.LS);
+ if (sketchType == DOUBLES_SKETCH) {
+ final KllDoublesSketch dblSk = (KllDoublesSketch) sketch;
+ sb.append(" Min Item : ").append(dblSk.getMinDoubleItem()).append(Util.LS);
+ sb.append(" Max Item : ").append(dblSk.getMaxDoubleItem()).append(Util.LS);
+ } else if (sketchType == FLOATS_SKETCH) {
+ final KllFloatsSketch fltSk = (KllFloatsSketch) sketch;
+ sb.append(" Min Item : ").append(fltSk.getMinFloatItem()).append(Util.LS);
+ sb.append(" Max Item : ").append(fltSk.getMaxFloatItem()).append(Util.LS);
}
+// else {
+// KllItemsSketch itmSk = (KllItemsSketch) sketch;
+// sb.append(" Min Item : ").append(itmSk.getMinItem()).append(Util.LS);
+// sb.append(" Max Item : ").append(itmSk.getMaxItem()).append(Util.LS);
+// }
sb.append("### End sketch summary").append(Util.LS);
double[] myDoubleItemsArr = null;
float[] myFloatItemsArr = null;
- if (doubleType) {
- myDoubleItemsArr = sketch.getDoubleItemsArray();
- } else {
- myFloatItemsArr = sketch.getFloatItemsArray();
- }
+ //Object[] myItemsArr = null;
+
if (withLevels) {
sb.append(outputLevels(k, m, numLevels, levelsArr));
}
if (withData) {
- sb.append(outputData(doubleType, numLevels, levelsArr, myFloatItemsArr, myDoubleItemsArr));
+ if (sketchType == DOUBLES_SKETCH) {
+ final KllDoublesSketch dblSk = (KllDoublesSketch) sketch;
+ myDoubleItemsArr = dblSk.getDoubleItemsArray();
+ sb.append(outputDoublesData(numLevels, levelsArr, myDoubleItemsArr));
+ } else if (sketchType == FLOATS_SKETCH) {
+ final KllFloatsSketch fltSk = (KllFloatsSketch) sketch;
+ myFloatItemsArr = fltSk.getFloatItemsArray();
+ sb.append(outputFloatsData(numLevels, levelsArr, myFloatItemsArr));
+ }
+// else { //Items Sketch //TODO
+// myItemsArr = null;
+// sb.append(outputGenericItemsData(numLevels, levelsArr, myItemsArr));
+// }
}
return sb.toString();
}
@@ -699,13 +739,11 @@
* @return a byte array in an updatable form.
*/
private static byte[] toUpdatableByteArrayFromUpdatableMemory(final KllSketch sketch) {
- final boolean doubleType = (sketch.sketchType == SketchType.DOUBLES_SKETCH);
final int curBytes = sketch.getCurrentUpdatableSerializedSizeBytes();
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)
- | (doubleType ? DOUBLES_SKETCH_BIT_MASK : 0));
+ | ((n == 1) ? SINGLE_ITEM_BIT_MASK : 0));
final byte[] byteArr = new byte[curBytes];
sketch.wmem.getByteArray(0, byteArr, 0, curBytes);
byteArr[FLAGS_BYTE_ADR] = flags;
@@ -732,7 +770,7 @@
setMemoryNumLevels(wmem, sketch.getNumLevels());
//load data
- final boolean doubleType = (sketch.sketchType == DOUBLES_SKETCH);
+ final SketchType sketchType = sketch.sketchType;
int offset = DATA_START_ADR;
//LOAD LEVELS ARRAY the last integer in levels_ IS serialized
@@ -742,21 +780,26 @@
offset += len * Integer.BYTES;
//LOAD MIN, MAX Items FOLLOWED BY ITEMS ARRAY
- if (doubleType) {
- wmem.putDouble(offset, sketch.getMinDoubleItem());
+ if (sketchType == DOUBLES_SKETCH) {
+ final KllDoublesSketch dblSk = (KllDoublesSketch) sketch;
+ wmem.putDouble(offset, dblSk.getMinDoubleItem());
offset += Double.BYTES;
- wmem.putDouble(offset, sketch.getMaxDoubleItem());
+ wmem.putDouble(offset, dblSk.getMaxDoubleItem());
offset += Double.BYTES;
- final double[] doubleItemsArr = sketch.getDoubleItemsArray();
+ final double[] doubleItemsArr = dblSk.getDoubleItemsArray();
wmem.putDoubleArray(offset, doubleItemsArr, 0, doubleItemsArr.length);
- } else {
- wmem.putFloat(offset, sketch.getMinFloatItem());
+ } else if (sketchType == FLOATS_SKETCH) {
+ final KllFloatsSketch fltSk = (KllFloatsSketch) sketch;
+ wmem.putFloat(offset, fltSk.getMinFloatItem());
offset += Float.BYTES;
- wmem.putFloat(offset,sketch.getMaxFloatItem());
+ wmem.putFloat(offset,fltSk.getMaxFloatItem());
offset += Float.BYTES;
- final float[] floatItemsArr = sketch.getFloatItemsArray();
+ final float[] floatItemsArr = fltSk.getFloatItemsArray();
wmem.putFloatArray(offset, floatItemsArr, 0, floatItemsArr.length);
}
+// else {
+// //ITEMS_SKETCH //TODO
+// }
return byteArr;
}
@@ -775,6 +818,7 @@
* @param sketch the current sketch
*/
private static void addEmptyTopLevelToCompletelyFullSketch(final KllSketch sketch) {
+ final SketchType sketchType = sketch.sketchType;
final int[] myCurLevelsArr = sketch.getLevelsArray();
final int myCurNumLevels = sketch.getNumLevels();
final int myCurTotalItemsCapacity = myCurLevelsArr[myCurNumLevels];
@@ -793,18 +837,23 @@
float[] myNewFloatItemsArr = null;
double[] myNewDoubleItemsArr = null;
- if (sketch.sketchType == DOUBLES_SKETCH) {
- minDouble = sketch.getMinDoubleItem();
- maxDouble = sketch.getMaxDoubleItem();
- myCurDoubleItemsArr = sketch.getDoubleItemsArray();
+ if (sketchType == DOUBLES_SKETCH) {
+ final KllDoublesSketch dblSk = (KllDoublesSketch) sketch;
+ minDouble = dblSk.getMinDoubleItem();
+ maxDouble = dblSk.getMaxDoubleItem();
+ myCurDoubleItemsArr = dblSk.getDoubleItemsArray();
//assert we are following a certain growth scheme
assert myCurDoubleItemsArr.length == myCurTotalItemsCapacity;
- } else { //FLOATS_SKETCH
- minFloat = sketch.getMinFloatItem();
- maxFloat = sketch.getMaxFloatItem();
- myCurFloatItemsArr = sketch.getFloatItemsArray();
+ } else if (sketchType == FLOATS_SKETCH) {
+ final KllFloatsSketch fltSk = (KllFloatsSketch) sketch;
+ minFloat = fltSk.getMinFloatItem();
+ maxFloat = fltSk.getMaxFloatItem();
+ myCurFloatItemsArr = fltSk.getFloatItemsArray();
assert myCurFloatItemsArr.length == myCurTotalItemsCapacity;
}
+// else {
+// //ITEMS_SKETCH //TODO
+// }
assert myCurLevelsArr[0] == 0; //definition of full is part of the growth scheme
final int deltaItemsCap = levelCapacity(sketch.getK(), myCurNumLevels + 1, 0, sketch.getM());
@@ -832,15 +881,18 @@
myNewLevelsArr[myNewNumLevels] = myNewTotalItemsCapacity; // initialize the new "extra" index at the top
// GROW ITEMS ARRAY
- if (sketch.sketchType == DOUBLES_SKETCH) {
+ if (sketchType == DOUBLES_SKETCH) {
myNewDoubleItemsArr = new double[myNewTotalItemsCapacity];
// copy and shift the current data into the new array
System.arraycopy(myCurDoubleItemsArr, 0, myNewDoubleItemsArr, deltaItemsCap, myCurTotalItemsCapacity);
- } else {
+ } else if (sketchType == FLOATS_SKETCH) {
myNewFloatItemsArr = new float[myNewTotalItemsCapacity];
// copy and shift the current items data into the new array
System.arraycopy(myCurFloatItemsArr, 0, myNewFloatItemsArr, deltaItemsCap, myCurTotalItemsCapacity);
}
+// else {
+// //ITEMS_SKETCH // TODO
+// }
//MEMORY SPACE MANAGEMENT
if (sketch.updatableMemFormat) {
@@ -849,14 +901,16 @@
//update our sketch with new expanded spaces
sketch.setNumLevels(myNewNumLevels);
sketch.setLevelsArray(myNewLevelsArr);
- if (sketch.sketchType == DOUBLES_SKETCH) {
- sketch.setMinDoubleItem(minDouble);
- sketch.setMaxDoubleItem(maxDouble);
- sketch.setDoubleItemsArray(myNewDoubleItemsArr);
+ if (sketchType == DOUBLES_SKETCH) {
+ final KllDoublesSketch dblSk = (KllDoublesSketch) sketch;
+ dblSk.setMinDoubleItem(minDouble);
+ dblSk.setMaxDoubleItem(maxDouble);
+ dblSk.setDoubleItemsArray(myNewDoubleItemsArr);
} else { //Float sketch
- sketch.setMinFloatItem(minFloat);
- sketch.setMaxFloatItem(maxFloat);
- sketch.setFloatItemsArray(myNewFloatItemsArr);
+ final KllFloatsSketch fltSk = (KllFloatsSketch) sketch;
+ fltSk.setMinFloatItem(minFloat);
+ fltSk.setMaxFloatItem(maxFloat);
+ fltSk.setFloatItemsArray(myNewFloatItemsArr);
}
}
@@ -916,7 +970,6 @@
final boolean empty = sk.getN() == 0;
final boolean lvlZeroSorted = sk.isLevelZeroSorted();
final boolean singleItem = sk.getN() == 1;
- final boolean doubleType = (sk.sketchType == DOUBLES_SKETCH);
final int preInts = updatableFormat
? PREAMBLE_INTS_FULL
: (empty || singleItem) ? PREAMBLE_INTS_EMPTY_SINGLE : PREAMBLE_INTS_FULL;
@@ -929,7 +982,6 @@
setMemoryEmptyFlag(wmem, empty);
setMemoryLevelZeroSortedFlag(wmem, lvlZeroSorted);
setMemorySingleItemFlag(wmem, singleItem);
- setMemoryDoubleSketchFlag(wmem, doubleType);
setMemoryUpdatableFlag(wmem, updatableFormat);
setMemoryK(wmem, sk.getK());
setMemoryM(wmem, sk.getM());
diff --git a/src/main/java/org/apache/datasketches/kll/KllMemoryValidate.java b/src/main/java/org/apache/datasketches/kll/KllMemoryValidate.java
index cd571ae..acfebf0 100644
--- a/src/main/java/org/apache/datasketches/kll/KllMemoryValidate.java
+++ b/src/main/java/org/apache/datasketches/kll/KllMemoryValidate.java
@@ -36,7 +36,6 @@
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.getMemoryDoubleSketchFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryEmptyFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryFamilyID;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryFlags;
@@ -50,15 +49,17 @@
import static org.apache.datasketches.kll.KllPreambleUtil.getMemorySerVer;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemorySingleItemFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryUpdatableFormatFlag;
+import static org.apache.datasketches.kll.KllSketch.SketchType.DOUBLES_SKETCH;
import org.apache.datasketches.common.Family;
import org.apache.datasketches.common.SketchesArgumentException;
+import org.apache.datasketches.kll.KllSketch.SketchType;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableMemory;
/**
* This class performs all the error checking of an incoming Memory object and extracts the key fields in the process.
- * This is used by all sketches that read or import Memory objects.
+ * This is used by all KLL sketches that read or import Memory objects.
*
* @author lrhodes
*
@@ -73,7 +74,7 @@
boolean empty;
boolean singleItem;
final boolean level0Sorted;
- final boolean doublesSketch;
+ final SketchType sketchType;
boolean updatableMemFormat = false;
final boolean readOnly;
final int k;
@@ -90,7 +91,8 @@
int sketchBytes;
int[] levelsArr; //adjusted to include top index
- KllMemoryValidate(final Memory srcMem) {
+ KllMemoryValidate(final Memory srcMem, final SketchType sketchType) {
+
readOnly = srcMem.isReadOnly();
preInts = getMemoryPreInts(srcMem);
serVer = getMemorySerVer(srcMem);
@@ -103,13 +105,13 @@
empty = getMemoryEmptyFlag(srcMem);
singleItem = getMemorySingleItemFlag(srcMem);
level0Sorted = getMemoryLevelZeroSortedFlag(srcMem);
- doublesSketch = getMemoryDoubleSketchFlag(srcMem);
+ this.sketchType = sketchType;
k = getMemoryK(srcMem);
m = getMemoryM(srcMem);
KllHelper.checkM(m);
KllHelper.checkK(k, m);
if ((serVer == SERIAL_VERSION_UPDATABLE) ^ updatableMemFormat) { memoryValidateThrow(UPDATABLEBIT_AND_SER_VER, 1); }
- typeBytes = doublesSketch ? Double.BYTES : Float.BYTES;
+ typeBytes = (sketchType == DOUBLES_SKETCH) ? Double.BYTES : Float.BYTES;
if (updatableMemFormat) { updatableMemFormatValidate((WritableMemory) srcMem); }
else { compactMemoryValidate(srcMem); }
diff --git a/src/main/java/org/apache/datasketches/kll/KllPreambleUtil.java b/src/main/java/org/apache/datasketches/kll/KllPreambleUtil.java
index 6bfe4d9..5a3cf6e 100644
--- a/src/main/java/org/apache/datasketches/kll/KllPreambleUtil.java
+++ b/src/main/java/org/apache/datasketches/kll/KllPreambleUtil.java
@@ -20,8 +20,10 @@
package org.apache.datasketches.kll;
import static org.apache.datasketches.common.Util.zeroPad;
+import static org.apache.datasketches.kll.KllSketch.SketchType.DOUBLES_SKETCH;
import org.apache.datasketches.common.Util;
+import org.apache.datasketches.kll.KllSketch.SketchType;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableMemory;
@@ -157,7 +159,6 @@
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 DOUBLES_SKETCH_BIT_MASK = 8;
static final int UPDATABLE_BIT_MASK = 16;
/**
@@ -168,9 +169,9 @@
* @param includeData if true, includes detail of retained data.
* @return the summary string.
*/
- static String toString(final byte[] byteArr, final boolean includeData) {
+ static String toString(final byte[] byteArr, final SketchType sketchType, final boolean includeData) {
final Memory mem = Memory.wrap(byteArr);
- return toString(mem, includeData);
+ return toString(mem, sketchType, includeData);
}
/**
@@ -181,13 +182,13 @@
* @param includeData if true, includes detail of retained data.
* @return the summary string.
*/
- static String toString(final Memory mem, final boolean includeData) {
- final KllMemoryValidate memVal = new KllMemoryValidate(mem);
+ static String toString(final Memory mem, final SketchType sketchType, final boolean includeData) {
+ final KllMemoryValidate memVal = new KllMemoryValidate(mem, sketchType);
final int flags = memVal.flags & 0XFF;
final String flagsStr = (flags) + ", 0x" + (Integer.toHexString(flags)) + ", "
+ zeroPad(Integer.toBinaryString(flags), 8);
final int preInts = memVal.preInts;
- final boolean doublesSketch = memVal.doublesSketch;
+ final boolean doublesSketch = memVal.sketchType == DOUBLES_SKETCH;
final boolean updatableMemFormat = memVal.updatableMemFormat;
final boolean empty = memVal.empty;
final boolean singleItem = memVal.singleItem;
@@ -342,10 +343,6 @@
return (getMemoryFlags(mem) & SINGLE_ITEM_BIT_MASK) != 0;
}
- static boolean getMemoryDoubleSketchFlag(final Memory mem) {
- return (getMemoryFlags(mem) & DOUBLES_SKETCH_BIT_MASK) != 0;
- }
-
static boolean getMemoryUpdatableFormatFlag(final Memory mem) {
return (getMemoryFlags(mem) & UPDATABLE_BIT_MASK) != 0;
}
@@ -401,11 +398,6 @@
setMemoryFlags(wmem, singleItem ? flags | SINGLE_ITEM_BIT_MASK : flags & ~SINGLE_ITEM_BIT_MASK);
}
- static void setMemoryDoubleSketchFlag(final WritableMemory wmem, final boolean doubleSketch) {
- final int flags = getMemoryFlags(wmem);
- setMemoryFlags(wmem, doubleSketch ? flags | DOUBLES_SKETCH_BIT_MASK : flags & ~DOUBLES_SKETCH_BIT_MASK);
- }
-
static void setMemoryUpdatableFlag(final WritableMemory wmem, final boolean updatable) {
final int flags = getMemoryFlags(wmem);
setMemoryFlags(wmem, updatable ? flags | UPDATABLE_BIT_MASK : flags & ~UPDATABLE_BIT_MASK);
diff --git a/src/main/java/org/apache/datasketches/kll/KllSketch.java b/src/main/java/org/apache/datasketches/kll/KllSketch.java
index 32e17a6..700416c 100644
--- a/src/main/java/org/apache/datasketches/kll/KllSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllSketch.java
@@ -88,8 +88,6 @@
TGT_IS_READ_ONLY("Given sketch Memory is immutable, cannot write."),
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"),
MRS_MUST_NOT_BE_NULL("MemoryRequestServer cannot be null."),
NOT_SINGLE_ITEM("Sketch is not single item."),
MUST_NOT_BE_UPDATABLE_FORMAT("Given Memory object must not be in updatableFormat.");
@@ -227,7 +225,7 @@
* @return the current number of bytes this sketch would require to store in the compact Memory Format.
* @deprecated version 4.0.0 use {@link #getSerializedSizeBytes}.
*/
- @Deprecated
+ @Deprecated //just make this package private
public final int getCurrentCompactSerializedSizeBytes() {
return getCurrentSerializedSizeBytes(getNumLevels(), getNumRetained(), sketchType, false);
}
@@ -237,7 +235,7 @@
* @return the current number of bytes this sketch would require to store in the updatable Memory Format.
* @deprecated version 4.0.0 use {@link #getSerializedSizeBytes}.
*/
- @Deprecated
+ @Deprecated //just make this package private
public final int getCurrentUpdatableSerializedSizeBytes() {
final int quantilesCap = KllHelper.computeTotalItemCapacity(getK(), getM(), getNumLevels());
return getCurrentSerializedSizeBytes(getNumLevels(), quantilesCap, sketchType, true);
@@ -342,34 +340,11 @@
if (sketchType == DOUBLES_SKETCH) {
if (!other.isDoublesSketch()) { kllSketchThrow(SRC_MUST_BE_DOUBLE); }
KllDoublesHelper.mergeDoubleImpl((KllDoublesSketch)this, other);
- } else {
+ } else if (sketchType == FLOATS_SKETCH) {
if (!other.isFloatsSketch()) { kllSketchThrow(SRC_MUST_BE_FLOAT); }
KllFloatsHelper.mergeFloatImpl((KllFloatsSketch)this, other);
}
- }
-
- /**
- * {@inheritDoc}
- * <p>The parameter <i>k</i> will not change.</p>
- */
- @Override
- public final void reset() {
- if (readOnly) { kllSketchThrow(TGT_IS_READ_ONLY); }
- final int k = getK();
- setN(0);
- setMinK(k);
- setNumLevels(1);
- setLevelZeroSorted(false);
- setLevelsArray(new int[] {k, k});
- if (sketchType == DOUBLES_SKETCH) {
- setMinDoubleItem(Double.NaN);
- setMaxDoubleItem(Double.NaN);
- setDoubleItemsArray(new double[k]);
- } else {
- setMinFloatItem(Float.NaN);
- setMaxFloatItem(Float.NaN);
- setFloatItemsArray(new float[k]);
- }
+ //TODO items
}
@Override
@@ -387,20 +362,6 @@
return KllHelper.toStringImpl(this, withLevels, withData);
}
- /**
- * @return full size of internal items array including garbage.
- */
- abstract double[] getDoubleItemsArray();
-
- abstract double getDoubleSingleItem();
-
- /**
- * @return full size of internal items array including garbage.
- */
- abstract float[] getFloatItemsArray();
-
- abstract float getFloatSingleItem();
-
final int[] getLevelsArray() {
return levelsArr;
}
@@ -414,14 +375,6 @@
*/
abstract int getM();
- abstract double getMaxDoubleItem();
-
- abstract float getMaxFloatItem();
-
- abstract double getMinDoubleItem();
-
- abstract float getMinFloatItem();
-
/**
* MinK is the K that results from a merge with a sketch configured with a K lower than
* the K of this sketch. This is then used in computing the estimated upper and lower bounds of error.
@@ -453,14 +406,6 @@
*/
boolean isSingleItem() { return getN() == 1; }
- abstract void setDoubleItemsArray(double[] doubleItems);
-
- abstract void setDoubleItemsArrayAt(int index, double item);
-
- abstract void setFloatItemsArray(float[] floatItems);
-
- abstract void setFloatItemsArrayAt(int index, float item);
-
final void setLevelsArray(final int[] levelsArr) {
if (readOnly) { kllSketchThrow(TGT_IS_READ_ONLY); }
this.levelsArr = levelsArr;
@@ -480,14 +425,6 @@
abstract void setLevelZeroSorted(boolean sorted);
- abstract void setMaxDoubleItem(double item);
-
- abstract void setMaxFloatItem(float item);
-
- abstract void setMinDoubleItem(double item);
-
- abstract void setMinFloatItem(float item);
-
abstract void setMinK(int minK);
abstract void setN(long n);
diff --git a/src/main/java/org/apache/datasketches/quantiles/ItemsUnion.java b/src/main/java/org/apache/datasketches/quantiles/ItemsUnion.java
index d90ba23..ed0a006 100644
--- a/src/main/java/org/apache/datasketches/quantiles/ItemsUnion.java
+++ b/src/main/java/org/apache/datasketches/quantiles/ItemsUnion.java
@@ -137,7 +137,7 @@
* @param srcMem Memory image of sketch to be merged
* @param serDe an instance of ArrayOfItemsSerDe
*/
- public void union(final Memory srcMem, final ArrayOfItemsSerDe<T> serDe) { //TODO rename merge
+ public void union(final Memory srcMem, final ArrayOfItemsSerDe<T> serDe) {
final ItemsSketch<T> that = ItemsSketch.getInstance(this.clazz_, srcMem, comparator_, serDe);
gadget_ = updateLogic(maxK_, comparator_, gadget_, that);
}
diff --git a/src/main/java/org/apache/datasketches/quantiles/ItemsUtil.java b/src/main/java/org/apache/datasketches/quantiles/ItemsUtil.java
index 1e1f670..782c467 100644
--- a/src/main/java/org/apache/datasketches/quantiles/ItemsUtil.java
+++ b/src/main/java/org/apache/datasketches/quantiles/ItemsUtil.java
@@ -29,10 +29,6 @@
/**
* Utility class for generic quantiles sketch.
*
- * <p>This class contains a highly specialized sort called blockyTandemMergeSort().
- * It also contains methods that are used while building histograms and other common
- * functions.</p>
- *
* @author Kevin Lang
* @author Alexander Saydakov
*/
diff --git a/src/main/java/org/apache/datasketches/quantiles/KolmogorovSmirnov.java b/src/main/java/org/apache/datasketches/quantiles/KolmogorovSmirnov.java
index ef2b900..c290b05 100644
--- a/src/main/java/org/apache/datasketches/quantiles/KolmogorovSmirnov.java
+++ b/src/main/java/org/apache/datasketches/quantiles/KolmogorovSmirnov.java
@@ -25,7 +25,7 @@
*/
final class KolmogorovSmirnov {
- //TODO This KS test will have to be redesigned to accomodate REQ sketches.
+ //TODO This KS test will have to be redesigned to accommodate REQ sketches.
/**
* Computes the raw delta area between two quantile sketches for the
diff --git a/src/main/java/org/apache/datasketches/theta/PreambleUtil.java b/src/main/java/org/apache/datasketches/theta/PreambleUtil.java
index 2a6c979..562be98 100644
--- a/src/main/java/org/apache/datasketches/theta/PreambleUtil.java
+++ b/src/main/java/org/apache/datasketches/theta/PreambleUtil.java
@@ -477,7 +477,6 @@
wmem.putLong(UNION_THETA_LONG, unionThetaLong);
}
- //TODO convert these to set/clear/any bits
static void setEmpty(final WritableMemory wmem) {
int flags = wmem.getByte(FLAGS_BYTE) & 0XFF;
flags |= EMPTY_FLAG_MASK;
diff --git a/src/test/java/org/apache/datasketches/hll/PreambleUtilTest.java b/src/test/java/org/apache/datasketches/hll/PreambleUtilTest.java
index 2c56b24..cd1e0cb 100644
--- a/src/test/java/org/apache/datasketches/hll/PreambleUtilTest.java
+++ b/src/test/java/org/apache/datasketches/hll/PreambleUtilTest.java
@@ -31,18 +31,18 @@
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
-import org.testng.annotations.Test;
import org.apache.datasketches.common.SketchesArgumentException;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableMemory;
+import org.testng.annotations.Test;
/**
* @author Lee Rhodes
*/
public class PreambleUtilTest {
- @Test
- public void preambleToString() { //TODO Check Visually
+ //@Test
+ public void preambleToString() { // Check Visually
int bytes = HllSketch.getMaxUpdatableSerializationBytes(8, TgtHllType.HLL_4);
byte[] byteArr1 = new byte[bytes];
WritableMemory wmem1 = WritableMemory.writableWrap(byteArr1);
diff --git a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
index c2c7b14..dfa5932 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectDoublesSketchTest.java
@@ -19,6 +19,7 @@
package org.apache.datasketches.kll;
+import static org.apache.datasketches.kll.KllSketch.SketchType.DOUBLES_SKETCH;
import static org.apache.datasketches.quantilescommon.QuantileSearchCriteria.EXCLUSIVE;
import static org.apache.datasketches.quantilescommon.QuantileSearchCriteria.INCLUSIVE;
import static org.testng.Assert.assertEquals;
@@ -351,8 +352,8 @@
assertEquals(sketch2.getNumRetained(), 1);
assertEquals(sketch2.getN(), 1);
assertEquals(sketch2.getNormalizedRankError(false), sketch1.getNormalizedRankError(false));
- assertFalse(Double.isNaN(sketch2.getMinItem()));
- assertFalse(Double.isNaN(sketch2.getMaxItem()));
+ assertTrue(Double.isFinite(sketch2.getMinItem()));
+ assertTrue(Double.isFinite(sketch2.getMaxItem()));
assertEquals(sketch2.getCurrentCompactSerializedSizeBytes(), 8 + Double.BYTES);
}
@@ -368,8 +369,8 @@
assertEquals(sketch2.getNumRetained(), 1);
assertEquals(sketch2.getN(), 1);
assertEquals(sketch2.getNormalizedRankError(false), sketch1.getNormalizedRankError(false));
- assertFalse(Double.isNaN(sketch2.getMinItem()));
- assertFalse(Double.isNaN(sketch2.getMaxItem()));
+ assertTrue(Double.isFinite(sketch2.getMinItem()));
+ assertTrue(Double.isFinite(sketch2.getMaxItem()));
assertEquals(sketch2.getCurrentCompactSerializedSizeBytes(), 8 + Double.BYTES);
}
@@ -481,7 +482,7 @@
//println(sk2.toString(true, true));
compBytes = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(compBytes, true));
+ println(KllPreambleUtil.toString(compBytes, DOUBLES_SKETCH, true));
sk = KllDoublesSketch.writableWrap(wmem, memReqSvr);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
@@ -501,7 +502,7 @@
//println(sk.toString(true, true));
compBytes = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(compBytes, true));
+ println(KllPreambleUtil.toString(compBytes, DOUBLES_SKETCH, true));
sk = KllDoublesSketch.writableWrap(wmem, memReqSvr);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
@@ -522,7 +523,7 @@
//println(sk.toString(true, true));
compBytes = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(compBytes, true));
+ println(KllPreambleUtil.toString(compBytes, DOUBLES_SKETCH, true));
sk = KllDoublesSketch.writableWrap(wmem, memReqSvr);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
@@ -643,7 +644,6 @@
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) { }
}
@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 875595d..7d78b20 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDirectFloatsSketchTest.java
@@ -19,6 +19,7 @@
package org.apache.datasketches.kll;
+import static org.apache.datasketches.kll.KllSketch.SketchType.FLOATS_SKETCH;
import static org.apache.datasketches.quantilescommon.QuantileSearchCriteria.EXCLUSIVE;
import static org.apache.datasketches.quantilescommon.QuantileSearchCriteria.INCLUSIVE;
import static org.testng.Assert.assertEquals;
@@ -352,7 +353,6 @@
assertEquals(sketch2.getN(), 1);
assertEquals(sketch2.getNormalizedRankError(false), sketch1.getNormalizedRankError(false));
assertTrue(Float.isFinite(sketch2.getMinItem()));
- assertTrue(Float.isFinite(sketch2.getMinItem()));
assertTrue(Float.isFinite(sketch2.getMaxItem()));
assertEquals(sketch2.getCurrentCompactSerializedSizeBytes(), 8 + Float.BYTES);
}
@@ -482,7 +482,7 @@
//println(sk2.toString(true, true));
compBytes = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(compBytes, true));
+ println(KllPreambleUtil.toString(compBytes, FLOATS_SKETCH, true));
sk = KllFloatsSketch.writableWrap(wmem, memReqSvr);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
@@ -502,7 +502,7 @@
//println(sk.toString(true, true));
compBytes = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(compBytes, true));
+ println(KllPreambleUtil.toString(compBytes, FLOATS_SKETCH, true));
sk = KllFloatsSketch.writableWrap(wmem, memReqSvr);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
@@ -523,7 +523,7 @@
//println(sk.toString(true, true));
compBytes = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(compBytes, true));
+ println(KllPreambleUtil.toString(compBytes, FLOATS_SKETCH, true));
sk = KllFloatsSketch.writableWrap(wmem, memReqSvr);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
@@ -644,7 +644,6 @@
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.getDoubleSingleItem(); fail(); } catch (SketchesArgumentException e) { }
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -663,6 +662,7 @@
try { sk2.merge(sk1); fail(); } catch (SketchesArgumentException e) { }
}
+ // get Direct Floats Sketch
private static KllFloatsSketch getDFSketch(final int k, final int n) {
KllFloatsSketch sk = KllFloatsSketch.newHeapInstance(k);
for (int i = 1; i <= n; i++) { sk.update(i); }
diff --git a/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java
index 6777b93..e6d1edc 100644
--- a/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllDoublesSketchTest.java
@@ -415,7 +415,7 @@
sketch1.update(1);
final byte[] bytes = sketch1.toByteArray();
final KllDoublesSketch sketch2 = KllDoublesSketch.heapify(Memory.wrap(bytes));
- assertEquals(bytes.length, sketch1.getCurrentCompactSerializedSizeBytes());
+ assertEquals(bytes.length, sketch1.getSerializedSizeBytes());
assertFalse(sketch2.isEmpty());
assertEquals(sketch2.getNumRetained(), 1);
assertEquals(sketch2.getN(), 1);
@@ -501,21 +501,6 @@
}
@Test
- public void coverInheritanceArtifacts() {
- float[] fltArr = new float[0];
- float fltV = 1.0f;
- int idx = 1;
- KllDoublesSketch sk = KllDoublesSketch.newHeapInstance(20);
- try { sk.getFloatItemsArray(); fail(); } catch (SketchesArgumentException e) { }
- try { sk.getMaxFloatItem(); fail(); } catch (SketchesArgumentException e) { }
- try { sk.getMinFloatItem(); fail(); } catch (SketchesArgumentException e) { }
- try { sk.setFloatItemsArray(fltArr); fail(); } catch (SketchesArgumentException e) { }
- try { sk.setFloatItemsArrayAt(idx,fltV); fail(); } catch (SketchesArgumentException e) { }
- try { sk.setMaxFloatItem(fltV); fail(); } catch (SketchesArgumentException e) { }
- try { sk.setMinFloatItem(fltV); fail(); } catch (SketchesArgumentException e) { }
- }
-
- @Test
public void checkReadOnlyUpdate() {
KllDoublesSketch sk1 = KllDoublesSketch.newHeapInstance(20);
Memory mem = Memory.wrap(sk1.toByteArray());
diff --git a/src/test/java/org/apache/datasketches/kll/KllFloatsSketchTest.java b/src/test/java/org/apache/datasketches/kll/KllFloatsSketchTest.java
index 51cbcf1..c6ef946 100644
--- a/src/test/java/org/apache/datasketches/kll/KllFloatsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllFloatsSketchTest.java
@@ -502,21 +502,6 @@
}
@Test
- public void coverInheritanceArtifacts() {
- double[] dblArr = new double[0];
- double dblV = 1.0;
- int idx = 1;
- KllFloatsSketch sk = KllFloatsSketch.newHeapInstance(20);
- try { sk.getDoubleItemsArray(); fail(); } catch (SketchesArgumentException e) { }
- try { sk.getMaxDoubleItem(); fail(); } catch (SketchesArgumentException e) { }
- try { sk.getMinDoubleItem(); fail(); } catch (SketchesArgumentException e) { }
- try { sk.setDoubleItemsArray(dblArr); fail(); } catch (SketchesArgumentException e) { }
- try { sk.setDoubleItemsArrayAt(idx,dblV); fail(); } catch (SketchesArgumentException e) { }
- try { sk.setMaxDoubleItem(dblV); fail(); } catch (SketchesArgumentException e) { }
- try { sk.setMinDoubleItem(dblV); fail(); } catch (SketchesArgumentException e) { }
- }
-
- @Test
public void checkReadOnlyUpdate() {
KllFloatsSketch sk1 = KllFloatsSketch.newHeapInstance(20);
Memory mem = Memory.wrap(sk1.toByteArray());
diff --git a/src/test/java/org/apache/datasketches/kll/KllHelperTest.java b/src/test/java/org/apache/datasketches/kll/KllHelperTest.java
index a68bad4..7d6ff81 100644
--- a/src/test/java/org/apache/datasketches/kll/KllHelperTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllHelperTest.java
@@ -26,21 +26,12 @@
import static org.testng.Assert.fail;
import org.apache.datasketches.common.SketchesArgumentException;
-import org.apache.datasketches.kll.KllSketch.SketchType;
import org.apache.datasketches.memory.Memory;
import org.testng.annotations.Test;
@SuppressWarnings("unused")
public class KllHelperTest {
- /**
- * Println Object o
- * @param o object to print
- */
- static void println(Object o) {
- //System.out.println(o.toString());
- }
-
@Test
public void checkCheckM() {
try {
@@ -195,6 +186,14 @@
KllHelper.getGrowthSchemeForGivenN(k, KllSketch.DEFAULT_M, n, DOUBLES_SKETCH, true);
assertEquals(gStats.numLevels, 2);
assertEquals(gStats.maxItems, 333);
-
}
+
+ /**
+ * Println Object o
+ * @param o object to print
+ */
+ static void println(Object o) {
+ //System.out.println(o.toString());
+ }
+
}
diff --git a/src/test/java/org/apache/datasketches/kll/KllMemoryValidateTest.java b/src/test/java/org/apache/datasketches/kll/KllMemoryValidateTest.java
index e0af8f3..5c23731 100644
--- a/src/test/java/org/apache/datasketches/kll/KllMemoryValidateTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllMemoryValidateTest.java
@@ -19,7 +19,18 @@
package org.apache.datasketches.kll;
-import static org.apache.datasketches.kll.KllPreambleUtil.*;
+import static org.apache.datasketches.kll.KllPreambleUtil.EMPTY_BIT_MASK;
+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;
+import static org.apache.datasketches.kll.KllPreambleUtil.SINGLE_ITEM_BIT_MASK;
+import static org.apache.datasketches.kll.KllPreambleUtil.UPDATABLE_BIT_MASK;
+import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryFamilyID;
+import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryFlags;
+import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryPreInts;
+import static org.apache.datasketches.kll.KllPreambleUtil.setMemorySerVer;
+import static org.apache.datasketches.kll.KllSketch.SketchType.DOUBLES_SKETCH;
+import static org.apache.datasketches.kll.KllSketch.SketchType.FLOATS_SKETCH;
import org.apache.datasketches.common.Family;
import org.apache.datasketches.common.SketchesArgumentException;
@@ -35,7 +46,7 @@
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryFamilyID(wmem, Family.KLL.getID() - 1);
- KllMemoryValidate memVal = new KllMemoryValidate(wmem);
+ KllMemoryValidate memVal = new KllMemoryValidate(wmem, FLOATS_SKETCH);
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -44,7 +55,7 @@
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemorySerVer(wmem, SERIAL_VERSION_EMPTY_FULL - 1);
- KllMemoryValidate memVal = new KllMemoryValidate(wmem);
+ KllMemoryValidate memVal = new KllMemoryValidate(wmem, FLOATS_SKETCH);
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -53,7 +64,7 @@
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryFlags(wmem, EMPTY_BIT_MASK | SINGLE_ITEM_BIT_MASK);
- KllMemoryValidate memVal = new KllMemoryValidate(wmem);
+ KllMemoryValidate memVal = new KllMemoryValidate(wmem, FLOATS_SKETCH);
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -63,7 +74,7 @@
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryFlags(wmem, UPDATABLE_BIT_MASK);
setMemorySerVer(wmem, SERIAL_VERSION_EMPTY_FULL);
- KllMemoryValidate memVal = new KllMemoryValidate(wmem);
+ KllMemoryValidate memVal = new KllMemoryValidate(wmem, FLOATS_SKETCH);
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -73,7 +84,7 @@
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryPreInts(wmem, PREAMBLE_INTS_FULL);
- KllMemoryValidate memVal = new KllMemoryValidate(wmem);
+ KllMemoryValidate memVal = new KllMemoryValidate(wmem, FLOATS_SKETCH);
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -83,7 +94,7 @@
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemorySerVer(wmem, SERIAL_VERSION_EMPTY_FULL);
- KllMemoryValidate memVal = new KllMemoryValidate(wmem);
+ KllMemoryValidate memVal = new KllMemoryValidate(wmem, FLOATS_SKETCH);
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -92,7 +103,7 @@
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryPreInts(wmem, PREAMBLE_INTS_FULL);
- KllMemoryValidate memVal = new KllMemoryValidate(wmem);
+ KllMemoryValidate memVal = new KllMemoryValidate(wmem, DOUBLES_SKETCH);
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -102,7 +113,7 @@
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemorySerVer(wmem, SERIAL_VERSION_EMPTY_FULL);
- KllMemoryValidate memVal = new KllMemoryValidate(wmem);
+ KllMemoryValidate memVal = new KllMemoryValidate(wmem, DOUBLES_SKETCH);
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -111,7 +122,7 @@
byte[] byteArr = KllHelper.toUpdatableByteArrayImpl(sk);
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryPreInts(wmem, PREAMBLE_INTS_EMPTY_SINGLE);
- KllMemoryValidate memVal = new KllMemoryValidate(wmem);
+ KllMemoryValidate memVal = new KllMemoryValidate(wmem, DOUBLES_SKETCH);
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -121,7 +132,7 @@
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryPreInts(wmem, PREAMBLE_INTS_EMPTY_SINGLE);
- KllMemoryValidate memVal = new KllMemoryValidate(wmem);
+ KllMemoryValidate memVal = new KllMemoryValidate(wmem, FLOATS_SKETCH);
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -131,7 +142,7 @@
byte[] byteArr = KllHelper.toUpdatableByteArrayImpl(sk);
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryPreInts(wmem, PREAMBLE_INTS_EMPTY_SINGLE);
- KllMemoryValidate memVal = new KllMemoryValidate(wmem);
+ KllMemoryValidate memVal = new KllMemoryValidate(wmem, FLOATS_SKETCH);
}
@Test(expectedExceptions = SketchesArgumentException.class)
@@ -141,7 +152,7 @@
byte[] byteArr = sk.toByteArray();
WritableMemory wmem = WritableMemory.writableWrap(byteArr);
setMemoryPreInts(wmem, PREAMBLE_INTS_FULL);//should be 2, single
- KllMemoryValidate memVal = new KllMemoryValidate(wmem);
+ KllMemoryValidate memVal = new KllMemoryValidate(wmem, DOUBLES_SKETCH);
}
}
diff --git a/src/test/java/org/apache/datasketches/kll/KllMiscDirectDoublesTest.java b/src/test/java/org/apache/datasketches/kll/KllMiscDirectDoublesTest.java
index 0cf1890..3864279 100644
--- a/src/test/java/org/apache/datasketches/kll/KllMiscDirectDoublesTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllMiscDirectDoublesTest.java
@@ -19,6 +19,7 @@
package org.apache.datasketches.kll;
+import static org.apache.datasketches.kll.KllSketch.SketchType.DOUBLES_SKETCH;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
@@ -322,13 +323,13 @@
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
upBytes = KllHelper.toUpdatableByteArrayImpl(sk);
wmem = WritableMemory.writableWrap(upBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllDoublesSketch.writableWrap(wmem, memReqSvr);
upBytes2 = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(upBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(upBytes, upBytes2);
@@ -337,13 +338,13 @@
sk = getDDSketch(k, 0);
upBytes = KllHelper.toUpdatableByteArrayImpl(sk);
wmem = WritableMemory.writableWrap(upBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllDoublesSketch.writableWrap(wmem, memReqSvr);
upBytes2 = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(upBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(upBytes, upBytes2);
@@ -353,13 +354,13 @@
sk.update(1);
upBytes = KllHelper.toUpdatableByteArrayImpl(sk);
wmem = WritableMemory.writableWrap(upBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllDoublesSketch.writableWrap(wmem, memReqSvr);
upBytes2 = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(upBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(upBytes, upBytes2);
diff --git a/src/test/java/org/apache/datasketches/kll/KllMiscDirectFloatsTest.java b/src/test/java/org/apache/datasketches/kll/KllMiscDirectFloatsTest.java
index 4755a4a..f73a441 100644
--- a/src/test/java/org/apache/datasketches/kll/KllMiscDirectFloatsTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllMiscDirectFloatsTest.java
@@ -19,6 +19,7 @@
package org.apache.datasketches.kll;
+import static org.apache.datasketches.kll.KllSketch.SketchType.FLOATS_SKETCH;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
@@ -323,13 +324,13 @@
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
upBytes = KllHelper.toUpdatableByteArrayImpl(sk);
wmem = WritableMemory.writableWrap(upBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllFloatsSketch.writableWrap(wmem, memReqSvr);
upBytes2 = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(upBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(upBytes, upBytes2);
@@ -338,13 +339,13 @@
sk = getDFSketch(k, 0);
upBytes = KllHelper.toUpdatableByteArrayImpl(sk);
wmem = WritableMemory.writableWrap(upBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllFloatsSketch.writableWrap(wmem, memReqSvr);
upBytes2 = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(upBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(upBytes, upBytes2);
@@ -354,13 +355,13 @@
sk.update(1);
upBytes = KllHelper.toUpdatableByteArrayImpl(sk);
wmem = WritableMemory.writableWrap(upBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllFloatsSketch.writableWrap(wmem, memReqSvr);
upBytes2 = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(upBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(upBytes, upBytes2);
diff --git a/src/test/java/org/apache/datasketches/kll/KllMiscDoublesTest.java b/src/test/java/org/apache/datasketches/kll/KllMiscDoublesTest.java
index fd6f52c..4d5d3da 100644
--- a/src/test/java/org/apache/datasketches/kll/KllMiscDoublesTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllMiscDoublesTest.java
@@ -19,6 +19,7 @@
package org.apache.datasketches.kll;
+import static org.apache.datasketches.kll.KllSketch.SketchType.DOUBLES_SKETCH;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
@@ -253,7 +254,7 @@
//println(sk.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(wmem, true));
+ println(KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true));
sk = KllDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
@@ -273,7 +274,7 @@
//println(sk.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(wmem, true));
+ println(KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true));
sk = KllDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
@@ -294,7 +295,7 @@
println(sk2.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(wmem, true));
+ println(KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true));
sk = KllDoublesSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
@@ -324,7 +325,7 @@
//println(sk2.toString(true, true));
compBytes = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(wmem, true));
+ println(KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true));
sk = KllHeapDoublesSketch.heapifyImpl(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
@@ -344,7 +345,7 @@
//println(sk.toString(true, true));
compBytes = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(wmem, true));
+ println(KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true));
sk = KllHeapDoublesSketch.heapifyImpl(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
@@ -365,7 +366,7 @@
//println(sk.toString(true, true));
compBytes = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(wmem, true));
+ println(KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true));
sk = KllHeapDoublesSketch.heapifyImpl(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
@@ -396,13 +397,13 @@
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
compBytes = sk.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllDoublesSketch.heapify(wmem);
compBytes2 = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(compBytes, compBytes2);
@@ -411,13 +412,13 @@
sk = KllDoublesSketch.newHeapInstance(20);
compBytes = sk.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllDoublesSketch.heapify(wmem);
compBytes2 = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(compBytes, compBytes2);
@@ -427,13 +428,13 @@
sk.update(1);
compBytes = sk.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllDoublesSketch.heapify(wmem);
compBytes2 = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(compBytes, compBytes2);
@@ -454,13 +455,13 @@
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
upBytes = KllHelper.toUpdatableByteArrayImpl(sk);
wmem = WritableMemory.writableWrap(upBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllHeapDoublesSketch.heapifyImpl(wmem);
upBytes2 = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(upBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s); //note: heapify does not copy garbage, while toUpdatableByteArray does
assertEquals(sk.getN(), sk2.getN());
@@ -472,13 +473,13 @@
sk = KllDoublesSketch.newHeapInstance(k);
upBytes = KllHelper.toUpdatableByteArrayImpl(sk);
wmem = WritableMemory.writableWrap(upBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllHeapDoublesSketch.heapifyImpl(wmem);
upBytes2 = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(upBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(upBytes, upBytes2);
@@ -488,13 +489,13 @@
sk.update(1);
upBytes = KllHelper.toUpdatableByteArrayImpl(sk);
wmem = WritableMemory.writableWrap(upBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllHeapDoublesSketch.heapifyImpl(wmem);
upBytes2 = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(upBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, DOUBLES_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(upBytes, upBytes2);
@@ -542,18 +543,6 @@
}
@Test
- public void checkInheritanceArtifacts() {
- KllDoublesSketch sk = KllDoublesSketch.newHeapInstance(20);
- try { sk.getFloatItemsArray(); fail();} catch (SketchesArgumentException e) {}
- try { sk.getMaxFloatItem(); fail();} catch (SketchesArgumentException e) {}
- try { sk.getMinFloatItem(); fail();} catch (SketchesArgumentException e) {}
- try { sk.setFloatItemsArray(null); fail();} catch (SketchesArgumentException e) {}
- try { sk.setFloatItemsArrayAt(0, 0f); fail();} catch (SketchesArgumentException e) {}
- try { sk.setMaxFloatItem(0); fail();} catch (SketchesArgumentException e) {}
- try { sk.setMinFloatItem(0); fail();} catch (SketchesArgumentException e) {}
- }
-
- @Test
public void printlnTest() {
String s = "PRINTING: printf in " + this.getClass().getName();
println(s);
diff --git a/src/test/java/org/apache/datasketches/kll/KllMiscFloatsTest.java b/src/test/java/org/apache/datasketches/kll/KllMiscFloatsTest.java
index 0642da6..ce27fa2 100644
--- a/src/test/java/org/apache/datasketches/kll/KllMiscFloatsTest.java
+++ b/src/test/java/org/apache/datasketches/kll/KllMiscFloatsTest.java
@@ -19,6 +19,7 @@
package org.apache.datasketches.kll;
+import static org.apache.datasketches.kll.KllSketch.SketchType.FLOATS_SKETCH;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
@@ -275,7 +276,7 @@
println(sk2.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(wmem, true));
+ println(KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true));
sk = KllFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
@@ -295,7 +296,7 @@
//println(sk.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(wmem, true));
+ println(KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true));
sk = KllFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
@@ -316,7 +317,7 @@
//println(sk2.toString(true, true));
compBytes = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(wmem, true));
+ println(KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true));
sk = KllFloatsSketch.heapify(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
@@ -346,7 +347,7 @@
//println(sk2.toString(true, true));
compBytes = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(wmem, true));
+ println(KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true));
sk = KllHeapFloatsSketch.heapifyImpl(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), k + 1);
@@ -366,7 +367,7 @@
//println(sk.toString(true, true));
compBytes = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(wmem, true));
+ println(KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true));
sk = KllHeapFloatsSketch.heapifyImpl(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 0);
@@ -387,7 +388,7 @@
//println(sk.toString(true, true));
compBytes = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(compBytes);
- println(KllPreambleUtil.toString(wmem, true));
+ println(KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true));
sk = KllHeapFloatsSketch.heapifyImpl(wmem);
assertEquals(sk.getK(), k);
assertEquals(sk.getN(), 1);
@@ -418,13 +419,13 @@
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
compBytes = sk.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllFloatsSketch.heapify(wmem);
compBytes2 = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(compBytes, compBytes2);
@@ -433,13 +434,13 @@
sk = KllFloatsSketch.newHeapInstance(k);
compBytes = sk.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllFloatsSketch.heapify(wmem);
compBytes2 = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(compBytes, compBytes2);
@@ -449,13 +450,13 @@
sk.update(1);
compBytes = sk.toByteArray();
wmem = WritableMemory.writableWrap(compBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllFloatsSketch.heapify(wmem);
compBytes2 = sk2.toByteArray();
wmem = WritableMemory.writableWrap(compBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(compBytes, compBytes2);
@@ -476,13 +477,13 @@
for (int i = 1; i <= k + 1; i++) { sk.update(i); }
upBytes = KllHelper.toUpdatableByteArrayImpl(sk);
wmem = WritableMemory.writableWrap(upBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllHeapFloatsSketch.heapifyImpl(wmem);
upBytes2 = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(upBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s); //note: heapify does not copy garbage, while toUpdatableByteArray does
assertEquals(sk.getN(), sk2.getN());
@@ -494,13 +495,13 @@
sk = KllFloatsSketch.newHeapInstance(k);
upBytes = KllHelper.toUpdatableByteArrayImpl(sk);
wmem = WritableMemory.writableWrap(upBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllHeapFloatsSketch.heapifyImpl(wmem);
upBytes2 = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(upBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(upBytes, upBytes2);
@@ -510,13 +511,13 @@
sk.update(1);
upBytes = KllHelper.toUpdatableByteArrayImpl(sk);
wmem = WritableMemory.writableWrap(upBytes);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 1: sketch to byte[]/memory & analyze memory");
println(s);
sk2 = KllHeapFloatsSketch.heapifyImpl(wmem);
upBytes2 = KllHelper.toUpdatableByteArrayImpl(sk2);
wmem = WritableMemory.writableWrap(upBytes2);
- s = KllPreambleUtil.toString(wmem, true);
+ s = KllPreambleUtil.toString(wmem, FLOATS_SKETCH, true);
println("step 2: memory to heap sketch, to byte[]/memory & analyze memory. Should match above");
println(s);
assertEquals(upBytes, upBytes2);
@@ -562,18 +563,6 @@
assertEquals(skCompact.getFloatSingleItem(), 1.0F);
}
- //@Test
- public void checkInheritanceArtifacts() {
- KllFloatsSketch sk = KllFloatsSketch.newHeapInstance(20);
- try { sk.getDoubleItemsArray(); fail();} catch (SketchesArgumentException e) {}
- try { sk.getMaxDoubleItem(); fail();} catch (SketchesArgumentException e) {}
- try { sk.getMinDoubleItem(); fail();} catch (SketchesArgumentException e) {}
- try { sk.setDoubleItemsArray(null); fail();} catch (SketchesArgumentException e) {}
- try { sk.setDoubleItemsArrayAt(0, 0f); fail();} catch (SketchesArgumentException e) {}
- try { sk.setMaxDoubleItem(0); fail();} catch (SketchesArgumentException e) {}
- try { sk.setMinDoubleItem(0); fail();} catch (SketchesArgumentException e) {}
- }
-
@Test
public void printlnTest() {
String s = "PRINTING: printf in " + this.getClass().getName();
diff --git a/src/test/java/org/apache/datasketches/quantiles/KolmogorovSmirnovTest.java b/src/test/java/org/apache/datasketches/quantiles/KolmogorovSmirnovTest.java
index 20d5f1b..fd8e4f7 100644
--- a/src/test/java/org/apache/datasketches/quantiles/KolmogorovSmirnovTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/KolmogorovSmirnovTest.java
@@ -43,7 +43,6 @@
s1.update(x + 500);
s2.update(x);
}
- //TODO NEED TO FIX KS Algo, it assumed non-inclusive cumulative weight arrays
//assertEquals(KolmogorovSmirnov.computeKSDelta(s1, s2), 1.0, 1E-6);
println("D = " + KolmogorovSmirnov.computeKSDelta(s1, s2));
}
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java
index fd530a1..5171c65 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java
@@ -467,7 +467,7 @@
WritableMemory mem2 = WritableMemory.writableWrap(new byte[1_000_000]);
ArrayOfDoublesCompactSketch dcsk = sketch.compact(mem2);
ArrayOfDoublesUnion union = ArrayOfDoublesSketches.wrapUnion(mem); //empty union
- union.union(dcsk); //TODO est error
+ union.union(dcsk);
//ArrayOfDoublesSketches.wrapUnion(mem).union(sketch.compact(WritableMemory.writableWrap(new byte[1_000_000])));
final ArrayOfDoublesSketch result = ArrayOfDoublesUnion.wrap(mem).getResult();
