You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datasketches.apache.org by le...@apache.org on 2022/04/06 20:15:16 UTC
[datasketches-java] branch DirectKllDoubleV2 updated: Refactored KllDirectDoublesSketch and KllDirectFloatsSketch
This is an automated email from the ASF dual-hosted git repository.
leerho pushed a commit to branch DirectKllDoubleV2
in repository https://gitbox.apache.org/repos/asf/datasketches-java.git
The following commit(s) were added to refs/heads/DirectKllDoubleV2 by this push:
new fda951f3 Refactored KllDirectDoublesSketch and KllDirectFloatsSketch
fda951f3 is described below
commit fda951f3dd3de55e287683af334bb0c0eef0cffa
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Wed Apr 6 13:15:10 2022 -0700
Refactored KllDirectDoublesSketch and KllDirectFloatsSketch
---
.../datasketches/kll/KllDirectDoublesSketch.java | 182 ++++++++++++++++-
.../datasketches/kll/KllDirectFloatsSketch.java | 186 ++++++++++++++++-
.../apache/datasketches/kll/KllDirectSketch.java | 225 ---------------------
3 files changed, 362 insertions(+), 231 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
index 95980adb..3c3598c4 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDirectDoublesSketch.java
@@ -26,9 +26,16 @@ import static org.apache.datasketches.kll.KllPreambleUtil.DOUBLES_SKETCH_BIT_MAS
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;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryK;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryLevelZeroSortedFlag;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryM;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryMinK;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryN;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryNumLevels;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryFamilyID;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryFlags;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryK;
+import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryLevelZeroSortedFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryM;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryMinK;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryN;
@@ -53,7 +60,7 @@ import org.apache.datasketches.memory.WritableMemory;
*
* @author Lee Rhodes, Kevin Lang
*/
-public final class KllDirectDoublesSketch extends KllDirectSketch {
+public final class KllDirectDoublesSketch extends KllSketch {
/**
* The actual constructor.
@@ -63,7 +70,11 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
*/
private KllDirectDoublesSketch(final WritableMemory wmem, final MemoryRequestServer memReqSvr,
final KllMemoryValidate memVal) {
- super(SketchType.DOUBLES_SKETCH, wmem, memReqSvr, memVal);
+ super(SketchType.DOUBLES_SKETCH, wmem, memReqSvr);
+ updatableMemory = memVal.updatableMemory && memReqSvr != null;
+ levelsArrUpdatable = memVal.levelsArrUpdatable;
+ minMaxArrUpdatable = memVal.minMaxArrUpdatable;
+ itemsArrUpdatable = memVal.itemsArrUpdatable;
}
/**
@@ -392,4 +403,171 @@ public final class KllDirectDoublesSketch extends KllDirectSketch {
@Override
void setMinFloatValue(final float value) { kllSketchThrow(MUST_NOT_CALL); }
+ //**********************************************************************************
+ final boolean updatableMemory;
+ WritableMemory levelsArrUpdatable;
+ WritableMemory minMaxArrUpdatable;
+ WritableMemory itemsArrUpdatable;
+
+ @Override
+ public int getK() {
+ return getMemoryK(wmem);
+ }
+
+ @Override
+ public long getN() {
+ return getMemoryN(wmem);
+ }
+
+ @Override
+ public void reset() {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ final int k = getK();
+ setN(0);
+ setMinK(k);
+ setNumLevels(1);
+ setLevelsArray(new int[] {k, k});
+ setLevelZeroSorted(false);
+ final int newLevelsArrLen = 2 * Integer.BYTES;
+ final int newItemsArrLen = k;
+ KllHelper.memorySpaceMgmt(this, newLevelsArrLen, newItemsArrLen);
+ levelsArrUpdatable.putIntArray(0L, new int[] {k, k}, 0, 2);
+ if (sketchType == SketchType.DOUBLES_SKETCH) {
+ minMaxArrUpdatable.putDoubleArray(0L, new double[] {Double.NaN, Double.NaN}, 0, 2);
+ itemsArrUpdatable.putDoubleArray(0L, new double[k], 0, k);
+ } else {
+ minMaxArrUpdatable.putFloatArray(0L, new float[] {Float.NaN, Float.NaN}, 0, 2);
+ itemsArrUpdatable.putFloatArray(0L, new float[k], 0, k);
+ }
+ }
+
+ @Override
+ public byte[] toUpdatableByteArray() {
+ final int bytes = (int) wmem.getCapacity();
+ final byte[] byteArr = new byte[bytes];
+ wmem.getByteArray(0, byteArr, 0, bytes);
+ return byteArr;
+ }
+
+ int getItemsArrLengthItems() {
+ return getLevelsArray()[getNumLevels()];
+ }
+
+ @Override
+ int[] getLevelsArray() {
+ final int numInts = getNumLevels() + 1;
+ final int[] myLevelsArr = new int[numInts];
+ levelsArrUpdatable.getIntArray(0, myLevelsArr, 0, numInts);
+ return myLevelsArr;
+ }
+
+ @Override
+ int getLevelsArrayAt(final int index) {
+ return levelsArrUpdatable.getInt((long)index * Integer.BYTES);
+ }
+
+ @Override
+ int getM() {
+ return getMemoryM(wmem);
+ }
+
+ @Override
+ int getMinK() {
+ return getMemoryMinK(wmem);
+ }
+
+ @Override
+ int getNumLevels() {
+ return getMemoryNumLevels(wmem);
+ }
+
+ @Override
+ void incN() {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ long n = getMemoryN(wmem);
+ setMemoryN(wmem, ++n);
+ }
+
+ @Override
+ void incNumLevels() {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ int numLevels = getMemoryNumLevels(wmem);
+ setMemoryNumLevels(wmem, ++numLevels);
+ }
+
+ @Override
+ boolean isLevelZeroSorted() {
+ return getMemoryLevelZeroSortedFlag(wmem);
+ }
+
+ @Override
+ void setItemsArrayUpdatable(final WritableMemory itemsMem) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ itemsArrUpdatable = itemsMem;
+ }
+
+ @Override
+ void setLevelsArray(final int[] levelsArr) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ levelsArrUpdatable.putIntArray(0, levelsArr, 0, levelsArr.length);
+ }
+
+ @Override
+ void setLevelsArrayAt(final int index, final int value) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ levelsArrUpdatable.putInt((long)index * Integer.BYTES, value);
+ }
+
+ @Override
+ void setLevelsArrayAtMinusEq(final int index, final int minusEq) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ final int offset = index * Integer.BYTES;
+ final int curV = levelsArrUpdatable.getInt(offset);
+ levelsArrUpdatable.putInt(offset, curV - minusEq);
+ }
+
+ @Override
+ void setLevelsArrayAtPlusEq(final int index, final int plusEq) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ final int offset = index * Integer.BYTES;
+ final int curV = levelsArrUpdatable.getInt(offset);
+ levelsArrUpdatable.putInt(offset, curV + plusEq);
+ }
+
+ @Override
+ void setLevelsArrayUpdatable(final WritableMemory levelsMem) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ levelsArrUpdatable = levelsMem;
+ }
+
+ @Override
+ void setLevelZeroSorted(final boolean sorted) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ setMemoryLevelZeroSortedFlag(wmem, sorted);
+ }
+
+ @Override
+ void setMinK(final int minK) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ setMemoryMinK(wmem, minK);
+ }
+
+ @Override
+ void setMinMaxArrayUpdatable(final WritableMemory minMaxMem) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ minMaxArrUpdatable = minMaxMem;
+ }
+
+ @Override
+ void setN(final long n) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ setMemoryN(wmem, n);
+ }
+
+ @Override
+ void setNumLevels(final int numLevels) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ setMemoryNumLevels(wmem, numLevels);
+ }
+
}
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
index ecd34327..fb2588a7 100644
--- a/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
+++ b/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java
@@ -25,11 +25,18 @@ import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR;
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;
-import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryMinK;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryK;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryLevelZeroSortedFlag;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryM;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryMinK;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryN;
+import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryNumLevels;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryFamilyID;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryFlags;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryK;
+import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryLevelZeroSortedFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryM;
+import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryMinK;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryN;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryNumLevels;
import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryPreInts;
@@ -53,7 +60,7 @@ import org.apache.datasketches.memory.WritableMemory;
*
* @author Lee Rhodes, Kevin Lang
*/
-public final class KllDirectFloatsSketch extends KllDirectSketch {
+public final class KllDirectFloatsSketch extends KllSketch {
/**
* The actual constructor
@@ -62,8 +69,12 @@ public final class KllDirectFloatsSketch extends KllDirectSketch {
* @param memVal the MemoryValadate object
*/
private KllDirectFloatsSketch(final WritableMemory wmem, final MemoryRequestServer memReqSvr,
- final KllMemoryValidate memVal) {
- super(SketchType.FLOATS_SKETCH, wmem, memReqSvr, memVal);
+ final KllMemoryValidate memVal) {
+ super(SketchType.FLOATS_SKETCH, wmem, memReqSvr);
+ updatableMemory = memVal.updatableMemory && memReqSvr != null;
+ levelsArrUpdatable = memVal.levelsArrUpdatable;
+ minMaxArrUpdatable = memVal.minMaxArrUpdatable;
+ itemsArrUpdatable = memVal.itemsArrUpdatable;
}
/**
@@ -392,4 +403,171 @@ public final class KllDirectFloatsSketch extends KllDirectSketch {
minMaxArrUpdatable.putFloat(0, value);
}
+ //**********************************************************************************
+ final boolean updatableMemory;
+ WritableMemory levelsArrUpdatable;
+ WritableMemory minMaxArrUpdatable;
+ WritableMemory itemsArrUpdatable;
+
+ @Override
+ public int getK() {
+ return getMemoryK(wmem);
+ }
+
+ @Override
+ public long getN() {
+ return getMemoryN(wmem);
+ }
+
+ @Override
+ public void reset() {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ final int k = getK();
+ setN(0);
+ setMinK(k);
+ setNumLevels(1);
+ setLevelsArray(new int[] {k, k});
+ setLevelZeroSorted(false);
+ final int newLevelsArrLen = 2 * Integer.BYTES;
+ final int newItemsArrLen = k;
+ KllHelper.memorySpaceMgmt(this, newLevelsArrLen, newItemsArrLen);
+ levelsArrUpdatable.putIntArray(0L, new int[] {k, k}, 0, 2);
+ if (sketchType == SketchType.DOUBLES_SKETCH) {
+ minMaxArrUpdatable.putDoubleArray(0L, new double[] {Double.NaN, Double.NaN}, 0, 2);
+ itemsArrUpdatable.putDoubleArray(0L, new double[k], 0, k);
+ } else {
+ minMaxArrUpdatable.putFloatArray(0L, new float[] {Float.NaN, Float.NaN}, 0, 2);
+ itemsArrUpdatable.putFloatArray(0L, new float[k], 0, k);
+ }
+ }
+
+ @Override
+ public byte[] toUpdatableByteArray() {
+ final int bytes = (int) wmem.getCapacity();
+ final byte[] byteArr = new byte[bytes];
+ wmem.getByteArray(0, byteArr, 0, bytes);
+ return byteArr;
+ }
+
+ int getItemsArrLengthItems() {
+ return getLevelsArray()[getNumLevels()];
+ }
+
+ @Override
+ int[] getLevelsArray() {
+ final int numInts = getNumLevels() + 1;
+ final int[] myLevelsArr = new int[numInts];
+ levelsArrUpdatable.getIntArray(0, myLevelsArr, 0, numInts);
+ return myLevelsArr;
+ }
+
+ @Override
+ int getLevelsArrayAt(final int index) {
+ return levelsArrUpdatable.getInt((long)index * Integer.BYTES);
+ }
+
+ @Override
+ int getM() {
+ return getMemoryM(wmem);
+ }
+
+ @Override
+ int getMinK() {
+ return getMemoryMinK(wmem);
+ }
+
+ @Override
+ int getNumLevels() {
+ return getMemoryNumLevels(wmem);
+ }
+
+ @Override
+ void incN() {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ long n = getMemoryN(wmem);
+ setMemoryN(wmem, ++n);
+ }
+
+ @Override
+ void incNumLevels() {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ int numLevels = getMemoryNumLevels(wmem);
+ setMemoryNumLevels(wmem, ++numLevels);
+ }
+
+ @Override
+ boolean isLevelZeroSorted() {
+ return getMemoryLevelZeroSortedFlag(wmem);
+ }
+
+ @Override
+ void setItemsArrayUpdatable(final WritableMemory itemsMem) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ itemsArrUpdatable = itemsMem;
+ }
+
+ @Override
+ void setLevelsArray(final int[] levelsArr) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ levelsArrUpdatable.putIntArray(0, levelsArr, 0, levelsArr.length);
+ }
+
+ @Override
+ void setLevelsArrayAt(final int index, final int value) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ levelsArrUpdatable.putInt((long)index * Integer.BYTES, value);
+ }
+
+ @Override
+ void setLevelsArrayAtMinusEq(final int index, final int minusEq) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ final int offset = index * Integer.BYTES;
+ final int curV = levelsArrUpdatable.getInt(offset);
+ levelsArrUpdatable.putInt(offset, curV - minusEq);
+ }
+
+ @Override
+ void setLevelsArrayAtPlusEq(final int index, final int plusEq) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ final int offset = index * Integer.BYTES;
+ final int curV = levelsArrUpdatable.getInt(offset);
+ levelsArrUpdatable.putInt(offset, curV + plusEq);
+ }
+
+ @Override
+ void setLevelsArrayUpdatable(final WritableMemory levelsMem) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ levelsArrUpdatable = levelsMem;
+ }
+
+ @Override
+ void setLevelZeroSorted(final boolean sorted) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ setMemoryLevelZeroSortedFlag(wmem, sorted);
+ }
+
+ @Override
+ void setMinK(final int minK) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ setMemoryMinK(wmem, minK);
+ }
+
+ @Override
+ void setMinMaxArrayUpdatable(final WritableMemory minMaxMem) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ minMaxArrUpdatable = minMaxMem;
+ }
+
+ @Override
+ void setN(final long n) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ setMemoryN(wmem, n);
+ }
+
+ @Override
+ void setNumLevels(final int numLevels) {
+ if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
+ setMemoryNumLevels(wmem, numLevels);
+ }
+
}
diff --git a/src/main/java/org/apache/datasketches/kll/KllDirectSketch.java b/src/main/java/org/apache/datasketches/kll/KllDirectSketch.java
deleted file mode 100644
index 959d4bd3..00000000
--- a/src/main/java/org/apache/datasketches/kll/KllDirectSketch.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.datasketches.kll;
-
-import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryMinK;
-import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryK;
-import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryLevelZeroSortedFlag;
-import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryM;
-import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryN;
-import static org.apache.datasketches.kll.KllPreambleUtil.getMemoryNumLevels;
-import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryMinK;
-import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryLevelZeroSortedFlag;
-import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryN;
-import static org.apache.datasketches.kll.KllPreambleUtil.setMemoryNumLevels;
-import static org.apache.datasketches.kll.KllSketch.Error.TGT_IS_IMMUTABLE;
-import static org.apache.datasketches.kll.KllSketch.Error.kllSketchThrow;
-
-import org.apache.datasketches.memory.MemoryRequestServer;
-import org.apache.datasketches.memory.WritableMemory;
-
-/**
- * This class implements all the methods for the Direct (off-heap) sketches that are independent
- * of the sketch type (float or double).
- */
-abstract class KllDirectSketch extends KllSketch {
- final boolean updatableMemory;
- WritableMemory levelsArrUpdatable;
- WritableMemory minMaxArrUpdatable;
- WritableMemory itemsArrUpdatable;
-
- /**
- * For the direct sketches it is important that the methods implemented here are designed to
- * work dynamically as the sketch grows off-heap.
- * @param sketchType either DOUBLE_SKETCH or FLOAT_SKETCH
- * @param wmem the current WritableMemory
- * @param memReqSvr the given MemoryRequestServer to request a larger WritableMemory
- */
- KllDirectSketch(final SketchType sketchType, final WritableMemory wmem, final MemoryRequestServer memReqSvr,
- final KllMemoryValidate memVal) {
- super(sketchType, wmem, memReqSvr);
- updatableMemory = memVal.updatableMemory && memReqSvr != null;
- levelsArrUpdatable = memVal.levelsArrUpdatable;
- minMaxArrUpdatable = memVal.minMaxArrUpdatable;
- itemsArrUpdatable = memVal.itemsArrUpdatable;
- }
-
- @Override
- public int getK() {
- return getMemoryK(wmem);
- }
-
- @Override
- public long getN() {
- return getMemoryN(wmem);
- }
-
- @Override
- public void reset() {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- final int k = getK();
- setN(0);
- setMinK(k);
- setNumLevels(1);
- setLevelsArray(new int[] {k, k});
- setLevelZeroSorted(false);
- final int newLevelsArrLen = 2 * Integer.BYTES;
- final int newItemsArrLen = k;
- KllHelper.memorySpaceMgmt(this, newLevelsArrLen, newItemsArrLen);
- levelsArrUpdatable.putIntArray(0L, new int[] {k, k}, 0, 2);
- if (sketchType == SketchType.DOUBLES_SKETCH) {
- minMaxArrUpdatable.putDoubleArray(0L, new double[] {Double.NaN, Double.NaN}, 0, 2);
- itemsArrUpdatable.putDoubleArray(0L, new double[k], 0, k);
- } else {
- minMaxArrUpdatable.putFloatArray(0L, new float[] {Float.NaN, Float.NaN}, 0, 2);
- itemsArrUpdatable.putFloatArray(0L, new float[k], 0, k);
- }
- }
-
- @Override
- public byte[] toUpdatableByteArray() {
- final int bytes = (int) wmem.getCapacity();
- final byte[] byteArr = new byte[bytes];
- wmem.getByteArray(0, byteArr, 0, bytes);
- return byteArr;
- }
-
- int getItemsArrLengthItems() {
- return getLevelsArray()[getNumLevels()];
- }
-
- @Override
- int[] getLevelsArray() {
- final int numInts = getNumLevels() + 1;
- final int[] myLevelsArr = new int[numInts];
- levelsArrUpdatable.getIntArray(0, myLevelsArr, 0, numInts);
- return myLevelsArr;
- }
-
- @Override
- int getLevelsArrayAt(final int index) {
- return levelsArrUpdatable.getInt((long)index * Integer.BYTES);
- }
-
- @Override
- int getM() {
- return getMemoryM(wmem);
- }
-
- @Override
- int getMinK() {
- return getMemoryMinK(wmem);
- }
-
- @Override
- int getNumLevels() {
- return getMemoryNumLevels(wmem);
- }
-
- @Override
- void incN() {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- long n = getMemoryN(wmem);
- setMemoryN(wmem, ++n);
- }
-
- @Override
- void incNumLevels() {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- int numLevels = getMemoryNumLevels(wmem);
- setMemoryNumLevels(wmem, ++numLevels);
- }
-
- @Override
- boolean isLevelZeroSorted() {
- return getMemoryLevelZeroSortedFlag(wmem);
- }
-
- @Override
- void setItemsArrayUpdatable(final WritableMemory itemsMem) {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- itemsArrUpdatable = itemsMem;
- }
-
- @Override
- void setLevelsArray(final int[] levelsArr) {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- levelsArrUpdatable.putIntArray(0, levelsArr, 0, levelsArr.length);
- }
-
- @Override
- void setLevelsArrayAt(final int index, final int value) {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- levelsArrUpdatable.putInt((long)index * Integer.BYTES, value);
- }
-
- @Override
- void setLevelsArrayAtMinusEq(final int index, final int minusEq) {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- final int offset = index * Integer.BYTES;
- final int curV = levelsArrUpdatable.getInt(offset);
- levelsArrUpdatable.putInt(offset, curV - minusEq);
- }
-
- @Override
- void setLevelsArrayAtPlusEq(final int index, final int plusEq) {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- final int offset = index * Integer.BYTES;
- final int curV = levelsArrUpdatable.getInt(offset);
- levelsArrUpdatable.putInt(offset, curV + plusEq);
- }
-
- @Override
- void setLevelsArrayUpdatable(final WritableMemory levelsMem) {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- levelsArrUpdatable = levelsMem;
- }
-
- @Override
- void setLevelZeroSorted(final boolean sorted) {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- setMemoryLevelZeroSortedFlag(wmem, sorted);
- }
-
- @Override
- void setMinK(final int minK) {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- setMemoryMinK(wmem, minK);
- }
-
- @Override
- void setMinMaxArrayUpdatable(final WritableMemory minMaxMem) {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- minMaxArrUpdatable = minMaxMem;
- }
-
- @Override
- void setN(final long n) {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- setMemoryN(wmem, n);
- }
-
- @Override
- void setNumLevels(final int numLevels) {
- if (!updatableMemory) { kllSketchThrow(TGT_IS_IMMUTABLE); }
- setMemoryNumLevels(wmem, numLevels);
- }
-
-}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org