#190

Build # #190

Build Type

push

Committed by

Commit Message

<a href="https://github.com/apache/datasketches-java/commit/<a class=hub.com/apache/datasketches-java/commit/<a class="double-link" href="https://git"><a class=hub.com/apache/datasketches-java/commit/<a class="double-link" href="https://git"><a class=hub.com/apache/datasketches-java/commit/<a class="double-link" href="https://git"><a class=hub.com/apache/datasketches-java/commit/4d91b157a68c582e7b7e6a17d4ac1d10e00945c0">4d91b157a">&lt;a href=&quot;https://github.com/apache/datasketches-java/commit/</a><a class="double-link" href="https://github.com/apache/datasketches-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/datasketches-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/datasketches-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/datasketches-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/datasketches-java/commit/4d91b157a68c582e7b7e6a17d4ac1d10e00945c0">4d91b157a</a><a href="https://github.com/apache/datasketches-java/commit/4d91b157a68c582e7b7e6a17d4ac1d10e00945c0">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/apache/datasketches-java/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/apache/datasketches-java/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/apache/datasketches-java/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/apache/datasketches-java/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/apache/datasketches-java/commit/4d91b157a68c582e7b7e6a17d4ac1d10e00945c0&quot;&gt;4d91b157a&lt;/a&gt;&lt;a href=&quot;https://github.com/apache/datasketches-java/commit/4d91b157a68c582e7b7e6a17d4ac1d10e00945c0&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/apache/datasketches-java/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/apache/datasketches-java/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link... (continued)

Run Details

1599 of 1599 new or added lines in 19 files covered. (100.0%)

19147 of 19515 relevant lines covered (98.11%)

0.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.69

/src/main/java/org/apache/datasketches/kll/KllDirectFloatsSketch.java

/*
 * 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 java.lang.Math.max;
import static java.lang.Math.min;
import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_FLOAT;
import static org.apache.datasketches.kll.KllPreambleUtil.DEFAULT_M;
import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_FLOAT;
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.insertMinK;
import static org.apache.datasketches.kll.KllPreambleUtil.insertFamilyID;
import static org.apache.datasketches.kll.KllPreambleUtil.insertFlags;
import static org.apache.datasketches.kll.KllPreambleUtil.insertK;
import static org.apache.datasketches.kll.KllPreambleUtil.insertM;
import static org.apache.datasketches.kll.KllPreambleUtil.insertN;
import static org.apache.datasketches.kll.KllPreambleUtil.insertNumLevels;
import static org.apache.datasketches.kll.KllPreambleUtil.insertPreInts;
import static org.apache.datasketches.kll.KllPreambleUtil.insertSerVer;
import static org.apache.datasketches.kll.KllSketch.Error.MUST_NOT_CALL;
import static org.apache.datasketches.kll.KllSketch.Error.SRC_IS_NOT_DIRECT;
import static org.apache.datasketches.kll.KllSketch.Error.SRC_IS_NOT_FLOAT;
import static org.apache.datasketches.kll.KllSketch.Error.TGT_IS_IMMUTABLE;

import org.apache.datasketches.Family;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableMemory;

//Intentional extra blank line so the code lines up with KllDirectDoublesSketch
/**
 * This class implements an off-heap floats KllSketch via a WritableMemory instance of the sketch.
 *
 * <p>Please refer to the documentation in the package-info:<br>
 * {@link org.apache.datasketches.kll}</p>
 *
 * @author Lee Rhodes, Kevin Lang
 */
public final class KllDirectFloatsSketch extends KllDirectSketch {

  /**
   * The actual constructor
   * @param wmem the current WritableMemory
   * @param memReqSvr the given MemoryRequestServer to request a larger WritableMemory
   * @param memVal the MemoryValadate object
   */
  private KllDirectFloatsSketch(final WritableMemory wmem, final MemoryRequestServer memReqSvr,
      final KllMemoryValidate memVal) {
   super(SketchType.FLOATS_SKETCH, wmem, memReqSvr, memVal);
  }

  /**
   * Wrap a sketch around the given source 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
   */
  public static KllDirectFloatsSketch writableWrap(final WritableMemory srcMem, final MemoryRequestServer memReqSvr) {
    final KllMemoryValidate memVal = new KllMemoryValidate(srcMem);
    return new KllDirectFloatsSketch(srcMem, memReqSvr, memVal);
  }

