This is an automated email from the ASF dual-hosted git repository.
git-site-role pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/datasketches-website.git
The following commit(s) were added to refs/heads/asf-site by this push:
new 4d1d8c68 Automatic Site Publish by Buildbot
4d1d8c68 is described below
commit 4d1d8c68ff134e5d072e38af0a988a4c0668f4ae
Author: buildbot <[email protected]>
AuthorDate: Mon May 2 19:10:30 2022 +0000
Automatic Site Publish by Buildbot
---
output/docs/Architecture/MajorSketchFamilies.html | 4 ++--
output/docs/KLL/KLLSketch.html | 22 +++++++++++-----------
2 files changed, 13 insertions(+), 13 deletions(-)
diff --git a/output/docs/Architecture/MajorSketchFamilies.html
b/output/docs/Architecture/MajorSketchFamilies.html
index 412f16e8..3499b02c 100644
--- a/output/docs/Architecture/MajorSketchFamilies.html
+++ b/output/docs/Architecture/MajorSketchFamilies.html
@@ -558,9 +558,9 @@ However, if an approximate answer to these problems is
acceptable, <a href="/doc
<p>There are two different families of quantiles sketches, the original <a
href="https://github.com/apache/datasketches-java/blob/master/src/main/java/org/apache/datasketches/quantiles/DoublesSketch.java";>quantiles/DoublesSketch</a>,
which can be operated either on-heap or off-heap, and is also available in a
Java Generic form for arbitrary comparable objects.</p>
-<p>Later we developed the <a
href="https://github.com/apache/datasketches-java/blob/master/src/main/java/org/apache/datasketches/kll/KllFloatsSketch.java";>kll/KllFloatsSketch</a>
(Named after its authors), which is also a quantiles sketch, that achieves
near optimal small size for a given accuracy.</p>
+<p>Later we developed the <a
href="https://datasketches.apache.org/docs/KLL/KLLSketch.html";>kll/KllSketch</a>
(Named after its authors), which is also a quantiles sketch, that achieves
near optimal small size for a given accuracy.</p>
-<p>The most recent sketch in this group is called the Relative Error Quantiles
sketch, which is a cousin of the KLL sketch except that it provides very high
accuracy at one of the ends of the rank domain. If your application requires
high accuracy primarily for the very high ranks, e.g., the 99.999%ile, or the
very low ranks, e.g. the .00001%ile, and you can give up some accuracy at the
other end of the rank scale, this sketch is designed for you.</p>
+<p>The most recent sketch in this group is called the Relative Error Quantiles
<a
href="https://datasketches.apache.org/docs/REQ/ReqSketch.html";>ReqSketch</a>,
which is a cousin of the KLL sketch except that it provides very high accuracy
at one of the ends of the rank domain. If your application requires high
accuracy primarily for the very high ranks, e.g., the 99.999%ile, or the very
low ranks, e.g. the .00001%ile, and you can give up some accuracy at the other
end of the rank scale, [...]
<h2 id="frequent-items--heavy-hitters-sketches">Frequent Items / Heavy Hitters
Sketches</h2>
diff --git a/output/docs/KLL/KLLSketch.html b/output/docs/KLL/KLLSketch.html
index f30cdb53..52b3e98b 100644
--- a/output/docs/KLL/KLLSketch.html
+++ b/output/docs/KLL/KLLSketch.html
@@ -508,21 +508,21 @@
specific language governing permissions and limitations
under the License.
-->
-<h2 id="kll-sketch">KLL sketch</h2>
+<h2 id="kll-sketch">KLL Sketch</h2>
<p>Implementation of a very compact quantiles sketch with lazy compaction
scheme and nearly optimal accuracy per bit.
-See <a href="https://arxiv.org/abs/1603.05346v2";>this paper</a>.
+See <a href="https://arxiv.org/abs/1603.05346v2";>Optimal Quantile
Approximation in Streams, by Zohar Karnin, Kevin Lang, Edo Liberty</a>.
The name KLL is composed of the initial letters of the last names of the
authors.</p>
-<p>The usage of KllFloatsSketch is very similar to DoublesSketch. Because the
key feature of this sketch is compactness, it was implemented with float values
instead of double values.
+<p>The usage of KllSketch is very similar to DoublesSketch. The key feature of
this sketch is its compactness for a given accuracy. It is implemented with
both float and double values and can be configured for use on-heap or off-heap
(Direct mode).
The parameter K that affects the accuracy and the size of the sketch is not
restricted to powers of 2.
-The default of 200 was chosen to yield approximately the same normalized rank
error (1.65%) as the default DoublesSketch (K=128, error 1.73%).</p>
+The default of 200 was chosen to yield approximately the same normalized rank
error (1.65%) as the original DoublesSketch (K=128, error 1.73%).</p>
<h3 id="java-example">Java example</h3>
<div class="highlighter-rouge"><div class="highlight"><pre
class="highlight"><code>import org.apache.datasketches.kll.KllFloatsSketch;
-KllFloatsSketch sketch = new KllFloatsSketch();
+KllFloatsSketch sketch = KllFloatsSketch.newHeapInstance();
int n = 1000000;
for (int i = 0; i < n; i++) {
sketch.update(i);
@@ -531,27 +531,27 @@ float median = sketch.getQuantile(0.5);
double rankOf1000 = sketch.getRank(1000);
</code></pre></div></div>
-<h3 id="differences-of-kllfloatssketch-from-doublessketch">Differences of
KllFloatsSketch from DoublesSketch</h3>
+<h3
id="differences-of-kllsketch-from-the-original-quantiles-doublessketch">Differences
of KllSketch from the original quantiles DoublesSketch</h3>
<ul>
<li>KLL has a smaller size for the same accuracy</li>
<li>KLL is slightly faster to update</li>
<li>The KLL parameter K doesn’t have to be power of 2</li>
- <li>KLL operates with float values instead of double values</li>
+ <li>KLL operates with either float values or double values</li>
<li>KLL uses a merge method rather than a union object</li>
- <li>KLL does not offer direct, off-heap implementation</li>
- <li>KLL does not have separate updatable and compact forms</li>
</ul>
<p>The starting point for the comparison is setting K in such a way that rank
error would be approximately the same. As pointed out above, the default K for
both sketches should achieve this. Here is the comparison of the single-sided
normalized rank error (getRank() method) for the default K:</p>
<p><img class="doc-img-full"
src="/docs/img/kll/kll200-vs-ds128-rank-error.png" alt="RankError" /></p>
-<p>DoublesSketch has two forms with different serialized sizes:
UpdateDoublesSketch and CompactDoublesSketch. KllFloatsSketch has no such
distinction. It is always serialized in a compact form, and it is not much
bigger than that in memory. Here is the comparison of serialized sizes:</p>
+<p>DoublesSketch has two forms with different serialized sizes:
UpdateDoublesSketch and CompactDoublesSketch. The KLL sketches makes this
distinction differently. When the KllSketch is serialized using
<em>toByteArray()</em> it is always in a compact form and immutable. When the
KllSketch is on-heap it is always updatable. It can be created off-heap using
the static factory method <em>newDirectInstance(…)</em> method, which is also
updatable. It is possible to move from off-heap (Direct) [...]
+
+<p>Here is the comparison of serialized sizes:</p>
<p><img class="doc-img-full" src="/docs/img/kll/kll200-vs-ds128-size.png"
alt="SerializedSize" /></p>
-<p>Some part of the size difference above is due to using items of float type
as opposed to double type. Here is the comparison of the number of retained
items to see the difference with no influence of the size of the item type:</p>
+<p>Here is the comparison of the number of retained items to see the
difference with no influence of the size of the item type:</p>
<p><img class="doc-img-full" src="/docs/img/kll/kll200-vs-ds128-items.png"
alt="NumberOfRetainedItems" /></p>
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