  /**
   * Create a new instance of this sketch using the default <i>m</i> of 8.
   * @param k parameter that controls size of the sketch and accuracy of estimates
   * @param dstMem the given destination WritableMemory object for use by the sketch
   * @param memReqSvr the given MemoryRequestServer to request a larger WritableMemory
   * @return a new instance of this sketch
   */
  public static KllDirectFloatsSketch newInstance(final int k, final WritableMemory dstMem,
      final MemoryRequestServer memReqSvr) {
    return newInstance(k, DEFAULT_M, dstMem, memReqSvr);
  }

  /**
   * Create a new instance of this sketch.
   * @param k parameter that controls size of the sketch and accuracy of estimates
   * @param m parameter that controls the minimum level width.
   * @param dstMem the given destination WritableMemory object for use by the sketch
   * @param memReqSvr the given MemoryRequestServer to request a larger WritableMemory
   * @return a new instance of this sketch
   */
  static KllDirectFloatsSketch newInstance(final int k, final int m, final WritableMemory dstMem,
      final MemoryRequestServer memReqSvr) {
    insertPreInts(dstMem, PREAMBLE_INTS_FLOAT);
    insertSerVer(dstMem, SERIAL_VERSION_UPDATABLE);
    insertFamilyID(dstMem, Family.KLL.getID());
    insertFlags(dstMem, UPDATABLE_BIT_MASK);
    insertK(dstMem, k);
    insertM(dstMem, m);
    insertN(dstMem, 0);
    insertMinK(dstMem, k);
    insertNumLevels(dstMem, 1);
    int offset = DATA_START_ADR_FLOAT;
    dstMem.putIntArray(offset, new int[] {k, k}, 0, 2);
    offset += 2 * Integer.BYTES;
    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);
    return new KllDirectFloatsSketch(dstMem, memReqSvr, memVal);
  }

  /**
   * Returns an approximation to the Cumulative Distribution Function (CDF), which is the
   * cumulative analog of the PMF, of the input stream given a set of splitPoint (values).
   *
   * <p>The resulting approximations have a probabilistic guarantee that can be obtained from the
   * getNormalizedRankError(false) function.
   *
   * <p>If the sketch is empty this returns null.</p>
   *
   * @param splitPoints an array of <i>m</i> unique, monotonically increasing float values
   * that divide the real number line into <i>m+1</i> consecutive disjoint intervals.
   * The definition of an "interval" is inclusive of the left splitPoint (or minimum value) and
   * exclusive of the right splitPoint, with the exception that the last interval will include
   * the maximum value.
   * It is not necessary to include either the min or max values in these split points.
   *
   * @return an array of m+1 double values on the interval [0.0, 1.0),
   * which are a consecutive approximation to the CDF of the input stream given the splitPoints.
   * The value at array position j of the returned CDF array is the sum of the returned values
   * in positions 0 through j of the returned PMF array.
   */
  public double[] getCDF(final float[] splitPoints) {
    return getFloatsPmfOrCdf(splitPoints, true);
  }

  /**
   * Returns the max value of the stream.
   * If the sketch is empty this returns NaN.
   *
   * @return the max value of the stream
   */
  public float getMaxValue() {
    return getMaxFloatValue();
  }

  /**
   * Returns the min value of the stream.
   * If the sketch is empty this returns NaN.
   *
   * @return the min value of the stream
   */
  public float getMinValue() {
    return getMinFloatValue();
  }

  /**
   * Returns an approximation to the Probability Mass Function (PMF) of the input stream
   * given a set of splitPoints (values).
   *
   * <p>The resulting approximations have a probabilistic guarantee that can be obtained from the
   * getNormalizedRankError(true) function.
   *
   * <p>If the sketch is empty this returns null.</p>
   *
   * @param splitPoints an array of <i>m</i> unique, monotonically increasing float values
   * that divide the real number line into <i>m+1</i> consecutive disjoint intervals.
   * The definition of an "interval" is inclusive of the left splitPoint (or minimum value) and
   * exclusive of the right splitPoint, with the exception that the last interval will include
   * the maximum value.
   * It is not necessary to include either the min or max values in these split points.
   *
   * @return an array of m+1 doubles on the interval [0.0, 1.0),
   * each of which is an approximation to the fraction of the total input stream values
   * (the mass) that fall into one of those intervals.
   * The definition of an "interval" is inclusive of the left splitPoint and exclusive of the right
   * splitPoint, with the exception that the last interval will include maximum value.
   */
  public double[] getPMF(final float[] splitPoints) {
    return getFloatsPmfOrCdf(splitPoints, false);
  }

  /**
   * Returns an approximation to the value of the data item
   * that would be preceded by the given fraction of a hypothetical sorted
   * version of the input stream so far.
   *
   * <p>We note that this method has a fairly large overhead (microseconds instead of nanoseconds)
   * so it should not be called multiple times to get different quantiles from the same
   * sketch. Instead use getQuantiles(), which pays the overhead only once.
   *
   * <p>If the sketch is empty this returns NaN.
   *
   * @param fraction the specified fractional position in the hypothetical sorted stream.
   * These are also called normalized ranks or fractional ranks.
   * If fraction = 0.0, the true minimum value of the stream is returned.
   * If fraction = 1.0, the true maximum value of the stream is returned.
   *
   * @return the approximation to the value at the given fraction
   */
  public float getQuantile(final double fraction) {
    return getFloatsQuantile(fraction);
  }

  /**
   * Gets the lower bound of the value interval in which the true quantile of the given rank
   * exists with a confidence of at least 99%.
   * @param fraction the given normalized rank as a fraction
   * @return the lower bound of the value interval in which the true quantile of the given rank
   * exists with a confidence of at least 99%. Returns NaN if the sketch is empty.
   */
  public float getQuantileLowerBound(final double fraction) {
    return getQuantile(max(0, fraction - KllHelper.getNormalizedRankError(getMinK(), false)));
  }

  /**
   * This is a more efficient multiple-query version of getQuantile().
   *
   * <p>This returns an array that could have been generated by using getQuantile() with many
   * different fractional ranks, but would be very inefficient.
   * This method incurs the internal set-up overhead once and obtains multiple quantile values in
   * a single query. It is strongly recommend that this method be used instead of multiple calls
   * to getQuantile().
   *
   * <p>If the sketch is empty this returns null.
   *
   * @param fractions given array of fractional positions in the hypothetical sorted stream.
   * These are also called normalized ranks or fractional ranks.
   * These fractions must be in the interval [0.0, 1.0], inclusive.
   *
   * @return array of approximations to the given fractions in the same order as given fractions
   * array.
   */
  public float[] getQuantiles(final double[] fractions) {
    return getFloatsQuantiles(fractions);
  }

  /**
   * This is also a more efficient multiple-query version of getQuantile() and allows the caller to
   * specify the number of evenly spaced fractional ranks.
   *
   * <p>If the sketch is empty this returns null.
   *
   * @param numEvenlySpaced an integer that specifies the number of evenly spaced fractional ranks.
   * This must be a positive integer greater than 0. A value of 1 will return the min value.
   * A value of 2 will return the min and the max value. A value of 3 will return the min,
   * the median and the max value, etc.
   *
   * @return array of approximations to the given fractions in the same order as given fractions
   * array.
   */
  public float[] getQuantiles(final int numEvenlySpaced) {
    if (isEmpty()) { return null; }
    return getQuantiles(org.apache.datasketches.Util.evenlySpaced(0.0, 1.0, numEvenlySpaced));
  }

  /**
   * Gets the upper bound of the value interval in which the true quantile of the given rank
   * exists with a confidence of at least 99%.
   * @param fraction the given normalized rank as a fraction
   * @return the upper bound of the value interval in which the true quantile of the given rank
   * exists with a confidence of at least 99%. Returns NaN if the sketch is empty.
   */
  public float getQuantileUpperBound(final double fraction) {
    return getQuantile(min(1.0, fraction + KllHelper.getNormalizedRankError(getMinK(), false)));
  }

  /**
   * Returns an approximation to the normalized (fractional) rank of the given value from 0 to 1,
   * inclusive.
   *
   * <p>The resulting approximation has a probabilistic guarantee that can be obtained from the
   * getNormalizedRankError(false) function.
   *
   * <p>If the sketch is empty this returns NaN.</p>
   *
   * @param value to be ranked
   * @return an approximate rank of the given value
   */
  public double getRank(final float value) {
    return getFloatRank(value);
  }

  /**
   * @return the iterator for this class
   */
  public KllFloatsSketchIterator iterator() {
    return new KllFloatsSketchIterator(getFloatItemsArray(), getLevelsArray(), getNumLevels());
  }

  /**
   * Merges another sketch into this one.
   * @param other sketch to merge into this one
   */
  public void merge(final KllSketch other) {
    if (!other.isDirect()) { kllSketchThrow(SRC_IS_NOT_DIRECT); }
    if (!other.isFloatsSketch()) { kllSketchThrow(SRC_IS_NOT_FLOAT); }
    mergeFloatImpl(other);
  }

  @Override
  public byte[] toByteArray() {
    return toCompactByteArrayImpl();
  }

  @Override
  public String toString(final boolean withLevels, final boolean withData) {
    return toStringImpl(withLevels, withData);
  }

  /**
   * Updates this sketch with the given data item.
   *
   * @param value an item from a stream of items. NaNs are ignored.
   */
  public void update(final float value) {
    updateFloat(value);
  }

  @Override
  double[] getDoubleItemsArray() { kllSketchThrow(MUST_NOT_CALL); return null; }

  @Override
  double getDoubleItemsArrayAt(final int index) { kllSketchThrow(MUST_NOT_CALL); return Double.NaN; }

  @Override
  float[] getFloatItemsArray() {
    final int items = getItemsArrLengthItems();
    final float[] itemsArr = new float[items];
    itemsArrUpdatable.getFloatArray(0, itemsArr, 0, items);
    return itemsArr;
  }

  @Override
  float getFloatItemsArrayAt(final int index) {
    return itemsArrUpdatable.getFloat((long)index * Float.BYTES);
  }

  @Override
  double getMaxDoubleValue() { kllSketchThrow(MUST_NOT_CALL); return Double.NaN; }

  @Override
  float getMaxFloatValue() {
    return minMaxArrUpdatable.getFloat(Float.BYTES);
  }

  @Override
  double getMinDoubleValue() { kllSketchThrow(MUST_NOT_CALL); return Double.NaN; }

  @Override
  float getMinFloatValue() {
    return minMaxArrUpdatable.getFloat(0);
  }

  @Override
  void setDoubleItemsArray(final double[] doubleItems) { kllSketchThrow(MUST_NOT_CALL); }

  @Override
  void setDoubleItemsArrayAt(final int index, final double value) { kllSketchThrow(MUST_NOT_CALL); }

  @Override
  void setFloatItemsArray(final float[] floatItems) {
    if (!updatable) { kllSketchThrow(TGT_IS_IMMUTABLE); }
    itemsArrUpdatable.putFloatArray(0, floatItems, 0, floatItems.length);
  }

  @Override
  void setFloatItemsArrayAt(final int index, final float value) {
    itemsArrUpdatable.putFloat((long)index * Float.BYTES, value);
  }

  @Override
  void setMaxDoubleValue(final double value) { kllSketchThrow(MUST_NOT_CALL); }

  @Override
  void setMaxFloatValue(final float value) {
    if (!updatable) { kllSketchThrow(TGT_IS_IMMUTABLE); }
    minMaxArrUpdatable.putFloat(Float.BYTES, value);
  }

  @Override
  void setMinDoubleValue(final double value) { kllSketchThrow(MUST_NOT_CALL); }

  @Override
  void setMinFloatValue(final float value) {
    if (!updatable) { kllSketchThrow(TGT_IS_IMMUTABLE); }
    minMaxArrUpdatable.putFloat(0, value);
  }

}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one
3	* or more contributor license agreements. See the NOTICE file
4	* distributed with this work for additional information
5	* regarding copyright ownership. The ASF licenses this file
6	* to you under the Apache License, Version 2.0 (the
7	* "License"); you may not use this file except in compliance
8	* with the License. You may obtain a copy of the License at
9	*
10	* http://www.apache.org/licenses/LICENSE-2.0
11	*
12	* Unless required by applicable law or agreed to in writing,
13	* software distributed under the License is distributed on an
14	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15	* KIND, either express or implied. See the License for the
16	* specific language governing permissions and limitations
17	* under the License.
18	*/
19
20	package org.apache.datasketches.kll;
21
22	import static java.lang.Math.max;
23	import static java.lang.Math.min;
24	import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_FLOAT;
25	import static org.apache.datasketches.kll.KllPreambleUtil.DEFAULT_M;
26	import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_FLOAT;
27	import static org.apache.datasketches.kll.KllPreambleUtil.SERIAL_VERSION_UPDATABLE;
28	import static org.apache.datasketches.kll.KllPreambleUtil.UPDATABLE_BIT_MASK;
29	import static org.apache.datasketches.kll.KllPreambleUtil.insertMinK;
30	import static org.apache.datasketches.kll.KllPreambleUtil.insertFamilyID;
31	import static org.apache.datasketches.kll.KllPreambleUtil.insertFlags;
32	import static org.apache.datasketches.kll.KllPreambleUtil.insertK;
33	import static org.apache.datasketches.kll.KllPreambleUtil.insertM;
34	import static org.apache.datasketches.kll.KllPreambleUtil.insertN;
35	import static org.apache.datasketches.kll.KllPreambleUtil.insertNumLevels;
36	import static org.apache.datasketches.kll.KllPreambleUtil.insertPreInts;
37	import static org.apache.datasketches.kll.KllPreambleUtil.insertSerVer;
38	import static org.apache.datasketches.kll.KllSketch.Error.MUST_NOT_CALL;
39	import static org.apache.datasketches.kll.KllSketch.Error.SRC_IS_NOT_DIRECT;
40	import static org.apache.datasketches.kll.KllSketch.Error.SRC_IS_NOT_FLOAT;
41	import static org.apache.datasketches.kll.KllSketch.Error.TGT_IS_IMMUTABLE;
42
43	import org.apache.datasketches.Family;
44	import org.apache.datasketches.memory.MemoryRequestServer;
45	import org.apache.datasketches.memory.WritableMemory;
46
47	//Intentional extra blank line so the code lines up with KllDirectDoublesSketch
48	/**
49	* This class implements an off-heap floats KllSketch via a WritableMemory instance of the sketch.
50	*
51	* <p>Please refer to the documentation in the package-info:<br>
52	* {@link org.apache.datasketches.kll}</p>
53	*
54	* @author Lee Rhodes, Kevin Lang
55	*/
56	public final class KllDirectFloatsSketch extends KllDirectSketch {
57
58	/**
59	* The actual constructor
60	* @param wmem the current WritableMemory
61	* @param memReqSvr the given MemoryRequestServer to request a larger WritableMemory
62	* @param memVal the MemoryValadate object
63	*/
64	private KllDirectFloatsSketch(final WritableMemory wmem, final MemoryRequestServer memReqSvr,
65	final KllMemoryValidate memVal) {
66	super(SketchType.FLOATS_SKETCH, wmem, memReqSvr, memVal);	1✔
67	}	1✔
68
69	/**
70	* Wrap a sketch around the given source Memory containing sketch data that originated from
71	* this sketch.
72	* @param srcMem a WritableMemory that contains data.
73	* @param memReqSvr the given MemoryRequestServer to request a larger WritableMemory
74	* @return instance of this sketch
75	*/
76	public static KllDirectFloatsSketch writableWrap(final WritableMemory srcMem, final MemoryRequestServer memReqSvr) {
77	final KllMemoryValidate memVal = new KllMemoryValidate(srcMem);	1✔
78	return new KllDirectFloatsSketch(srcMem, memReqSvr, memVal);	1✔
79	}
80
81	/**
82	* Create a new instance of this sketch using the default <i>m</i> of 8.
83	* @param k parameter that controls size of the sketch and accuracy of estimates
84	* @param dstMem the given destination WritableMemory object for use by the sketch
85	* @param memReqSvr the given MemoryRequestServer to request a larger WritableMemory
86	* @return a new instance of this sketch
87	*/
88	public static KllDirectFloatsSketch newInstance(final int k, final WritableMemory dstMem,
89	final MemoryRequestServer memReqSvr) {
90	return newInstance(k, DEFAULT_M, dstMem, memReqSvr);	1✔
91	}
92
93	/**
94	* Create a new instance of this sketch.
95	* @param k parameter that controls size of the sketch and accuracy of estimates
96	* @param m parameter that controls the minimum level width.
97	* @param dstMem the given destination WritableMemory object for use by the sketch
98	* @param memReqSvr the given MemoryRequestServer to request a larger WritableMemory
99	* @return a new instance of this sketch
100	*/
101	static KllDirectFloatsSketch newInstance(final int k, final int m, final WritableMemory dstMem,
102	final MemoryRequestServer memReqSvr) {
103	insertPreInts(dstMem, PREAMBLE_INTS_FLOAT);	1✔
104	insertSerVer(dstMem, SERIAL_VERSION_UPDATABLE);	1✔
105	insertFamilyID(dstMem, Family.KLL.getID());	1✔
106	insertFlags(dstMem, UPDATABLE_BIT_MASK);	1✔
107	insertK(dstMem, k);	1✔
108	insertM(dstMem, m);	1✔
109	insertN(dstMem, 0);	1✔
110	insertMinK(dstMem, k);	1✔
111	insertNumLevels(dstMem, 1);	1✔
112	int offset = DATA_START_ADR_FLOAT;	1✔
113	dstMem.putIntArray(offset, new int[] {k, k}, 0, 2);	1✔
114	offset += 2 * Integer.BYTES;	1✔
115	dstMem.putFloatArray(offset, new float[] {Float.NaN, Float.NaN}, 0, 2);	1✔
116	offset += 2 * Float.BYTES;	1✔
117	dstMem.putFloatArray(offset, new float[k], 0, k);	1✔
118	final KllMemoryValidate memVal = new KllMemoryValidate(dstMem);	1✔
119	return new KllDirectFloatsSketch(dstMem, memReqSvr, memVal);	1✔
120	}
121
122	/**
123	* Returns an approximation to the Cumulative Distribution Function (CDF), which is the
124	* cumulative analog of the PMF, of the input stream given a set of splitPoint (values).
125	*
126	* <p>The resulting approximations have a probabilistic guarantee that can be obtained from the
127	* getNormalizedRankError(false) function.
128	*
129	* <p>If the sketch is empty this returns null.</p>
130	*
131	* @param splitPoints an array of <i>m</i> unique, monotonically increasing float values
132	* that divide the real number line into <i>m+1</i> consecutive disjoint intervals.
133	* The definition of an "interval" is inclusive of the left splitPoint (or minimum value) and
134	* exclusive of the right splitPoint, with the exception that the last interval will include
135	* the maximum value.
136	* It is not necessary to include either the min or max values in these split points.
137	*
138	* @return an array of m+1 double values on the interval [0.0, 1.0),
139	* which are a consecutive approximation to the CDF of the input stream given the splitPoints.
140	* The value at array position j of the returned CDF array is the sum of the returned values
141	* in positions 0 through j of the returned PMF array.
142	*/
143	public double[] getCDF(final float[] splitPoints) {
144	return getFloatsPmfOrCdf(splitPoints, true);	1✔
145	}
146
147	/**
148	* Returns the max value of the stream.
149	* If the sketch is empty this returns NaN.
150	*
151	* @return the max value of the stream
152	*/
153	public float getMaxValue() {
154	return getMaxFloatValue();	1✔
155	}
156
157	/**
158	* Returns the min value of the stream.
159	* If the sketch is empty this returns NaN.
160	*
161	* @return the min value of the stream
162	*/
163	public float getMinValue() {
164	return getMinFloatValue();	1✔
165	}
166
167	/**
168	* Returns an approximation to the Probability Mass Function (PMF) of the input stream
169	* given a set of splitPoints (values).
170	*
171	* <p>The resulting approximations have a probabilistic guarantee that can be obtained from the
172	* getNormalizedRankError(true) function.
173	*
174	* <p>If the sketch is empty this returns null.</p>
175	*
176	* @param splitPoints an array of <i>m</i> unique, monotonically increasing float values
177	* that divide the real number line into <i>m+1</i> consecutive disjoint intervals.
178	* The definition of an "interval" is inclusive of the left splitPoint (or minimum value) and
179	* exclusive of the right splitPoint, with the exception that the last interval will include
180	* the maximum value.
181	* It is not necessary to include either the min or max values in these split points.
182	*
183	* @return an array of m+1 doubles on the interval [0.0, 1.0),
184	* each of which is an approximation to the fraction of the total input stream values
185	* (the mass) that fall into one of those intervals.
186	* The definition of an "interval" is inclusive of the left splitPoint and exclusive of the right
187	* splitPoint, with the exception that the last interval will include maximum value.
188	*/
189	public double[] getPMF(final float[] splitPoints) {
190	return getFloatsPmfOrCdf(splitPoints, false);	1✔
191	}
192
193	/**
194	* Returns an approximation to the value of the data item
195	* that would be preceded by the given fraction of a hypothetical sorted
196	* version of the input stream so far.
197	*
198	* <p>We note that this method has a fairly large overhead (microseconds instead of nanoseconds)
199	* so it should not be called multiple times to get different quantiles from the same
200	* sketch. Instead use getQuantiles(), which pays the overhead only once.
201	*
202	* <p>If the sketch is empty this returns NaN.
203	*
204	* @param fraction the specified fractional position in the hypothetical sorted stream.
205	* These are also called normalized ranks or fractional ranks.
206	* If fraction = 0.0, the true minimum value of the stream is returned.
207	* If fraction = 1.0, the true maximum value of the stream is returned.
208	*
209	* @return the approximation to the value at the given fraction
210	*/
211	public float getQuantile(final double fraction) {
212	return getFloatsQuantile(fraction);	1✔
213	}
214
215	/**
216	* Gets the lower bound of the value interval in which the true quantile of the given rank
217	* exists with a confidence of at least 99%.
218	* @param fraction the given normalized rank as a fraction
219	* @return the lower bound of the value interval in which the true quantile of the given rank
220	* exists with a confidence of at least 99%. Returns NaN if the sketch is empty.
221	*/
222	public float getQuantileLowerBound(final double fraction) {
223	return getQuantile(max(0, fraction - KllHelper.getNormalizedRankError(getMinK(), false)));	1✔
224	}
225
226	/**
227	* This is a more efficient multiple-query version of getQuantile().
228	*
229	* <p>This returns an array that could have been generated by using getQuantile() with many
230	* different fractional ranks, but would be very inefficient.
231	* This method incurs the internal set-up overhead once and obtains multiple quantile values in
232	* a single query. It is strongly recommend that this method be used instead of multiple calls
233	* to getQuantile().
234	*
235	* <p>If the sketch is empty this returns null.
236	*
237	* @param fractions given array of fractional positions in the hypothetical sorted stream.
238	* These are also called normalized ranks or fractional ranks.
239	* These fractions must be in the interval [0.0, 1.0], inclusive.
240	*
241	* @return array of approximations to the given fractions in the same order as given fractions
242	* array.
243	*/
244	public float[] getQuantiles(final double[] fractions) {
245	return getFloatsQuantiles(fractions);	1✔
246	}
247
248	/**
249	* This is also a more efficient multiple-query version of getQuantile() and allows the caller to
250	* specify the number of evenly spaced fractional ranks.
251	*
252	* <p>If the sketch is empty this returns null.
253	*
254	* @param numEvenlySpaced an integer that specifies the number of evenly spaced fractional ranks.
255	* This must be a positive integer greater than 0. A value of 1 will return the min value.
256	* A value of 2 will return the min and the max value. A value of 3 will return the min,
257	* the median and the max value, etc.
258	*
259	* @return array of approximations to the given fractions in the same order as given fractions
260	* array.
261	*/
262	public float[] getQuantiles(final int numEvenlySpaced) {
263	if (isEmpty()) { return null; }	1✔
264	return getQuantiles(org.apache.datasketches.Util.evenlySpaced(0.0, 1.0, numEvenlySpaced));	1✔
265	}
266
267	/**
268	* Gets the upper bound of the value interval in which the true quantile of the given rank
269	* exists with a confidence of at least 99%.
270	* @param fraction the given normalized rank as a fraction
271	* @return the upper bound of the value interval in which the true quantile of the given rank
272	* exists with a confidence of at least 99%. Returns NaN if the sketch is empty.
273	*/
274	public float getQuantileUpperBound(final double fraction) {
275	return getQuantile(min(1.0, fraction + KllHelper.getNormalizedRankError(getMinK(), false)));	1✔
276	}
277
278	/**
279	* Returns an approximation to the normalized (fractional) rank of the given value from 0 to 1,
280	* inclusive.
281	*
282	* <p>The resulting approximation has a probabilistic guarantee that can be obtained from the
283	* getNormalizedRankError(false) function.
284	*
285	* <p>If the sketch is empty this returns NaN.</p>
286	*
287	* @param value to be ranked
288	* @return an approximate rank of the given value
289	*/
290	public double getRank(final float value) {
291	return getFloatRank(value);	1✔
292	}
293
294	/**
295	* @return the iterator for this class
296	*/
297	public KllFloatsSketchIterator iterator() {
298	return new KllFloatsSketchIterator(getFloatItemsArray(), getLevelsArray(), getNumLevels());	1✔
299	}
300
301	/**
302	* Merges another sketch into this one.
303	* @param other sketch to merge into this one
304	*/
305	public void merge(final KllSketch other) {
306	if (!other.isDirect()) { kllSketchThrow(SRC_IS_NOT_DIRECT); }	1✔
307	if (!other.isFloatsSketch()) { kllSketchThrow(SRC_IS_NOT_FLOAT); }	1✔
308	mergeFloatImpl(other);	1✔
309	}	1✔
310
311	@Override
312	public byte[] toByteArray() {
313	return toCompactByteArrayImpl();	1✔
314	}
315
316	@Override
317	public String toString(final boolean withLevels, final boolean withData) {
318	return toStringImpl(withLevels, withData);	1✔
319	}
320
321	/**
322	* Updates this sketch with the given data item.
323	*
324	* @param value an item from a stream of items. NaNs are ignored.
325	*/
326	public void update(final float value) {
327	updateFloat(value);	1✔
328	}	1✔
329
330	@Override
331	double[] getDoubleItemsArray() { kllSketchThrow(MUST_NOT_CALL); return null; }	×
332
333	@Override
334	double getDoubleItemsArrayAt(final int index) { kllSketchThrow(MUST_NOT_CALL); return Double.NaN; }	×
335
336	@Override
337	float[] getFloatItemsArray() {
338	final int items = getItemsArrLengthItems();	1✔
339	final float[] itemsArr = new float[items];	1✔
340	itemsArrUpdatable.getFloatArray(0, itemsArr, 0, items);	1✔
341	return itemsArr;	1✔
342	}
343
344	@Override
345	float getFloatItemsArrayAt(final int index) {
346	return itemsArrUpdatable.getFloat((long)index * Float.BYTES);	1✔
347	}
348
349	@Override
350	double getMaxDoubleValue() { kllSketchThrow(MUST_NOT_CALL); return Double.NaN; }	×
351
352	@Override
353	float getMaxFloatValue() {
354	return minMaxArrUpdatable.getFloat(Float.BYTES);	1✔
355	}
356
357	@Override
358	double getMinDoubleValue() { kllSketchThrow(MUST_NOT_CALL); return Double.NaN; }	×
359
360	@Override
361	float getMinFloatValue() {
362	return minMaxArrUpdatable.getFloat(0);	1✔
363	}
364
365	@Override
366	void setDoubleItemsArray(final double[] doubleItems) { kllSketchThrow(MUST_NOT_CALL); }	×
367
368	@Override
369	void setDoubleItemsArrayAt(final int index, final double value) { kllSketchThrow(MUST_NOT_CALL); }	×
370
371	@Override
372	void setFloatItemsArray(final float[] floatItems) {
373	if (!updatable) { kllSketchThrow(TGT_IS_IMMUTABLE); }
374	itemsArrUpdatable.putFloatArray(0, floatItems, 0, floatItems.length);	1✔
375	}	1✔
376
377	@Override
378	void setFloatItemsArrayAt(final int index, final float value) {
379	itemsArrUpdatable.putFloat((long)index * Float.BYTES, value);	1✔
380	}	1✔
381
382	@Override
383	void setMaxDoubleValue(final double value) { kllSketchThrow(MUST_NOT_CALL); }	×
384
385	@Override
386	void setMaxFloatValue(final float value) {
387	if (!updatable) { kllSketchThrow(TGT_IS_IMMUTABLE); }
388	minMaxArrUpdatable.putFloat(Float.BYTES, value);	1✔
389	}	1✔
390
391	@Override
392	void setMinDoubleValue(final double value) { kllSketchThrow(MUST_NOT_CALL); }	×
393
394	@Override
395	void setMinFloatValue(final float value) {
396	if (!updatable) { kllSketchThrow(TGT_IS_IMMUTABLE); }
397	minMaxArrUpdatable.putFloat(0, value);	1✔
398	}	1✔
399
400	}

apache / datasketches-java / #190

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous