From d5c651e04ad2e25141424a749dd1a95a052c9b5f Mon Sep 17 00:00:00 2001 From: Elouen Ginat Date: Tue, 23 Jun 2026 13:41:56 +0200 Subject: [PATCH 1/7] fix: remove API comparison card in doc index --- docs/demo.ipynb | 28 ++++++++++++++-------------- docs/index.rst | 12 +----------- 2 files changed, 15 insertions(+), 25 deletions(-) diff --git a/docs/demo.ipynb b/docs/demo.ipynb index c3255ae..6fd1d15 100644 --- a/docs/demo.ipynb +++ b/docs/demo.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "e24a8a4b", "metadata": {}, "outputs": [ @@ -61,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "56410772", "metadata": {}, "outputs": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "1b7d0305", "metadata": {}, "outputs": [ @@ -141,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "2749c664", "metadata": {}, "outputs": [ @@ -165,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "1cca2392", "metadata": {}, "outputs": [ @@ -187,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "2ad6d7e5", "metadata": {}, "outputs": [ @@ -220,7 +220,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "id": "b6c4ea8c", "metadata": {}, "outputs": [ @@ -258,7 +258,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "6c89bf07", "metadata": {}, "outputs": [ @@ -285,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "id": "25d8d0e5", "metadata": {}, "outputs": [ @@ -322,7 +322,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "id": "d985437b", "metadata": {}, "outputs": [ @@ -406,7 +406,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "id": "51179a02", "metadata": {}, "outputs": [ @@ -440,7 +440,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "id": "e9bbabc9", "metadata": {}, "outputs": [ @@ -477,7 +477,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "id": "1190f8aa", "metadata": {}, "outputs": [ @@ -518,7 +518,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "id": "bf2ba150", "metadata": {}, "outputs": [ diff --git a/docs/index.rst b/docs/index.rst index b1bb828..1a4c8b2 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -43,7 +43,7 @@ Get started data = np.random.normal(0, 1, 10_000) hist, bin_edges = histogram(data) # optimal bins, no guessing -.. grid:: 1 1 3 3 +.. grid:: 1 1 2 2 :gutter: 3 :class-container: sd-mt-3 @@ -68,16 +68,6 @@ Get started ``compute_histograms`` exposes every granularity level so you can pick the resolution that suits your analysis. -.. grid:: 1 1 2 2 - :gutter: 3 - :class-container: sd-mt-1 - - .. grid-item-card:: :octicon:`git-compare;1.5em` API comparison - :link: api_comparison - :link-type: doc - - Side-by-side parameter tables for NumPy, Matplotlib, and Khisto. - .. grid-item-card:: :octicon:`play;1.5em` Interactive demo :link: demo :link-type: doc From ff6226428cb8783df07f400cacc853a0c219695b Mon Sep 17 00:00:00 2001 From: Elouen Ginat Date: Tue, 23 Jun 2026 14:57:55 +0200 Subject: [PATCH 2/7] doc(readme): more conscise readme --- README.md | 99 +------------------------------------------------------ 1 file changed, 1 insertion(+), 98 deletions(-) diff --git a/README.md b/README.md index 46a6cda..2e342ce 100644 --- a/README.md +++ b/README.md @@ -10,28 +10,7 @@ Khisto is a Python library for creating histograms using the **Khiops optimal binning algorithm**. Unlike standard histograms that use fixed-width bins or simple heuristics, Khisto automatically determines the optimal number of bins and their variable widths to best represent the underlying data distribution. -## Features - -- **Optimal Binning**: Uses the MODL (Minimum Description Length) principle to find the best discretization. -- **Variable-Width Bins**: Captures dense regions with fine bins and sparse regions with wider bins. -- **NumPy Compatible**: Drop-in replacement for `numpy.histogram`. -- **Matplotlib Integration**: `khisto.matplotlib.hist` works like `plt.hist`. -- **Core Histogram API**: Inspect every available granularity with `khisto.core.compute_histograms` and `HistogramResult`. -- **Minimal Dependencies**: Only requires NumPy (matplotlib optional for plotting). - -| Standard Gaussian | Heavy-tailed Pareto | -| --- | --- | -| ![Adaptive Gaussian histogram](docs/images/gaussian-quick-start.png) | ![Adaptive Pareto histogram](docs/images/pareto-quick-start.png) | - -## Reproducing The Example Distributions - -The complete runnable script is available in `scripts/generate_distribution_examples.py`. - -Run it from the repository root to regenerate both example distributions and the figure files used in this README: - -```bash -python scripts/generate_distribution_examples.py -``` +Documentation is available at **[khiops.github.io/khisto-python](https://khiopsml.github.io/khisto-python/)**. ## Installation @@ -58,74 +37,8 @@ data = np.random.normal(0, 1, 10000) # Compute optimal histogram (drop-in replacement for np.histogram) hist, bin_edges = histogram(data) - -# With density normalization -density, bin_edges = histogram(data, density=True) - -# Limit maximum number of bins -hist, bin_edges = histogram(data, max_bins=10) - -# Specify range -hist, bin_edges = histogram(data, range=(-2, 2)) -``` - -Using 10,000 samples keeps the adaptive refinement visible while remaining fast to compute. - -Heavy-tailed example: - -```python -import numpy as np -import matplotlib.pyplot as plt -from khisto.matplotlib import hist - -# Generate 10,000 samples from a Pareto distribution, shifted to start at 1 for better log-log visualization -shape = 3 -long_tail_data = np.random.pareto(shape, size=10000) + 1 - -# Plot an adaptive histogram on logarithmic axes. -n, bins, patches = hist(long_tail_data, density=True) -plt.xscale("log") -plt.yscale("log") -plt.show() -``` - -### Matplotlib Integration - -```python -import numpy as np -import matplotlib.pyplot as plt -from khisto.matplotlib import hist - -# Generate 10,000 samples from a standard Gaussian distribution. -data = np.random.normal(0, 1, 10000) - -# Density is usually the most interpretable view with variable-width bins. -n, bins, patches = hist(data, density=True) -plt.xlabel('Value') -plt.ylabel('Density') -plt.show() - -# Cumulative density follows matplotlib semantics. -n, bins, patches = hist(data, density=True, cumulative=True) -plt.ylabel('Cumulative probability') -plt.show() ``` -## How It Works - -Khisto uses the Khiops optimal binning algorithm based on the MODL (Minimum Optimal Description Length) principle. Instead of using fixed-width bins like traditional histograms, it: - -1. Analyzes the data distribution -2. Finds bin boundaries that minimize information loss -3. Creates variable-width bins that adapt to data density - -This results in histograms that better represent the underlying distribution, with finer bins in dense regions and wider bins in sparse regions. - -The method implemented in Khiops is comprehensively detailed in [2] and further extended in [1]. - -- [1] M. Boullé. Floating-point histograms for exploratory analysis of large scale real-world data sets. Intelligent Data Analysis, 28(5):1347-1394, 2024 -- [2] V. Zelaya Mendizábal, M. Boullé, F. Rossi. Fast and fully-automated histograms for large-scale data sets. Computational Statistics & Data Analysis, 180:0-0, 2023 - ## Development ```bash @@ -140,16 +53,6 @@ uv sync --group dev --extra all uv run pytest ``` -## Documentation - -Full documentation is hosted at **[khiops.github.io/khisto-python](https://khiops.github.io/khisto-python/)**. - -- [API Reference](https://khiops.github.io/khisto-python/array/histogram/index.html) — NumPy-like histogram API -- [Matplotlib Integration](https://khiops.github.io/khisto-python/matplotlib/index.html) — `hist` plotting function -- [Core API](https://khiops.github.io/khisto-python/core/index.html) — full access to histogram granularity levels -- [API Comparison](https://khiops.github.io/khisto-python/api_comparison.html) — side-by-side with NumPy and Matplotlib -- [Demo Notebook](https://khiops.github.io/khisto-python/demo.html) — interactive walkthrough - ## License [BSD 3-Clause Clear License](LICENSE) From 179391df9febdd55ab3b04c7b188ff806f81bf91 Mon Sep 17 00:00:00 2001 From: Elouen Ginat Date: Fri, 26 Jun 2026 10:09:09 +0200 Subject: [PATCH 3/7] fix: implement alpha test feedback. Make density=True by default for hist. rework hist implmentation to be identical to matplotlib. rework the demo notebook to be simpler. Add better errors in backend. --- README.md | 27 +- docs/demo.ipynb | 609 ++++++++++++------------ docs/index.rst | 2 +- sandbox/khisto_demo.ipynb | 31 +- src/khisto/core/backend.py | 13 +- src/khisto/matplotlib/hist.py | 151 +----- test.py | 26 + tests/plot/test_matplotlib_histogram.py | 4 +- 8 files changed, 388 insertions(+), 475 deletions(-) create mode 100644 test.py diff --git a/README.md b/README.md index 2e342ce..fc3db94 100644 --- a/README.md +++ b/README.md @@ -12,6 +12,10 @@ Khisto is a Python library for creating histograms using the **Khiops optimal bi Documentation is available at **[khiops.github.io/khisto-python](https://khiopsml.github.io/khisto-python/)**. +| Standard Gaussian | Heavy-tailed Pareto | +| --- | --- | +| ![Adaptive Gaussian histogram](docs/images/gaussian-quick-start.png) | ![Adaptive Pareto histogram](docs/images/pareto-quick-start.png) | + ## Installation ```bash @@ -26,17 +30,26 @@ pip install "khisto[matplotlib]" ## Quick Start -### NumPy-like API - ```python import numpy as np -from khisto import histogram +import matplotlib.pyplot as plt +from khisto.matplotlib import hist + +# Generate 10,000 samples from a Pareto distribution +long_tail_data = np.random.pareto(3, size=10000) + +# Plot an adaptive histogram on logarithmic axes. +n, bins, patches = hist(long_tail_data, density=True) +plt.xscale("symlog") +plt.yscale("log") +plt.show() -# Generate 10,000 samples from a standard Gaussian distribution. -data = np.random.normal(0, 1, 10000) +# Generate 10,000 samples from a Normal distribution +normal_data = np.random.normal(size=10000) -# Compute optimal histogram (drop-in replacement for np.histogram) -hist, bin_edges = histogram(data) +# Plot an adaptive histogram +n, bins, patches = hist(normal_data, density=True) +plt.show() ``` ## Development diff --git a/docs/demo.ipynb b/docs/demo.ipynb index 6fd1d15..4eedab5 100644 --- a/docs/demo.ipynb +++ b/docs/demo.ipynb @@ -2,102 +2,126 @@ "cells": [ { "cell_type": "markdown", - "id": "2bc0c481", + "id": "4bc89ce5", "metadata": {}, "source": [ - "# Khisto Demo\n", + "# Khisto — optimal binning histograms\n", "\n", - "A good histogram should reveal structure without asking you to guess the right bin count first.\n", + "A good histogram should reveal the structure of your data without asking you to\n", + "guess the right number of bins first. Khisto chooses the bins for you: it uses\n", + "the **Khiops optimal binning algorithm** (the MODL / Minimum Description Length\n", + "principle) to pick both the number of bins *and* their — possibly unequal —\n", + "widths, so dense regions get fine bins and sparse regions get wide ones.\n", "\n", - "This notebook starts with a deliberately awkward distribution: a sharp spike, a broad shoulder, a long right tail, and a few isolated values. It is the kind of data where fixed-width bins often hide the story, while Khisto stays readable with one call." + "This notebook goes **from the simplest case to a richer one**:\n", + "\n", + "1. **Quick start** — two textbook distributions (a Gaussian and a heavy-tailed\n", + " Pareto), each in a single call.\n", + "2. **A three-component mixture** — a more realistic example used to tour the\n", + " full API.\n", + "\n", + "Throughout, we plot the **density** rather than raw counts. With variable-width\n", + "bins this is almost always the right choice: a tall-but-narrow bin and a\n", + "short-but-wide bin can hold the *same* number of points, so only the density\n", + "(count divided by bin width) shows the true shape of the distribution.\n", + "\n", + "> 📚 For a didactic walk-through of optimal histograms — from the simplest to the\n", + "> most complex — see the\n", + "> [Khiops histograms guide](https://github.com/KhiopsML/khiops-doc/blob/dev/docs/learn/histograms.md).\n" + ] + }, + { + "cell_type": "markdown", + "id": "5c8142b2", + "metadata": {}, + "source": [ + "## 1. Quick start\n", + "\n", + "The simplest promise: one call, sensible bins, a readable density. We start with\n", + "two distributions where the \"right\" binning is well understood, so you can see\n", + "that Khisto does the natural thing." ] }, { "cell_type": "code", - "execution_count": null, - "id": "e24a8a4b", + "execution_count": 1, + "id": "d9b9b33b", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Samples: 1124\n", - "Range: [-3.06, 13.94]\n", - "Story: a sharp left spike, a wide middle mass, and a stretched right tail.\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", - "# Build a deliberately hard distribution: one narrow spike, one broad shoulder,\n", - "# one long right tail, and a few isolated values.\n", - "rng = np.random.default_rng(42)\n", - "data = np.concatenate(\n", - " [\n", - " rng.normal(-2.6, 0.18, 420),\n", - " rng.normal(0.4, 1.05, 520),\n", - " rng.lognormal(mean=1.0, sigma=0.55, size=180) + 1.2,\n", - " np.array([8.5, 9.0, 9.8, 10.5]),\n", - " ]\n", - ")\n", + "from khisto import histogram\n", + "from khisto.matplotlib import hist\n", "\n", - "print(f\"Samples: {data.shape[0]}\")\n", - "print(f\"Range: [{data.min():.2f}, {data.max():.2f}]\")\n", - "print(\"Story: a sharp left spike, a wide middle mass, and a stretched right tail.\")" + "SEED = 42" ] }, { "cell_type": "markdown", - "id": "0859187a", + "id": "1433db45", "metadata": {}, "source": [ - "## 1. NumPy-like API: `khisto.histogram`\n", + "### A standard Gaussian — linear scale\n", "\n", - "Start with the simplest promise: keep the familiar NumPy return value, but let the bins adapt to the data instead of flattening it." + "For a bell curve, a linear axis is the natural view. `khisto.matplotlib.hist`\n", + "works like `plt.hist`, but the bins adapt to the data." ] }, { "cell_type": "code", "execution_count": null, - "id": "56410772", + "id": "9e8eff47", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of bins: 11\n", - "Bin edges: [-3.0625 -2.875 -2.6875 -2.4375 -2.25 -0.8125 0. 0.875 1.9375\n", - " 5.0625 7.375 14. ]\n", - "Frequencies: [ 23. 101. 233. 57. 73. 117. 187. 117. 168. 38. 10.]\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "from khisto import histogram\n", + "gaussian = np.random.default_rng(SEED).normal(0, 1, 10000)\n", "\n", - "# Compute optimal histogram\n", - "hist, bin_edges = histogram(data)\n", + "fig, ax = plt.subplots(figsize=(7, 4.5))\n", + "hist(gaussian, ax=ax, color=\"steelblue\", edgecolor=\"white\", linewidth=0.8)\n", + "ax.set_title(\"Adaptive histogram on a standard Gaussian\")\n", + "ax.set_xlabel(\"Value\")\n", + "ax.set_ylabel(\"Density\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8740f58a", + "metadata": {}, + "source": [ + "### A heavy-tailed Pareto — log-log scale\n", "\n", - "print(f\"Number of bins: {len(hist)}\")\n", - "print(f\"Bin edges: {bin_edges}\")\n", - "print(f\"Frequencies: {hist}\")" + "Heavy-tailed data spans several orders of magnitude, so a **log-log** view is\n", + "the natural one. Fixed-width bins struggle here — they are either too coarse in\n", + "the body or empty in the tail — while adaptive bins stay informative all the way\n", + "out." ] }, { "cell_type": "code", "execution_count": null, - "id": "1b7d0305", + "id": "e8a48420", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -105,195 +129,137 @@ } ], "source": [ - "# Compare fixed-width bins with Khisto using a simple bar plot\n", - "fig, axes = plt.subplots(1, 2, figsize=(13, 4.5), sharey=True)\n", + "pareto = np.random.default_rng(SEED).pareto(3, 10000) + 1.0 # shift to start at 1 for log axes\n", "\n", - "# NumPy histogram (fixed bins)\n", - "np_hist, np_edges = np.histogram(data, bins=20)\n", - "axes[0].bar(\n", - " np_edges[:-1],\n", - " np_hist,\n", - " width=np.diff(np_edges),\n", - " align=\"edge\",\n", - " color=\"#B8C4D6\",\n", - " edgecolor=\"white\",\n", - ")\n", - "axes[0].set_title(\"NumPy: fixed-width bins\")\n", - "axes[0].set_xlabel(\"Value\")\n", - "axes[0].set_ylabel(\"Count\")\n", - "\n", - "# Khisto histogram (adaptive bins)\n", - "axes[1].bar(\n", - " bin_edges[:-1],\n", - " hist,\n", - " width=np.diff(bin_edges),\n", - " align=\"edge\",\n", - " color=\"#F16E00\",\n", - " edgecolor=\"white\",\n", - ")\n", - "axes[1].set_title(f\"Khisto: {len(hist)} adaptive bins\")\n", - "axes[1].set_xlabel(\"Value\")\n", - "\n", - "fig.suptitle(\"Same data, same scale, very different readability\", y=1.03)\n", + "fig, ax = plt.subplots(figsize=(7, 4.5))\n", + "hist(pareto, ax=ax, color=\"darkorange\", edgecolor=\"white\", linewidth=0.8)\n", + "ax.set_xscale(\"log\")\n", + "ax.set_yscale(\"log\")\n", + "ax.set_title(\"Adaptive histogram on a heavy-tailed Pareto law\")\n", + "ax.set_xlabel(\"Value\")\n", + "ax.set_ylabel(\"Density\")\n", "plt.tight_layout()\n", "plt.show()" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "2749c664", + "cell_type": "markdown", + "id": "b4736e89", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Integral of density: 1.000000\n" - ] - } - ], "source": [ - "# With density normalization\n", - "density, bin_edges = histogram(data, density=True)\n", + "## 2. A richer example — a three-component mixture\n", "\n", - "# Verify normalization (integral should be ~1)\n", - "widths = np.diff(bin_edges)\n", - "integral = np.sum(density * widths)\n", - "print(f\"Integral of density: {integral:.6f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1cca2392", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Limited to max 5 bins: got 4 bins\n", - "Bin edges: [-3.0625 0. 4. 8. 14. ]\n" - ] - } - ], - "source": [ - "# With max_bins limit\n", - "hist_limited, edges_limited = histogram(data, max_bins=5)\n", - "print(f\"Limited to max 5 bins: got {len(hist_limited)} bins\")\n", - "print(f\"Bin edges: {edges_limited}\")" + "To exercise the rest of the API we use a more realistic distribution that mixes\n", + "three components:\n", + "\n", + "- a **standard Gaussian** (broad central mass),\n", + "- a **narrow, peaked Gaussian** (a sharp mode), and\n", + "- a **lognormal** (a stretched right tail).\n", + "\n", + "10,000 samples keep the adaptive refinement visible while staying fast to\n", + "compute. This single `data` array is reused for every example below." ] }, { "cell_type": "code", - "execution_count": null, - "id": "2ad6d7e5", + "execution_count": 4, + "id": "8b183e7b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Range [-3, 3]: 9 bins\n", - "Bin edges: [-3. -2.875 -2.6875 -2.4375 -2.25 -0.8125 0. 0.875 1.625\n", - " 3. ]\n" + "Samples: 10000\n", + "Range: [-3.65, 56.03]\n", + "Shape: a broad bell, a sharp spike near 3, and a long lognormal tail.\n" ] } ], "source": [ - "# With range specification\n", - "hist_range, edges_range = histogram(data, range=(-3, 3))\n", - "print(f\"Range [-3, 3]: {len(hist_range)} bins\")\n", - "print(f\"Bin edges: {edges_range}\")" + "rng = np.random.default_rng(SEED)\n", + "data = np.concatenate([\n", + " rng.normal(0, 1, 5000), # standard Gaussian\n", + " rng.normal(3, 0.25, 2000), # narrow, peaked Gaussian\n", + " rng.lognormal(mean=0, sigma=1, size=3000), # lognormal right tail\n", + "])\n", + "\n", + "print(f\"Samples: {data.shape[0]}\")\n", + "print(f\"Range: [{data.min():.2f}, {data.max():.2f}]\")\n", + "print(\"Shape: a broad bell, a sharp spike near 3, and a long lognormal tail.\")" ] }, { "cell_type": "markdown", - "id": "1eba79b4", + "id": "3c14f255", "metadata": {}, "source": [ - "## 2. Matplotlib API: `khisto.matplotlib.hist`\n", + "### Adaptive vs fixed-width bins — linear scale\n", "\n", - "Once the bins are right, plotting should stay effortless. `khisto.matplotlib.hist` keeps the familiar matplotlib workflow and makes the hard distribution readable in one line." + "The same data, the same density normalization, the same axes — only the binning\n", + "differs. Fixed-width bins blur the sharp mode and waste resolution on the empty\n", + "tail; Khisto's adaptive bins keep both readable." ] }, { "cell_type": "code", - "execution_count": null, - "id": "b6c4ea8c", + "execution_count": 21, + "id": "c8ed6f75", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Returned 11 bin values\n" - ] } ], "source": [ - "from khisto.matplotlib import hist\n", + "fig, axes = plt.subplots(1, 2, figsize=(13, 4.5), sharey=True)\n", "\n", - "# Basic histogram plot\n", - "fig, ax = plt.subplots(figsize=(8, 5))\n", - "n, bins, patches = hist(data, ax=ax)\n", - "ax.set_xlabel(\"Value\")\n", - "ax.set_ylabel(\"Count\")\n", - "ax.set_title(\"Optimal Histogram\")\n", - "plt.show()\n", + "# Matplotlib / NumPy: fixed-width bins (density)\n", + "axes[0].hist(data, bins=60, density=True, color=\"silver\", edgecolor=\"white\")\n", + "axes[0].set_title(\"Fixed-width bins (60)\")\n", + "axes[0].set_xlabel(\"Value\")\n", + "axes[0].set_ylabel(\"Density\")\n", + "\n", + "# Khisto: adaptive bins (density)\n", + "hist(data, ax=axes[1], color=\"steelblue\", edgecolor=\"white\", linewidth=0.8)\n", + "axes[1].set_title(f\"Khisto: {len(hist(data, density=True)[0])} adaptive bins\")\n", + "axes[1].set_xlabel(\"Value\") \n", "\n", - "print(f\"Returned {len(n)} bin values\")" + "fig.suptitle(\"Same data, same density, very different readability\", y=1.03)\n", + "plt.tight_layout()\n", + "plt.show()" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "6c89bf07", + "cell_type": "markdown", + "id": "1f297ee8", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAArMAAAHWCAYAAABkNgFvAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQjRJREFUeJzt3XtcFmX+//H3DQooCGgoKKJ4qMwNQTEJy8MaiWmmnTQ1QTIzT2ux9ks6SNYmmYelNVNrPZRWkmXWdzWNWO2gliWWh9TUVDwBsiYoKhj3/P7owV133CAgcjPyej4e80iuuWbmc8893b4drrlui2EYhgAAAAATcnF2AQAAAEBlEWYBAABgWoRZAAAAmBZhFgAAAKZFmAUAAIBpEWYBAABgWoRZAAAAmBZhFgAAAKZFmAUAAIBpEWYBVIslS5bIYrHo0KFDV9WxLRaLnnvuuSrfb21x5MgReXh4aOPGjc4upcI2bNggi8WiDRs2VNk+165dKy8vL508ebLK9glc7QizQC21a9cuPfjggwoMDJS7u7uaNWumYcOGadeuXZe132nTpmnVqlVVU2Q1e+6552SxWJSTk+NwfXBwsO68887LPs4777yj5OTky97P1eD5559XRESEbrnlFlvbiBEjZLFYbIuXl5dat26t++67Tx988IGsVqsTKy7b5b63ffr0Udu2bZWUlFR1RQFXOcIsUAutXLlSnTp1UlpamuLi4vTaa69p5MiRWr9+vTp16qQPP/yw0vsuLcwOHz5c58+fV8uWLS+j8prn/PnzeuaZZyq0DWH2NydPntSbb76pRx99tMQ6d3d3LV26VEuXLtU///lPDR06VPv27dN9992n2267TXl5eU6o2F737t11/vx5de/e3dZWFe/t6NGjtWDBAp05c+YyKwRqhzrOLgBA9Tpw4ICGDx+u1q1b64svvlDjxo1t6yZOnKhu3bpp+PDh2r59u1q3bl1lx3V1dZWrq2uV7a+m8PDwcHYJFZafny9PT09nl6Fly5apTp066t+/f4l1derU0YMPPmjX9o9//EMvvfSSEhISNGrUKKWkpFRXqQ65uLhckff/3nvv1YQJE7RixQo99NBDVb5/4GrDnVmglpkxY4bOnTun119/3S7ISpKfn58WLFig/Px8vfzyy7b24l+/79mzR4MGDZK3t7euueYaTZw4URcuXLD1s1gsys/P15tvvmn7FfGIESMkOR63Wvxr+w0bNqhz586qV6+eQkJCbGMQV65cqZCQEHl4eCg8PFzbtm2zq3f79u0aMWKEWrduLQ8PDwUEBOihhx7S//73v6o9aWX485jZM2fO6LHHHlNwcLDc3d3VpEkT3X777UpPT5ck9ezZU6tXr9bhw4dt5yg4ONi2fXZ2tkaOHCl/f395eHgoNDRUb775Zonj/u9//9Pw4cPl7e0tX19fxcbG6ocffpDFYtGSJUts/UaMGCEvLy8dOHBAffv2VYMGDTRs2DBJ0pdffqn7779fLVq0kLu7u4KCgvT444/r/Pnzdscq3kdGRobuvPNOeXl5KTAwUHPnzpUk7dixQ7169ZKnp6datmypd955p1znbtWqVYqIiJCXl1e5+kvS5MmT1bt3b61YsUI//fST3bpPPvlE3bp1k6enpxo0aKB+/fqVGDZT/FqOHTumgQMHysvLS40bN9akSZNUVFRk13f58uUKDw9XgwYN5O3trZCQEL3yyiu29X8eM1vae3v27Fl5enpq4sSJJV7P0aNH5erqajesoEmTJurQoYM++uijcp8XoDbjzixQy/zf//2fgoOD1a1bN4fru3fvruDgYK1evbrEukGDBik4OFhJSUn6+uuv9a9//Uu//PKL3nrrLUnS0qVL9fDDD6tLly565JFHJElt2rQps579+/dr6NChGj16tB588EHNnDlT/fv31/z58/XUU09p7NixkqSkpCQNGjRIe/fulYvLb/8OT01N1c8//6y4uDgFBARo165dev3117Vr1y59/fXXslgslTpHp06dcthenrGajz76qN5//32NHz9e7du31//+9z999dVX2r17tzp16qSnn35aubm5Onr0qP75z39Kki3MnT9/Xj179tT+/fs1fvx4tWrVSitWrNCIESN0+vRpWxiyWq3q37+/tmzZojFjxqhdu3b66KOPFBsb67CmX3/9VdHR0br11ls1c+ZM1a9fX5K0YsUKnTt3TmPGjNE111yjLVu2aM6cOTp69KhWrFhht4+ioiLdcccd6t69u15++WW9/fbbGj9+vDw9PfX0009r2LBhuueeezR//nzFxMQoMjJSrVq1KvU8Xbx4Ud9++63GjBlzyXP6Z8OHD9enn36q1NRUXXfddZJ+u/ZiY2MVHR2t6dOn69y5c5o3b55uvfVWbdu2ze4fDEVFRYqOjlZERIRmzpypzz77TLNmzVKbNm1s9aSmpmrIkCG67bbbNH36dEnS7t27tXHjRoehVFKp762Xl5fuvvtupaSkaPbs2Xa/oXj33XdlGIbtHxjFwsPDTTv2HKh2BoBa4/Tp04YkY8CAAWX2u+uuuwxJRl5enmEYhpGYmGhIMu666y67fmPHjjUkGT/88IOtzdPT04iNjS2xz8WLFxuSjIMHD9raWrZsaUgyNm3aZGtbt26dIcmoV6+ecfjwYVv7ggULDEnG+vXrbW3nzp0rcZx3333XkGR88cUXZR7bkeLXWdbSr18/u20kGYmJibaffXx8jHHjxpV5nH79+hktW7Ys0Z6cnGxIMpYtW2ZrKywsNCIjIw0vLy/b+/HBBx8Ykozk5GRbv6KiIqNXr16GJGPx4sW29tjYWEOSMXny5BLHc3T+kpKSDIvFYnfui/cxbdo0W9svv/xi1KtXz7BYLMby5ctt7Xv27ClxThzZv3+/IcmYM2dOiXWxsbGGp6dnqdtu27bNkGQ8/vjjhmEYxpkzZwxfX19j1KhRdv0yMzMNHx8fu/bi1/L888/b9e3YsaMRHh5u+3nixImGt7e38euvv5Zax/r160tck6W9t8XX9SeffGLX3qFDB6NHjx4l+k+bNs2QZGRlZZV6fAC/YZgBUIsUP1DSoEGDMvsVr//zQzbjxo2z+3nChAmSpDVr1lS6pvbt2ysyMtL2c0REhCSpV69eatGiRYn2n3/+2dZWr149258vXLignJwc3XzzzZJk+7V+ZXzwwQdKTU0tsfj7+19yW19fX33zzTc6fvx4hY+7Zs0aBQQEaMiQIba2unXr6m9/+5vOnj2rzz//XNJv0zfVrVtXo0aNsvVzcXEp8f78kaM7oH88f/n5+crJyVHXrl1lGEaJIR2S9PDDD9v+7Ovrq+uvv16enp4aNGiQrf3666+Xr6+v3fvkSPFQkIYNG5bZz5HiO9nF13NqaqpOnz6tIUOGKCcnx7a4uroqIiJC69evL7GPPz901q1bN7uafX19lZ+fr9TU1ArX50hUVJSaNWumt99+29a2c+dObd++vcTYYOn381LazBoAfscwA6AWKQ6pl3pKurTQe+2119r93KZNG7m4uFzW/K1/DKyS5OPjI0kKCgpy2P7LL7/Y2k6dOqWpU6dq+fLlys7Otuufm5tb6Zq6d+8uPz+/Eu3ledjn5ZdfVmxsrIKCghQeHq6+ffsqJiamXA/THT58WNdee61tGEWxG264wba++L9Nmza1DRco1rZtW4f7rVOnjpo3b16iPSMjQ1OmTNHHH39sd16lkufPw8OjxBhrHx8fNW/evMRwDh8fnxL7K41hGOXq90dnz56V9Pv1uW/fPkm//QPIEW9vb7ufHb2Whg0b2tU8duxYvffee7rjjjsUGBio3r17a9CgQerTp0+F65V++8fGsGHDNG/ePJ07d07169fX22+/LQ8PD91///0l+hefl8oOlQFqE8IsUIv4+PioadOm2r59e5n9tm/frsDAwBIh4M+q4i/a0mY4KK39j+Fn0KBB2rRpk5544gmFhYXJy8tLVqtVffr0cdpcpIMGDVK3bt304Ycf6tNPP9WMGTM0ffp0rVy5UnfccYdTanJ3dy8RkIuKinT77bfr1KlTevLJJ9WuXTt5enrq2LFjGjFiRInzdznvkyPXXHONJJU79P7Rzp07Jf0e3otrXbp0qQICAkr0r1PH/q+68syq0aRJE33//fdat26dPvnkE33yySdavHixYmJiHD6QVx4xMTGaMWOGVq1apSFDhuidd97RnXfeafuH2h8VnxdH/6gCYI8wC9Qyd955p9544w199dVXuvXWW0us//LLL3Xo0CGNHj26xLp9+/bZPdSzf/9+Wa1Wu4drqutO0i+//KK0tDRNnTpVU6ZMsavR2Zo2baqxY8dq7Nixys7OVqdOnfTiiy/awmxp56hly5bavn27rFarXfjcs2ePbX3xf9evX2+7w1ds//795a5xx44d+umnn/Tmm28qJibG1l5Vv1a/lBYtWqhevXo6ePBghbddunSpLBaLbr/9dkm/P2TYpEkTRUVFVVmNbm5u6t+/v/r37y+r1aqxY8dqwYIFevbZZ0u9C17W9X/jjTeqY8eOevvtt9W8eXNlZGRozpw5DvsePHhQfn5+Je4gAyiJMbNALfPEE0+oXr16Gj16dIkprE6dOqVHH31U9evX1xNPPFFi2+KpmIoV/0X8xzuOnp6eOn36dNUX/ifFd9f+fAfQmV9GUFRUVOLX802aNFGzZs1UUFBga/P09HQ4DKJv377KzMy0mz/1119/1Zw5c+Tl5aUePXpIkqKjo3Xx4kW98cYbtn5Wq7XE+1MWR+fPMAy7qaeupLp166pz58767rvvKrTdSy+9pE8//VSDBw+2DXuJjo6Wt7e3pk2bposXL5bYpjJfDfvn/zdcXFzUoUMHSbJ7L/+stPe2WPFMDMnJybrmmmtKvVu/detWu7HkAErHnVmglrn22mv15ptvatiwYQoJCdHIkSPVqlUrHTp0SAsXLlROTo7effddh1NqHTx4UHfddZf69OmjzZs3a9myZRo6dKhCQ0NtfcLDw/XZZ59p9uzZatasmVq1amV7eKsqeXt726aJunjxogIDA/Xpp59W6k5fVTlz5oyaN2+u++67T6GhofLy8tJnn32mb7/9VrNmzbL1Cw8PV0pKiuLj43XTTTfJy8tL/fv31yOPPKIFCxZoxIgR2rp1q4KDg/X+++9r48aNSk5Oto0RHThwoLp06aK///3v2r9/v9q1a6ePP/7YNqVYee6Ot2vXTm3atNGkSZN07NgxeXt764MPPqjUr/0ra8CAAXr66aeVl5dXYkjLr7/+qmXLlkn67eG+w4cP6+OPP9b27dv117/+Va+//rqtr7e3t+bNm6fhw4erU6dOeuCBB9S4cWNlZGRo9erVuuWWW/Tqq69WqLaHH35Yp06dUq9evdS8eXMdPnxYc+bMUVhYmG0MsyOlvbfFhg4dqv/3//6fPvzwQ40ZM0Z169YtsY/s7Gxt3769zAf6APyB8yZSAOBM27dvN4YMGWI0bdrUqFu3rhEQEGAMGTLE2LFjR4m+xVNW/fjjj8Z9991nNGjQwGjYsKExfvx44/z583Z99+zZY3Tv3t2oV6+eIck2TVdpU3P9eaorw/htuqs/T2918OBBQ5IxY8YMW9vRo0eNu+++2/D19TV8fHyM+++/3zh+/HiJqaEqOjXXyZMnHa53VO8fj1VQUGA88cQTRmhoqNGgQQPD09PTCA0NNV577TW7bc6ePWsMHTrU8PX1NSTZTeWUlZVlxMXFGX5+foabm5sREhJiN9VWsZMnTxpDhw41GjRoYPj4+BgjRowwNm7caEiymyqrrGmufvzxRyMqKsrw8vIy/Pz8jFGjRhk//PCDw+m9HO2jR48exl/+8pdynSdHsrKyjDp16hhLly61ay+ePqt4qV+/vhEcHGzce++9xvvvv28UFRU53N/69euN6Ohow8fHx/Dw8DDatGljjBgxwvjuu+8u+VqK3/ti77//vtG7d2+jSZMmhpubm9GiRQtj9OjRxokTJ+yOpz9NzVXWe1usb9++Jaak+6N58+YZ9evXt03FBqBsFsOoxKOkAGqV5557TlOnTtXJkyd5IKUGW7Vqle6++2599dVXuuWWW5xdTrmMHDlSP/30k7788ktnl1Jt7r77bu3YsaPUMc4dO3ZUz549bV+8AKBsjJkFABP681fOFhUVac6cOfL29lanTp2cVFXFJSYm6ttvv9XGjRudXUq1OHHihFavXq3hw4c7XL927Vrt27dPCQkJ1VwZYF6MmQUAE5owYYLOnz+vyMhIFRQUaOXKldq0aZOmTZtm92UINV2LFi104cIFZ5dxxR08eFAbN27Uv//9b9WtW9fhbCGS1KdPH9s8ugDKhzALACbUq1cvzZo1S//5z3904cIFtW3bVnPmzNH48eOdXRoc+PzzzxUXF6cWLVrozTffdDgfLoDKYcwsAAAATIsxswAAADAtwiwAAABMq9aNmbVarTp+/LgaNGhQbV+7CQAAgPIzDENnzpxRs2bN7L7e25FaF2aPHz+uoKAgZ5cBAACASzhy5IiaN29eZp9aF2aLvw7yyJEjJb4+EQAAAM6Xl5enoKAgW24rS60Ls8VDC7y9vQmzAAAANVh5hoTyABgAAABMizALAAAA0yLMAgAAwLQIswAAADAtwiwAAABMizALAAAA0yLMAgAAwLQIswAAADAtwiwAAABMizALAAAA0yLMAgAAwLQIswAAADAtwiwAAABMizALAAAA0yLMAgAAwLTqOLsAOGaZailzvZFoVFMlAAAANRd3ZgEAAGBahFkAAACYFmEWAAAApkWYBQAAgGkRZgEAAGBahFkAAACYFmEWAAAApkWYBQAAgGk5PczOnTtXwcHB8vDwUEREhLZs2VJm/+TkZF1//fWqV6+egoKC9Pjjj+vChQvVVC0AAABqEqeG2ZSUFMXHxysxMVHp6ekKDQ1VdHS0srOzHfZ/5513NHnyZCUmJmr37t1auHChUlJS9NRTT1Vz5QAAAKgJnBpmZ8+erVGjRikuLk7t27fX/PnzVb9+fS1atMhh/02bNumWW27R0KFDFRwcrN69e2vIkCGXvJsLAACAq5PTwmxhYaG2bt2qqKio34txcVFUVJQ2b97scJuuXbtq69attvD6888/a82aNerbt2+pxykoKFBeXp7dAgAAgKtDHWcdOCcnR0VFRfL397dr9/f31549exxuM3ToUOXk5OjWW2+VYRj69ddf9eijj5Y5zCApKUlTp06t0toBAABQMzj9AbCK2LBhg6ZNm6bXXntN6enpWrlypVavXq0XXnih1G0SEhKUm5trW44cOVKNFQMAAOBKctqdWT8/P7m6uiorK8uuPSsrSwEBAQ63efbZZzV8+HA9/PDDkqSQkBDl5+frkUce0dNPPy0Xl5LZ3N3dXe7u7lX/AgAAAOB0Trsz6+bmpvDwcKWlpdnarFar0tLSFBkZ6XCbc+fOlQisrq6ukiTDMK5csQAAAKiRnHZnVpLi4+MVGxurzp07q0uXLkpOTlZ+fr7i4uIkSTExMQoMDFRSUpIkqX///po9e7Y6duyoiIgI7d+/X88++6z69+9vC7UAAACoPZwaZgcPHqyTJ09qypQpyszMVFhYmNauXWt7KCwjI8PuTuwzzzwji8WiZ555RseOHVPjxo3Vv39/vfjii856CQAAAHAii1HLfj+fl5cnHx8f5ebmytvb29nllMoy1VLmeiOxVr1tAACgFqlIXjPVbAYAAADAHxFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAadWIMDt37lwFBwfLw8NDERER2rJlS6l9e/bsKYvFUmLp169fNVYMAACAmsDpYTYlJUXx8fFKTExUenq6QkNDFR0drezsbIf9V65cqRMnTtiWnTt3ytXVVffff381Vw4AAABnc3qYnT17tkaNGqW4uDi1b99e8+fPV/369bVo0SKH/Rs1aqSAgADbkpqaqvr16xNmAQAAaiGnhtnCwkJt3bpVUVFRtjYXFxdFRUVp8+bN5drHwoUL9cADD8jT09Ph+oKCAuXl5dktAAAAuDo4Nczm5OSoqKhI/v7+du3+/v7KzMy85PZbtmzRzp079fDDD5faJykpST4+PrYlKCjosusGAABAzeD0YQaXY+HChQoJCVGXLl1K7ZOQkKDc3FzbcuTIkWqsEAAAAFdSHWce3M/PT66ursrKyrJrz8rKUkBAQJnb5ufna/ny5Xr++efL7Ofu7i53d/fLrhUAAAA1j1PvzLq5uSk8PFxpaWm2NqvVqrS0NEVGRpa57YoVK1RQUKAHH3zwSpcJAACAGsqpd2YlKT4+XrGxsercubO6dOmi5ORk5efnKy4uTpIUExOjwMBAJSUl2W23cOFCDRw4UNdcc40zygYAAEAN4PQwO3jwYJ08eVJTpkxRZmamwsLCtHbtWttDYRkZGXJxsb+BvHfvXn311Vf69NNPnVEyAAAAagiLYRiGs4uoTnl5efLx8VFubq68vb2dXU6pLFMtZa43EmvV2wYAAGqRiuQ1U89mAAAAgNqNMAsAAADTIswCAADAtAizAAAAMC3CLAAAAEyLMAsAAADTIswCAADAtAizAAAAMC3CLAAAAEyLMAsAAADTIswCAADAtAizAAAAMC3CLAAAAEyLMAsAAADTIswCAADAtAizAAAAMC3CLAAAAEyLMAsAAADTIswCAADAtAizAAAAMC3CLAAAAEyLMAsAAADTIswCAADAtAizAAAAMC3CLAAAAEyLMAsAAADTIswCAADAtAizAAAAMC3CLAAAAEyLMAsAAADTIswCAADAtAizAAAAMC3CLAAAAEyLMAsAAADTcnqYnTt3roKDg+Xh4aGIiAht2bKlzP6nT5/WuHHj1LRpU7m7u+u6667TmjVrqqlaAAAA1CR1nHnwlJQUxcfHa/78+YqIiFBycrKio6O1d+9eNWnSpET/wsJC3X777WrSpInef/99BQYG6vDhw/L19a3+4gEAAOB0Tg2zs2fP1qhRoxQXFydJmj9/vlavXq1FixZp8uTJJfovWrRIp06d0qZNm1S3bl1JUnBwcJnHKCgoUEFBge3nvLy8qnsBAAAAcCqnDTMoLCzU1q1bFRUV9XsxLi6KiorS5s2bHW7z8ccfKzIyUuPGjZO/v79uvPFGTZs2TUVFRaUeJykpST4+PrYlKCioyl8LAAAAnMNpYTYnJ0dFRUXy9/e3a/f391dmZqbDbX7++We9//77Kioq0po1a/Tss89q1qxZ+sc//lHqcRISEpSbm2tbjhw5UqWvAwAAAM7j1GEGFWW1WtWkSRO9/vrrcnV1VXh4uI4dO6YZM2YoMTHR4Tbu7u5yd3ev5koBAABQHZwWZv38/OTq6qqsrCy79qysLAUEBDjcpmnTpqpbt65cXV1tbTfccIMyMzNVWFgoNze3K1ozAAAAahanDTNwc3NTeHi40tLSbG1Wq1VpaWmKjIx0uM0tt9yi/fv3y2q12tp++uknNW3alCALAABQCzl1ntn4+Hi98cYbevPNN7V7926NGTNG+fn5ttkNYmJilJCQYOs/ZswYnTp1ShMnTtRPP/2k1atXa9q0aRo3bpyzXgIAAACcyKljZgcPHqyTJ09qypQpyszMVFhYmNauXWt7KCwjI0MuLr/n7aCgIK1bt06PP/64OnTooMDAQE2cOFFPPvmks14CAAAAnMhiGIbh7CKqU15ennx8fJSbmytvb29nl1Mqy1RLmeuNxFr1tgEAgFqkInnN6V9nCwAAAFQWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJhWjQizc+fOVXBwsDw8PBQREaEtW7aU2nfJkiWyWCx2i4eHRzVWCwAAgJrC6WE2JSVF8fHxSkxMVHp6ukJDQxUdHa3s7OxSt/H29taJEydsy+HDh6uxYgAAANQUTg+zs2fP1qhRoxQXF6f27dtr/vz5ql+/vhYtWlTqNhaLRQEBAbbF39+/GisGAABATeHUMFtYWKitW7cqKirK1ubi4qKoqCht3ry51O3Onj2rli1bKigoSAMGDNCuXbtK7VtQUKC8vDy7BQAAAFcHp4bZnJwcFRUVlbiz6u/vr8zMTIfbXH/99Vq0aJE++ugjLVu2TFarVV27dtXRo0cd9k9KSpKPj49tCQoKqvLXAQAAAOdw+jCDioqMjFRMTIzCwsLUo0cPrVy5Uo0bN9aCBQsc9k9ISFBubq5tOXLkSDVXDAAAgCuljjMP7ufnJ1dXV2VlZdm1Z2VlKSAgoFz7qFu3rjp27Kj9+/c7XO/u7i53d/fLrhUAAAA1j1PvzLq5uSk8PFxpaWm2NqvVqrS0NEVGRpZrH0VFRdqxY4eaNm16pcoEAABADeXUO7OSFB8fr9jYWHXu3FldunRRcnKy8vPzFRcXJ0mKiYlRYGCgkpKSJEnPP/+8br75ZrVt21anT5/WjBkzdPjwYT388MPOfBkAAABwgkqF2Z9//lmtW7eukgIGDx6skydPasqUKcrMzFRYWJjWrl1reygsIyNDLi6/30D+5ZdfNGrUKGVmZqphw4YKDw/Xpk2b1L59+yqpBwAAAOZhMQzDqOhGLi4u6tGjh0aOHKn77rvPVN/AlZeXJx8fH+Xm5srb29vZ5ZTKMtVS5nojscJvGwAAgClUJK9Vasxsenq6OnTooPj4eAUEBGj06NFlfgUtAAAAcCVUKsyGhYXplVde0fHjx7Vo0SKdOHFCt956q2688UbNnj1bJ0+erOo6AQAAgBIqNczgzwoKCvTaa68pISFBhYWFcnNz06BBgzR9+vQaN8tATRtmcKnhBKVhmAEAALhaXfFhBsW+++47jR07Vk2bNtXs2bM1adIkHThwQKmpqTp+/LgGDBhwObsHAAAAylSp2Qxmz56txYsXa+/everbt6/eeust9e3b1zbrQKtWrbRkyRIFBwdXZa0AAACAnUqF2Xnz5umhhx7SiBEjSh1G0KRJEy1cuPCyigMAAADKUqkwm5qaqhYtWtjN/ypJhmHoyJEjatGihdzc3BQbG1slRQIAAACOVGrMbJs2bZSTk1Oi/dSpU2rVqtVlFwUAAACUR6XCbGkTIJw9e9ZUX6AAAAAAc6vQMIP4+HhJksVi0ZQpU1S/fn3buqKiIn3zzTcKCwur0gIBAACA0lQozG7btk3Sb3dmd+zYITc3N9s6Nzc3hYaGatKkSVVbIQAAAFCKCoXZ9evXS5Li4uL0yiuv1IgvHQAAAEDtVanZDBYvXlzVdQAAAAAVVu4we88992jJkiXy9vbWPffcU2bflStXXnZhAAAAwKWUO8z6+PjIYrHY/gwAAAA4W7nD7B+HFjDMAAAAADVBpeaZPX/+vM6dO2f7+fDhw0pOTtann35aZYUBAAAAl1KpMDtgwAC99dZbkqTTp0+rS5cumjVrlgYMGKB58+ZVaYEAAABAaSoVZtPT09WtWzdJ0vvvv6+AgAAdPnxYb731lv71r39VaYEAAABAaSoVZs+dO6cGDRpIkj799FPdc889cnFx0c0336zDhw9XaYEAAABAaSoVZtu2batVq1bpyJEjWrdunXr37i1Jys7O5osUAAAAUG0qFWanTJmiSZMmKTg4WBEREYqMjJT0213ajh07VmmBAAAAQGkq9Q1g9913n2699VadOHFCoaGhtvbbbrtNd999d5UVBwAAAJSlUmFWkgICAhQQEGDX1qVLl8suCAAAACivSoXZ/Px8vfTSS0pLS1N2drasVqvd+p9//rlKigMAAADKUqkw+/DDD+vzzz/X8OHD1bRpU9vX3AIAAADVqVJh9pNPPtHq1at1yy23VHU9AAAAQLlVajaDhg0bqlGjRlVdCwAAAFAhlQqzL7zwgqZMmaJz585VdT0AAABAuVVqmMGsWbN04MAB+fv7Kzg4WHXr1rVbn56eXiXFAQAAAGWpVJgdOHBgFZcBAAAAVFylwmxiYmJV1wEAAABUWKXGzErS6dOn9e9//1sJCQk6deqUpN+GFxw7dqzKigMAAADKUqkwu337dl133XWaPn26Zs6cqdOnT0uSVq5cqYSEhArvb+7cuQoODpaHh4ciIiK0ZcuWcm23fPlyWSwWhj0AAADUUpUKs/Hx8RoxYoT27dsnDw8PW3vfvn31xRdfVGhfKSkpio+PV2JiotLT0xUaGqro6GhlZ2eXud2hQ4c0adIkdevWrTIvAQAAAFeBSoXZb7/9VqNHjy7RHhgYqMzMzArta/bs2Ro1apTi4uLUvn17zZ8/X/Xr19eiRYtK3aaoqEjDhg3T1KlT1bp16wrXDwAAgKtDpcKsu7u78vLySrT/9NNPaty4cbn3U1hYqK1btyoqKur3glxcFBUVpc2bN5e63fPPP68mTZpo5MiRlzxGQUGB8vLy7BYAAABcHSoVZu+66y49//zzunjxoiTJYrEoIyNDTz75pO69995y7ycnJ0dFRUXy9/e3a/f39y/1Du9XX32lhQsX6o033ijXMZKSkuTj42NbgoKCyl0fAAAAarZKhdlZs2bp7Nmzaty4sc6fP68ePXqobdu2atCggV588cWqrtHmzJkzGj58uN544w35+fmVa5uEhATl5ubaliNHjlyx+gAAAFC9KjXPrI+Pj1JTU7Vx40b98MMPOnv2rDp16mQ3XKA8/Pz85OrqqqysLLv2rKwsBQQElOh/4MABHTp0SP3797e1Wa1WSVKdOnW0d+9etWnTxm4bd3d3ubu7V6guAAAAmEOFw6zVatWSJUu0cuVKHTp0SBaLRa1atVJAQIAMw5DFYin3vtzc3BQeHq60tDTb9FpWq1VpaWkaP358if7t2rXTjh077NqeeeYZnTlzRq+88gpDCAAAAGqZCoVZwzB01113ac2aNQoNDVVISIgMw9Du3bs1YsQIrVy5UqtWrapQAfHx8YqNjVXnzp3VpUsXJScnKz8/X3FxcZKkmJgYBQYGKikpSR4eHrrxxhvttvf19ZWkEu0AAAC4+lUozC5ZskRffPGF0tLS9Ne//tVu3X//+18NHDhQb731lmJiYsq9z8GDB+vkyZOaMmWKMjMzFRYWprVr19oeCsvIyJCLS6W/qAwAAABXMYthGEZ5O/fu3Vu9evXS5MmTHa6fNm2aPv/8c61bt67KCqxqeXl58vHxUW5urry9vZ1djixTyz8s44+MxHK/bQAAAKZSkbxWoVue27dvV58+fUpdf8cdd+iHH36oyC4BAACASqtQmD116lSJOWH/yN/fX7/88stlFwUAAACUR4XCbFFRkerUKX2Yraurq3799dfLLgoAAAAojwrPZjBixIhS520tKCiokqIAAACA8qhQmI2Njb1kn4rMZAAAAABcjgqF2cWLF1+pOgAAAIAKYwJXAAAAmBZhFgAAAKZFmAUAAIBpEWYBAABgWoRZAAAAmBZhFgAAAKZFmAUAAIBpEWYBAABgWoRZAAAAmBZhFgAAAKZFmAUAAIBpEWYBAABgWoRZAAAAmBZhFgAAAKZFmAUAAIBpEWYBAABgWoRZAAAAmBZhFgAAAKZFmAUAAIBpEWYBAABgWoRZAAAAmBZhFgAAAKZFmAUAAIBpEWYBAABgWoRZAAAAmBZhFgAAAKZFmAUAAIBp1YgwO3fuXAUHB8vDw0MRERHasmVLqX1Xrlypzp07y9fXV56engoLC9PSpUursVoAAADUFE4PsykpKYqPj1diYqLS09MVGhqq6OhoZWdnO+zfqFEjPf3009q8ebO2b9+uuLg4xcXFad26ddVcOQAAAJzNYhiG4cwCIiIidNNNN+nVV1+VJFmtVgUFBWnChAmaPHlyufbRqVMn9evXTy+88MIl++bl5cnHx0e5ubny9va+rNqrgmWqpVLbGYlOfdsAAACumIrkNafemS0sLNTWrVsVFRVla3NxcVFUVJQ2b958ye0Nw1BaWpr27t2r7t27O+xTUFCgvLw8uwUAAABXB6eG2ZycHBUVFcnf39+u3d/fX5mZmaVul5ubKy8vL7m5ualfv36aM2eObr/9dod9k5KS5OPjY1uCgoKq9DUAAADAeZw+ZrYyGjRooO+//17ffvutXnzxRcXHx2vDhg0O+yYkJCg3N9e2HDlypHqLBQAAwBVTx5kH9/Pzk6urq7Kysuzas7KyFBAQUOp2Li4uatu2rSQpLCxMu3fvVlJSknr27Fmir7u7u9zd3au0bgAAANQMTr0z6+bmpvDwcKWlpdnarFar0tLSFBkZWe79WK1WFRQUXIkSAQAAUIM59c6sJMXHxys2NladO3dWly5dlJycrPz8fMXFxUmSYmJiFBgYqKSkJEm/jYHt3Lmz2rRpo4KCAq1Zs0ZLly7VvHnznPkyAAAA4AROD7ODBw/WyZMnNWXKFGVmZiosLExr1661PRSWkZEhF5ffbyDn5+dr7NixOnr0qOrVq6d27dpp2bJlGjx4sLNeAgAAAJzE6fPMVjfmmQUAAKjZTDPPLAAAAHA5CLMAAAAwLcIsAAAATIswCwAAANMizAIAAMC0CLMAAAAwLafPM4vKKW1KL6bsAgAAtQl3ZgEAAGBahFkAAACYFmEWAAAApkWYBQAAgGkRZgEAAGBahFkAAACYFmEWAAAApkWYBQAAgGkRZgEAAGBahFkAAACYFmEWAAAApkWYBQAAgGkRZgEAAGBahFkAAACYFmEWAAAApkWYBQAAgGkRZgEAAGBahFkAAACYFmEWAAAApkWYBQAAgGkRZgEAAGBahFkAAACYFmEWAAAApkWYBQAAgGkRZgEAAGBahFkAAACYVo0Is3PnzlVwcLA8PDwUERGhLVu2lNr3jTfeULdu3dSwYUM1bNhQUVFRZfYHAADA1cvpYTYlJUXx8fFKTExUenq6QkNDFR0drezsbIf9N2zYoCFDhmj9+vXavHmzgoKC1Lt3bx07dqyaKwcAAICzWQzDMJxZQEREhG666Sa9+uqrkiSr1aqgoCBNmDBBkydPvuT2RUVFatiwoV599VXFxMRcsn9eXp58fHyUm5srb2/vy67/clmmWqp0f0aiU99OAACAy1aRvObUO7OFhYXaunWroqKibG0uLi6KiorS5s2by7WPc+fO6eLFi2rUqJHD9QUFBcrLy7NbAAAAcHVwapjNyclRUVGR/P397dr9/f2VmZlZrn08+eSTatasmV0g/qOkpCT5+PjYlqCgoMuuGwAAADWD08fMXo6XXnpJy5cv14cffigPDw+HfRISEpSbm2tbjhw5Us1VAgAA4Eqp48yD+/n5ydXVVVlZWXbtWVlZCggIKHPbmTNn6qWXXtJnn32mDh06lNrP3d1d7u7uVVIvAAAAahan3pl1c3NTeHi40tLSbG1Wq1VpaWmKjIwsdbuXX35ZL7zwgtauXavOnTtXR6kAAACogZx6Z1aS4uPjFRsbq86dO6tLly5KTk5Wfn6+4uLiJEkxMTEKDAxUUlKSJGn69OmaMmWK3nnnHQUHB9vG1np5ecnLy8tprwMAAADVz+lhdvDgwTp58qSmTJmizMxMhYWFae3atbaHwjIyMuTi8vsN5Hnz5qmwsFD33Xef3X4SExP13HPPVWfpMLmqnhatPJg6DQCAquX0eWarG/PMohhhFgCAmsk088wCAAAAl4MwCwAAANMizAIAAMC0CLMAAAAwLcIsAAAATIswCwAAANMizAIAAMC0CLMAAAAwLcIsAAAATIswCwAAANMizAIAAMC0CLMAAAAwLcIsAAAATIswCwAAANMizAIAAMC0CLMAAAAwLcIsAAAATIswCwAAANMizAIAAMC0CLMAAAAwLcIsAAAATIswCwAAANMizAIAAMC0CLMAAAAwLcIsAAAATKuOswsA/sgy1eLsEgAAgIlwZxYAAACmRZgFAACAaRFmAQAAYFqEWQAAAJgWYRYAAACmRZgFAACAaRFmAQAAYFrMM1sNmDsVAADgynD6ndm5c+cqODhYHh4eioiI0JYtW0rtu2vXLt17770KDg6WxWJRcnJy9RUKAACAGsepYTYlJUXx8fFKTExUenq6QkNDFR0drezsbIf9z507p9atW+ull15SQEBANVcLAACAmsapYXb27NkaNWqU4uLi1L59e82fP1/169fXokWLHPa/6aabNGPGDD3wwANyd3ev5moBAABQ0zgtzBYWFmrr1q2Kior6vRgXF0VFRWnz5s1VdpyCggLl5eXZLQAAALg6OO0BsJycHBUVFcnf39+u3d/fX3v27Kmy4yQlJWnq1KlVtj/gctSkhwGNRMPZJQAAcNmc/gDYlZaQkKDc3FzbcuTIEWeXBAAAgCritDuzfn5+cnV1VVZWll17VlZWlT7c5e7uzvhaAACAq5TT7sy6ubkpPDxcaWlptjar1aq0tDRFRkY6qywAAACYiFO/NCE+Pl6xsbHq3LmzunTpouTkZOXn5ysuLk6SFBMTo8DAQCUlJUn67aGxH3/80fbnY8eO6fvvv5eXl5fatm3rtNcBAAAA53BqmB08eLBOnjypKVOmKDMzU2FhYVq7dq3tobCMjAy5uPx+8/j48ePq2LGj7eeZM2dq5syZ6tGjhzZs2FDd5QMAAMDJLIZh1KpHmvPy8uTj46Pc3Fx5e3tXyzGr8wl2sz+hXpOe9r/amf1aAQBcvSqS16762QwAAABw9SLMAgAAwLQIswAAADAtwiwAAABMizALAAAA0yLMAgAAwLQIswAAADAtwiwAAABMizALAAAA0yLMAgAAwLQIswAAADAtwiwAAABMizALAAAA0yLMAgAAwLQIswAAADAtwiwAAABMq46zCwDgHJapFmeXgFIYiYazSwAA0yDMXmUIKAAAoDZhmAEAAABMizALAAAA0yLMAgAAwLQIswAAADAtwiwAAABMizALAAAA0yLMAgAAwLQIswAAADAtwiwAAABMizALAAAA0yLMAgAAwLQIswAAADCtOs4uAABgzzLV4uwSTMVINJxdAgAn4s4sAAAATIswCwAAANOqEWF27ty5Cg4OloeHhyIiIrRly5Yy+69YsULt2rWTh4eHQkJCtGbNmmqqFAAAADWJ08NsSkqK4uPjlZiYqPT0dIWGhio6OlrZ2dkO+2/atElDhgzRyJEjtW3bNg0cOFADBw7Uzp07q7lyAAAAOJvFMAynjpyPiIjQTTfdpFdffVWSZLVaFRQUpAkTJmjy5Mkl+g8ePFj5+fn6z3/+Y2u7+eabFRYWpvnz51/yeHl5efLx8VFubq68vb2r7oWUgYc5AODK4QEw4OpTkbzm1NkMCgsLtXXrViUkJNjaXFxcFBUVpc2bNzvcZvPmzYqPj7dri46O1qpVqxz2LygoUEFBge3n3NxcSb+dpGpzofoOBQC1jSWBGwZAdchNyK22YxXntPLcc3VqmM3JyVFRUZH8/f3t2v39/bVnzx6H22RmZjrsn5mZ6bB/UlKSpk6dWqI9KCioklUDAADUPj4v+VT7Mc+cOSMfn7KPe9XPM5uQkGB3J9dqterUqVO65pprZLGY61/zeXl5CgoK0pEjR6ptiMTVinNZNTiPVYdzWTU4j1WHc1l1OJcVZxiGzpw5o2bNml2yr1PDrJ+fn1xdXZWVlWXXnpWVpYCAAIfbBAQEVKi/u7u73N3d7dp8fX0rX3QN4O3tzf8MVYRzWTU4j1WHc1k1OI9Vh3NZdTiXFXOpO7LFnDqbgZubm8LDw5WWlmZrs1qtSktLU2RkpMNtIiMj7fpLUmpqaqn9AQAAcPVy+jCD+Ph4xcbGqnPnzurSpYuSk5OVn5+vuLg4SVJMTIwCAwOVlJQkSZo4caJ69OihWbNmqV+/flq+fLm+++47vf766858GQAAAHACp4fZwYMH6+TJk5oyZYoyMzMVFhamtWvX2h7yysjIkIvL7zeQu3btqnfeeUfPPPOMnnrqKV177bVatWqVbrzxRme9hGrj7u6uxMTEEsMmUHGcy6rBeaw6nMuqwXmsOpzLqsO5vLKcPs8sAAAAUFlO/wYwAAAAoLIIswAAADAtwiwAAABMizALAAAA0yLM1mCHDh3SyJEj1apVK9WrV09t2rRRYmKiCgsLy9yuZ8+eslgsdsujjz5aTVXXHHPnzlVwcLA8PDwUERGhLVu2lNl/xYoVateunTw8PBQSEqI1a9ZUU6U1U1JSkm666SY1aNBATZo00cCBA7V3794yt1myZEmJa8/Dw6OaKq65nnvuuRLnpV27dmVuw/XoWHBwcIlzabFYNG7cOIf9uSZ/88UXX6h///5q1qyZLBaLVq1aZbfeMAxNmTJFTZs2Vb169RQVFaV9+/Zdcr8V/Zy9GpR1Li9evKgnn3xSISEh8vT0VLNmzRQTE6Pjx4+Xuc/KfEbgd4TZGmzPnj2yWq1asGCBdu3apX/+85+aP3++nnrqqUtuO2rUKJ04ccK2vPzyy9VQcc2RkpKi+Ph4JSYmKj09XaGhoYqOjlZ2drbD/ps2bdKQIUM0cuRIbdu2TQMHDtTAgQO1c+fOaq685vj88881btw4ff3110pNTdXFixfVu3dv5efnl7mdt7e33bV3+PDhaqq4ZvvLX/5id16++uqrUvtyPZbu22+/tTuPqampkqT777+/1G24JqX8/HyFhoZq7ty5Dte//PLL+te//qX58+frm2++kaenp6Kjo3XhwoVS91nRz9mrRVnn8ty5c0pPT9ezzz6r9PR0rVy5Unv37tVdd911yf1W5DMCf2LAVF5++WWjVatWZfbp0aOHMXHixOopqIbq0qWLMW7cONvPRUVFRrNmzYykpCSH/QcNGmT069fPri0iIsIYPXr0Fa3TTLKzsw1Jxueff15qn8WLFxs+Pj7VV5RJJCYmGqGhoeXuz/VYfhMnTjTatGljWK1Wh+u5JkuSZHz44Ye2n61WqxEQEGDMmDHD1nb69GnD3d3dePfdd0vdT0U/Z69Gfz6XjmzZssWQZBw+fLjUPhX9jIA97syaTG5urho1anTJfm+//bb8/Px04403KiEhQefOnauG6mqGwsJCbd26VVFRUbY2FxcXRUVFafPmzQ632bx5s11/SYqOji61f22Um5srSZe8/s6ePauWLVsqKChIAwYM0K5du6qjvBpv3759atasmVq3bq1hw4YpIyOj1L5cj+VTWFioZcuW6aGHHpLFYim1H9dk2Q4ePKjMzEy7a87Hx0cRERGlXnOV+ZytrXJzc2WxWOTr61tmv4p8RsAeYdZE9u/frzlz5mj06NFl9hs6dKiWLVum9evXKyEhQUuXLtWDDz5YTVU6X05OjoqKimzfIlfM399fmZmZDrfJzMysUP/axmq16rHHHtMtt9xS5rftXX/99Vq0aJE++ugjLVu2TFarVV27dtXRo0ersdqaJyIiQkuWLNHatWs1b948HTx4UN26ddOZM2cc9ud6LJ9Vq1bp9OnTGjFiRKl9uCYvrfi6qsg1V5nP2drowoULevLJJzVkyBB5e3uX2q+inxGw5/Svs62NJk+erOnTp5fZZ/fu3XaDv48dO6Y+ffro/vvv16hRo8rc9pFHHrH9OSQkRE2bNtVtt92mAwcOqE2bNpdXPGqlcePGaefOnZccwxUZGanIyEjbz127dtUNN9ygBQsW6IUXXrjSZdZYd9xxh+3PHTp0UEREhFq2bKn33ntPI0eOdGJl5rZw4ULdcccdatasWal9uCbhLBcvXtSgQYNkGIbmzZtXZl8+Iy4PYdYJ/v73v5d5J0GSWrdubfvz8ePH9de//lVdu3bV66+/XuHjRURESPrtzm5tCLN+fn5ydXVVVlaWXXtWVpYCAgIcbhMQEFCh/rXJ+PHj9Z///EdffPGFmjdvXqFt69atq44dO2r//v1XqDpz8vX11XXXXVfqeeF6vLTDhw/rs88+08qVKyu0HddkScXXVVZWlpo2bWprz8rKUlhYmMNtKvM5W5sUB9nDhw/rv//9b5l3ZR251GcE7DHMwAkaN26sdu3albm4ublJ+u2ObM+ePRUeHq7FixfLxaXib9n3338vSXYfUlczNzc3hYeHKy0tzdZmtVqVlpZmd4fmjyIjI+36S1Jqamqp/WsDwzA0fvx4ffjhh/rvf/+rVq1aVXgfRUVF2rFjR6259srr7NmzOnDgQKnnhevx0hYvXqwmTZqoX79+FdqOa7KkVq1aKSAgwO6ay8vL0zfffFPqNVeZz9naojjI7tu3T5999pmuueaaCu/jUp8R+BNnP4GG0h09etRo27atcdtttxlHjx41Tpw4YVv+2Of66683vvnmG8MwDGP//v3G888/b3z33XfGwYMHjY8++sho3bq10b17d2e9DKdYvny54e7ubixZssT48ccfjUceecTw9fU1MjMzDcMwjOHDhxuTJ0+29d+4caNRp04dY+bMmcbu3buNxMREo27dusaOHTuc9RKcbsyYMYaPj4+xYcMGu2vv3Llztj5/Po9Tp0411q1bZxw4cMDYunWr8cADDxgeHh7Grl27nPESaoy///3vxoYNG4yDBw8aGzduNKKiogw/Pz8jOzvbMAyux4oqKioyWrRoYTz55JMl1nFNOnbmzBlj27ZtxrZt2wxJxuzZs41t27bZnrB/6aWXDF9fX+Ojjz4ytm/fbgwYMMBo1aqVcf78eds+evXqZcyZM8f286U+Z69WZZ3LwsJC46677jKaN29ufP/993afnQUFBbZ9/PlcXuozAmUjzNZgixcvNiQ5XIodPHjQkGSsX7/eMAzDyMjIMLp37240atTIcHd3N9q2bWs88cQTRm5urpNehfPMmTPHaNGiheHm5mZ06dLF+Prrr23revToYcTGxtr1f++994zrrrvOcHNzM/7yl78Yq1evruaKa5bSrr3Fixfb+vz5PD722GO2c+7v72/07dvXSE9Pr/7ia5jBgwcbTZs2Ndzc3IzAwEBj8ODBxv79+23ruR4rZt26dYYkY+/evSXWcU06tn79eof/PxefK6vVajz77LOGv7+/4e7ubtx2220lzm/Lli2NxMREu7ayPmevVmWdy+K/kx0txX9PG0bJc3mpzwiUzWIYhnHl7/8CAAAAVY8xswAAADAtwiwAAABMizALAAAA0yLMAgAAwLQIswAAADAtwiwAAABMizALAAAA0yLMAgAAwLQIswBgYj179tRjjz3m7DIAwGkIswDgJP3791efPn0crvvyyy9lsVi0ffv2aq4KAMyFMAsATjJy5Eilpqbq6NGjJdYtXrxYnTt3VocOHZxQGQCYB2EWAJzkzjvvVOPGjbVkyRK79rNnz2rFihUaOHCghgwZosDAQNWvX18hISF69913y9ynxWLRqlWr7Np8fX3tjnHkyBENGjRIvr6+atSokQYMGKBDhw5VzYsCgGpGmAUAJ6lTp45iYmK0ZMkSGYZha1+xYoWKior04IMPKjw8XKtXr9bOnTv1yCOPaPjw4dqyZUulj3nx4kVFR0erQYMG+vLLL7Vx40Z5eXmpT58+KiwsrIqXBQDVijALAE700EMP6cCBA/r8889tbYsXL9a9996rli1batKkSQoLC1Pr1q01YcIE9enTR++9916lj5eSkiKr1ap///vfCgkJ0Q033KDFixcrIyNDGzZsqIJXBADVizALAE7Url07de3aVYsWLZIk7d+/X19++aVGjhypoqIivfDCCwoJCVGjRo3k5eWldevWKSMjo9LH++GHH7R//341aNBAXl5e8vLyUqNGjXThwgUdOHCgql4WAFSbOs4uAABqu5EjR2rChAmaO3euFi9erDZt2qhHjx6aPn26XnnlFSUnJyskJESenp567LHHyhwOYLFY7IYsSL8NLSh29uxZhYeH6+233y6xbePGjavuRQFANSHMAoCTDRo0SBMnTtQ777yjt956S2PGjJHFYtHGjRs1YMAAPfjgg5Ikq9Wqn376Se3bty91X40bN9aJEydsP+/bt0/nzp2z/dypUyelpKSoSZMm8vb2vnIvCgCqCcMMAMDJvLy8NHjwYCUkJOjEiRMaMWKEJOnaa69VamqqNm3apN27d2v06NHKysoqc1+9evXSq6++qm3btum7777To48+qrp169rWDxs2TH5+fhowYIC+/PJLHTx4UBs2bNDf/vY3h1OEAUBNR5gFgBpg5MiR+uWXXxQdHa1mzZpJkp555hl16tRJ0dHR6tmzpwICAjRw4MAy9zNr1iwFBQWpW7duGjp0qCZNmqT69evb1tevX19ffPGFWrRooXvuuUc33HCDRo4cqQsXLnCnFoApWYw/D64CAAAATII7swAAADAtwiwAAABMizALAAAA0yLMAgAAwLQIswAAADAtwiwAAABMizALAAAA0yLMAgAAwLQIswAAADAtwiwAAABMizALAAAA0/r/6o1XqcEFKrUAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ - "# Density plot\n", - "fig, ax = plt.subplots(figsize=(8, 5))\n", - "n, bins, patches = hist(data, density=True, ax=ax, color=\"green\")\n", - "ax.set_xlabel(\"Value\")\n", - "ax.set_ylabel(\"Density\")\n", - "ax.set_title(\"Optimal Histogram (Density)\")\n", - "plt.show()" + "### The same comparison — log-log scale\n", + "\n", + "On log-log axes the tail behaviour comes to the foreground. Empty fixed-width\n", + "bins simply vanish (a zero has no place on a log axis), whereas adaptive bins\n", + "widen to keep the tail populated and visible." ] }, { "cell_type": "code", - "execution_count": null, - "id": "25d8d0e5", + "execution_count": 23, + "id": "48c3b0aa", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAHWCAYAAACVPVriAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAASexJREFUeJzt3XtYVVX+x/HPAQUUBDSUi6HgZXQqlYRkKG8VCVkmZXnJ5DKmpuVPh6y0C2Q1oWbGZI5WM14rc2zMmSmjjBErIy0vaaampuINvAUoKhqs3x89nDoBJggc3PN+Pc9+krXXXue7N0f6sF17HZsxxggAAACwKBdnFwAAAADUJgIvAAAALI3ACwAAAEsj8AIAAMDSCLwAAACwNAIvAAAALI3ACwAAAEsj8AIAAMDSCLwAAACwNAIvgHpj/vz5stls2rt3r6Ve22az6emnn67xcf9X7N+/Xx4eHlqzZo2zS6myrKws2Ww2ZWVl1diYGRkZ8vLy0tGjR2tsTMDqCLwAKrV161bdd999atmypdzd3RUUFKShQ4dq69atlzTu888/r+XLl9dMkXXs6aefls1m07FjxyrcHxISottvv/2SX+ett95Senr6JY9jBc8884wiIyN1ww032NsSExNls9nsm5eXl9q0aaO7775b//znP1VaWurEii/sUr+3sbGxateundLS0mquKMDiCLwAKrRs2TJ17dpVmZmZSkpK0l//+lcNHz5cq1atUteuXfXuu+9We+zKAu+wYcN05swZtW7d+hIqr3/OnDmjJ598skrHEHh/cvToUS1YsEAPPPBAuX3u7u5atGiRFi1apJdeekn33nuvdu7cqbvvvls333yzCgsLnVCxo549e+rMmTPq2bOnva0mvrejRo3Sq6++qpMnT15ihcD/hgbOLgBA/bN7924NGzZMbdq00SeffKLmzZvb940bN049evTQsGHDtHnzZrVp06bGXtfV1VWurq41Nl594eHh4ewSqqyoqEienp7OLkNvvPGGGjRooH79+pXb16BBA913330Obc8995ymTJmiSZMmacSIEVqyZEldlVohFxeXWvn+DxgwQGPHjtXSpUv1xz/+scbHB6yGO7wAynnhhRd0+vRpvfbaaw5hV5L8/Pz06quvqqioSNOmTbO3l/1T//bt2zVw4EB5e3vriiuu0Lhx43T27Fl7P5vNpqKiIi1YsMD+z9GJiYmSKp5HWzZFICsrSxEREWrUqJE6depknxO5bNkyderUSR4eHgoPD9fGjRsd6t28ebMSExPVpk0beXh4KCAgQH/84x91/Pjxmr1oF/DrObwnT57U+PHjFRISInd3d7Vo0UK33HKLNmzYIEnq3bu33n//fe3bt89+jUJCQuzHHzlyRMOHD5e/v788PDzUpUsXLViwoNzrHj9+XMOGDZO3t7d8fX2VkJCgr7/+WjabTfPnz7f3S0xMlJeXl3bv3q2+ffuqSZMmGjp0qCTp008/1T333KNWrVrJ3d1dwcHB+tOf/qQzZ844vFbZGDk5Obr99tvl5eWlli1batasWZKkLVu26KabbpKnp6dat26tt95666Ku3fLlyxUZGSkvL6+L6i9JEydOVJ8+fbR06VJ99913Dvs++OAD9ejRQ56enmrSpIluu+22clN0ys7l4MGDiouLk5eXl5o3b64JEyaopKTEoe/bb7+t8PBwNWnSRN7e3urUqZP+8pe/2Pf/eg5vZd/bU6dOydPTU+PGjSt3PgcOHJCrq6vDFIYWLVqoc+fO+te//nXR1wX4X8YdXgDl/Oc//1FISIh69OhR4f6ePXsqJCRE77//frl9AwcOVEhIiNLS0vTFF1/o5Zdf1g8//KCFCxdKkhYtWqT7779f3bp108iRIyVJbdu2vWA9u3bt0r333qtRo0bpvvvu0/Tp09WvXz/NmTNHjz/+uMaMGSNJSktL08CBA7Vjxw65uPz0+/zKlSv1/fffKykpSQEBAdq6datee+01bd26VV988YVsNlu1rtGJEycqbL+YuaMPPPCA3nnnHT300EO66qqrdPz4cX322Wfatm2bunbtqieeeEIFBQU6cOCAXnrpJUmyB74zZ86od+/e2rVrlx566CGFhoZq6dKlSkxMVH5+vj0wlZaWql+/flq3bp1Gjx6tjh076l//+pcSEhIqrOnHH39UTEyMunfvrunTp6tx48aSpKVLl+r06dMaPXq0rrjiCq1bt04zZ87UgQMHtHTpUocxSkpKdOutt6pnz56aNm2a3nzzTT300EPy9PTUE088oaFDh+quu+7SnDlzFB8fr6ioKIWGhlZ6nc6fP68vv/xSo0eP/s1r+mvDhg3TRx99pJUrV+p3v/udpJ/eewkJCYqJidHUqVN1+vRpzZ49W927d9fGjRsdfqkoKSlRTEyMIiMjNX36dH388cd68cUX1bZtW3s9K1eu1JAhQ3TzzTdr6tSpkqRt27ZpzZo1FQZXSZV+b728vHTnnXdqyZIlmjFjhsO/dCxevFjGGPsvIWXCw8Mv27nwQJ0zAPAL+fn5RpLp37//BfvdcccdRpIpLCw0xhiTmppqJJk77rjDod+YMWOMJPP111/b2zw9PU1CQkK5MefNm2ckmT179tjbWrdubSSZzz//3N724YcfGkmmUaNGZt++ffb2V1991Ugyq1atsredPn263OssXrzYSDKffPLJBV+7ImXneaHttttuczhGkklNTbV/7ePjYx588MELvs5tt91mWrduXa49PT3dSDJvvPGGve3cuXMmKirKeHl52b8f//znP40kk56ebu9XUlJibrrpJiPJzJs3z96ekJBgJJmJEyeWe72Krl9aWpqx2WwO175sjOeff97e9sMPP5hGjRoZm81m3n77bXv79u3by12TiuzatctIMjNnziy3LyEhwXh6elZ67MaNG40k86c//ckYY8zJkyeNr6+vGTFihEO/3Nxc4+Pj49Bedi7PPPOMQ99rr73WhIeH278eN26c8fb2Nj/++GOldaxatarce7Ky723Z+/qDDz5waO/cubPp1atXuf7PP/+8kWTy8vIqfX0AP2FKAwAHZQ/BNGnS5IL9yvb/+sGgBx980OHrsWPHSpJWrFhR7ZquuuoqRUVF2b+OjIyUJN10001q1apVufbvv//e3taoUSP7n8+ePatjx47pD3/4gyTZpxBUxz//+U+tXLmy3Obv7/+bx/r6+mrt2rU6dOhQlV93xYoVCggI0JAhQ+xtDRs21P/93//p1KlTWr16taSflq5q2LChRowYYe/n4uJS7vvzSxXdSf3l9SsqKtKxY8d0/fXXyxhTbvqIJN1///32P/v6+qpDhw7y9PTUwIED7e0dOnSQr6+vw/epImXTTpo2bXrBfhUpuyNe9n5euXKl8vPzNWTIEB07dsy+ubq6KjIyUqtWrSo3xq8flOvRo4dDzb6+vioqKtLKlSurXF9FoqOjFRQUpDfffNPe9s0332jz5s3l5ipLP1+XylYMAfAzpjQAcFAWZH/r6e/KgnH79u0dvm7btq1cXFwuaX3bX4ZaSfLx8ZEkBQcHV9j+ww8/2NtOnDihyZMn6+2339aRI0cc+hcUFFS7pp49e8rPz69c+8U8oDRt2jQlJCQoODhY4eHh6tu3r+Lj4y/qAcB9+/apffv29ikbZX7/+9/b95f9NzAw0D41oUy7du0qHLdBgwa68sory7Xn5OQoJSVF//73vx2uq1T++nl4eJSb8+3j46Mrr7yy3NQRHx+fcuNVxhhzUf1+6dSpU5J+fn/u3LlT0k+/JFXE29vb4euKzqVp06YONY8ZM0b/+Mc/dOutt6ply5bq06ePBg4cqNjY2CrXK/30C8nQoUM1e/ZsnT59Wo0bN9abb74pDw8P3XPPPeX6l12X6k7LAf6XEHgBOPDx8VFgYKA2b958wX6bN29Wy5YtywWFX6uJ/xlXtnJDZe2/DEgDBw7U559/rkceeURhYWHy8vJSaWmpYmNjnbZW68CBA9WjRw+9++67+uijj/TCCy9o6tSpWrZsmW699Van1OTu7l4uRJeUlOiWW27RiRMn9Nhjj6ljx47y9PTUwYMHlZiYWO76Xcr3qSJXXHGFJF10MP6lb775RtLPAb+s1kWLFikgIKBc/wYNHP93eDGrhbRo0UKbNm3Shx9+qA8++EAffPCB5s2bp/j4+AofIrwY8fHxeuGFF7R8+XINGTJEb731lm6//Xb7L3O/VHZdKvrFC4AjAi+Acm6//Xa9/vrr+uyzz9S9e/dy+z/99FPt3btXo0aNKrdv586dDg8i7dq1S6WlpQ4PBNXVHakffvhBmZmZmjx5slJSUhxqdLbAwECNGTNGY8aM0ZEjR9S1a1f9+c9/tgfeyq5R69attXnzZpWWljoE1O3bt9v3l/131apV9juFZXbt2nXRNW7ZskXfffedFixYoPj4eHt7Tf0T/m9p1aqVGjVqpD179lT52EWLFslms+mWW26R9PODkS1atFB0dHSN1ejm5qZ+/fqpX79+Ki0t1ZgxY/Tqq6/qqaeeqvRu+oXe/9dcc42uvfZavfnmm7ryyiuVk5OjmTNnVth3z5498vPzK3cnGkB5zOEFUM4jjzyiRo0aadSoUeWW7zpx4oQeeOABNW7cWI888ki5Y8uWoSpT9j/rX9659PT0VH5+fs0X/itld+l+fSfRmR/oUFJSUm4qQIsWLRQUFKTi4mJ7m6enZ4VTLvr27avc3FyH9WV//PFHzZw5U15eXurVq5ckKSYmRufPn9frr79u71daWlru+3MhFV0/Y4zDslu1qWHDhoqIiNBXX31VpeOmTJmijz76SIMGDbJPsYmJiZG3t7eef/55nT9/vtwx1fmY3l//3XBxcVHnzp0lyeF7+WuVfW/LlK0wkZ6eriuuuKLSu/7r1693mNsOoHLc4QVQTvv27bVgwQINHTpUnTp10vDhwxUaGqq9e/fq73//u44dO6bFixdXuJzYnj17dMcddyg2NlbZ2dl64403dO+996pLly72PuHh4fr44481Y8YMBQUFKTQ01P7AWU3y9va2L5F1/vx5tWzZUh999FG17hjWlJMnT+rKK6/U3XffrS5dusjLy0sff/yxvvzyS7344ov2fuHh4VqyZImSk5N13XXXycvLS/369dPIkSP16quvKjExUevXr1dISIjeeecdrVmzRunp6fY5q3FxcerWrZsefvhh7dq1Sx07dtS///1v+3JqF3OXvWPHjmrbtq0mTJiggwcPytvbW//85z+rNcWguvr3768nnnhChYWF5abP/Pjjj3rjjTck/fRA4r59+/Tvf/9bmzdv1o033qjXXnvN3tfb21uzZ8/WsGHD1LVrVw0ePFjNmzdXTk6O3n//fd1www165ZVXqlTb/fffrxMnTuimm27SlVdeqX379mnmzJkKCwuzz6muSGXf2zL33nuvHn30Ub377rsaPXq0GjZsWG6MI0eOaPPmzRd8CBHALzhvgQgA9d3mzZvNkCFDTGBgoGnYsKEJCAgwQ4YMMVu2bCnXt2y5rm+//dbcfffdpkmTJqZp06bmoYceMmfOnHHou337dtOzZ0/TqFEjI8m+RFlly5L9epkvY35a6uvXS3vt2bPHSDIvvPCCve3AgQPmzjvvNL6+vsbHx8fcc8895tChQ+WWxarqsmRHjx6tcH9F9f7ytYqLi80jjzxiunTpYpo0aWI8PT1Nly5dzF//+leHY06dOmXuvfde4+vrayQ5LGOVl5dnkpKSjJ+fn3FzczOdOnVyWGaszNGjR829995rmjRpYnx8fExiYqJZs2aNkeSwTNiFlvj69ttvTXR0tPHy8jJ+fn5mxIgR5uuvv65wabOKxujVq5e5+uqrL+o6VSQvL880aNDALFq0yKG9bOmwsq1x48YmJCTEDBgwwLzzzjumpKSkwvFWrVplYmJijI+Pj/Hw8DBt27Y1iYmJ5quvvvrNcyn73pd55513TJ8+fUyLFi2Mm5ubadWqlRk1apQ5fPiww+vpV8uSXeh7W6Zv377lluP7pdmzZ5vGjRvbl6EDcGE2Y6rx+CsA/MrTTz+tyZMn6+jRozxEU48tX75cd955pz777DPdcMMNzi7nogwfPlzfffedPv30U2eXUmfuvPNObdmypdI519dee6169+5t//AKABfGHF4AsKhff/xvSUmJZs6cKW9vb3Xt2tVJVVVdamqqvvzyS61Zs8bZpdSJw4cP6/3339ewYcMq3J+RkaGdO3dq0qRJdVwZcPliDi8AWNTYsWN15swZRUVFqbi4WMuWLdPnn3+u559/3uEDJeq7Vq1a6ezZs84uo9bt2bNHa9as0d/+9jc1bNiwwlVQJCk2Nta+zjCAi0PgBQCLuummm/Tiiy/qvffe09mzZ9WuXTvNnDlTDz30kLNLQwVWr16tpKQktWrVSgsWLKhwvWAA1cMcXgAAAFgac3gBAABgaQReAAAAWBpzeCtQWlqqQ4cOqUmTJnX2EagAAAC4eMYYnTx5UkFBQQ4ftV4RAm8FDh06pODgYGeXAQAAgN+wf/9+XXnllRfsQ+CtQNlHc+7fv7/cR1kCAADA+QoLCxUcHGzPbRdC4K1A2TQGb29vAi8AAEA9djHTT3loDQAAAJZG4AUAAIClEXgBAABgaQReAAAAWBqBFwAAAJZG4AUAAIClEXgBAABgaQReAAAAWBqBFwAAAJZG4AUAAIClEXgBAABgaQReAAAAWBqBFwAAAJZG4AUAAIClEXgBAABgaQ2cXQAAoG7YJtucXQIuMybVOLsEoEZwhxcAAACWRuAFAACApRF4AQAAYGkEXgAAAFgagRcAAACWRuAFAACApRF4AQAAYGkEXgAAAFgagRcAAACWRuAFAACApRF4AQAAYGkEXgAAAFgagRcAAACWRuAFAACApRF4AQAAYGkEXgAAAFgagRcAAACWRuAFAACApdWLwDtr1iyFhITIw8NDkZGRWrdu3UUd9/bbb8tmsykuLs6h3RijlJQUBQYGqlGjRoqOjtbOnTtroXIAAADUd04PvEuWLFFycrJSU1O1YcMGdenSRTExMTpy5MgFj9u7d68mTJigHj16lNs3bdo0vfzyy5ozZ47Wrl0rT09PxcTE6OzZs7V1GgAAAKinnB54Z8yYoREjRigpKUlXXXWV5syZo8aNG2vu3LmVHlNSUqKhQ4dq8uTJatOmjcM+Y4zS09P15JNPqn///urcubMWLlyoQ4cOafny5bV8NgAAAKhvnBp4z507p/Xr1ys6Otre5uLioujoaGVnZ1d63DPPPKMWLVpo+PDh5fbt2bNHubm5DmP6+PgoMjKy0jGLi4tVWFjosAEAAMAanBp4jx07ppKSEvn7+zu0+/v7Kzc3t8JjPvvsM/3973/X66+/XuH+suOqMmZaWpp8fHzsW3BwcFVPBQAAAPWU06c0VMXJkyc1bNgwvf766/Lz86uxcSdNmqSCggL7tn///hobGwAAAM7VwJkv7ufnJ1dXV+Xl5Tm05+XlKSAgoFz/3bt3a+/everXr5+9rbS0VJLUoEED7dixw35cXl6eAgMDHcYMCwursA53d3e5u7tf6ukAAACgHnLqHV43NzeFh4crMzPT3lZaWqrMzExFRUWV69+xY0dt2bJFmzZtsm933HGHbrzxRm3atEnBwcEKDQ1VQECAw5iFhYVau3ZthWMCAADA2px6h1eSkpOTlZCQoIiICHXr1k3p6ekqKipSUlKSJCk+Pl4tW7ZUWlqaPDw8dM011zgc7+vrK0kO7ePHj9dzzz2n9u3bKzQ0VE899ZSCgoLKrdcLAAAA63N64B00aJCOHj2qlJQU5ebmKiwsTBkZGfaHznJycuTiUrUb0Y8++qiKioo0cuRI5efnq3v37srIyJCHh0dtnAIAAADqMZsxxji7iPqmsLBQPj4+KigokLe3t7PLAYAaYZtsc3YJuMyYVCIC6q+q5LXLapUGAAAAoKoIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAAS6sXgXfWrFkKCQmRh4eHIiMjtW7dukr7Llu2TBEREfL19ZWnp6fCwsK0aNEihz6JiYmy2WwOW2xsbG2fBgAAAOqhBs4uYMmSJUpOTtacOXMUGRmp9PR0xcTEaMeOHWrRokW5/s2aNdMTTzyhjh07ys3NTe+9956SkpLUokULxcTE2PvFxsZq3rx59q/d3d3r5HwAAABQvzj9Du+MGTM0YsQIJSUl6aqrrtKcOXPUuHFjzZ07t8L+vXv31p133qnf//73atu2rcaNG6fOnTvrs88+c+jn7u6ugIAA+9a0adO6OB0AAADUM04NvOfOndP69esVHR1tb3NxcVF0dLSys7N/83hjjDIzM7Vjxw717NnTYV9WVpZatGihDh06aPTo0Tp+/Hil4xQXF6uwsNBhAwAAgDU4dUrDsWPHVFJSIn9/f4d2f39/bd++vdLjCgoK1LJlSxUXF8vV1VV//etfdcstt9j3x8bG6q677lJoaKh2796txx9/XLfeequys7Pl6upabry0tDRNnjy55k4MAAAA9YbT5/BWR5MmTbRp0yadOnVKmZmZSk5OVps2bdS7d29J0uDBg+19O3XqpM6dO6tt27bKysrSzTffXG68SZMmKTk52f51YWGhgoODa/08AAAAUPucGnj9/Pzk6uqqvLw8h/a8vDwFBARUepyLi4vatWsnSQoLC9O2bduUlpZmD7y/1qZNG/n5+WnXrl0VBl53d3ceagMAALAop87hdXNzU3h4uDIzM+1tpaWlyszMVFRU1EWPU1paquLi4kr3HzhwQMePH1dgYOAl1QsAAIDLj9OnNCQnJyshIUERERHq1q2b0tPTVVRUpKSkJElSfHy8WrZsqbS0NEk/zbeNiIhQ27ZtVVxcrBUrVmjRokWaPXu2JOnUqVOaPHmyBgwYoICAAO3evVuPPvqo2rVr57BsGQAAAP43OD3wDho0SEePHlVKSopyc3MVFhamjIwM+4NsOTk5cnH5+UZ0UVGRxowZowMHDqhRo0bq2LGj3njjDQ0aNEiS5Orqqs2bN2vBggXKz89XUFCQ+vTpo2effZZpCwAAAP+DbMYY4+wi6pvCwkL5+PiooKBA3t7ezi4HAGqEbbLN2SXgMmNSiQiov6qS15z+wRMAAABAbSLwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsrV4E3lmzZikkJEQeHh6KjIzUunXrKu27bNkyRUREyNfXV56engoLC9OiRYsc+hhjlJKSosDAQDVq1EjR0dHauXNnbZ8GAAAA6iGnB94lS5YoOTlZqamp2rBhg7p06aKYmBgdOXKkwv7NmjXTE088oezsbG3evFlJSUlKSkrShx9+aO8zbdo0vfzyy5ozZ47Wrl0rT09PxcTE6OzZs3V1WgAAAKgnbMYY48wCIiMjdd111+mVV16RJJWWlio4OFhjx47VxIkTL2qMrl276rbbbtOzzz4rY4yCgoL08MMPa8KECZKkgoIC+fv7a/78+Ro8ePBvjldYWCgfHx8VFBTI29u7+icHAPWIbbLN2SXgMmNSnRoRgAuqSl5z6h3ec+fOaf369YqOjra3ubi4KDo6WtnZ2b95vDFGmZmZ2rFjh3r27ClJ2rNnj3Jzcx3G9PHxUWRkZKVjFhcXq7Cw0GEDAACANTg18B47dkwlJSXy9/d3aPf391dubm6lxxUUFMjLy0tubm667bbbNHPmTN1yyy2SZD+uKmOmpaXJx8fHvgUHB1/KaQEAAKAecfoc3upo0qSJNm3apC+//FJ//vOflZycrKysrGqPN2nSJBUUFNi3/fv311yxAAAAcKoGznxxPz8/ubq6Ki8vz6E9Ly9PAQEBlR7n4uKidu3aSZLCwsK0bds2paWlqXfv3vbj8vLyFBgY6DBmWFhYheO5u7vL3d39Es8GAAAA9ZFT7/C6ubkpPDxcmZmZ9rbS0lJlZmYqKirqoscpLS1VcXGxJCk0NFQBAQEOYxYWFmrt2rVVGhMAAADW4NQ7vJKUnJyshIQERUREqFu3bkpPT1dRUZGSkpIkSfHx8WrZsqXS0tIk/TTfNiIiQm3btlVxcbFWrFihRYsWafbs2ZIkm82m8ePH67nnnlP79u0VGhqqp556SkFBQYqLi3PWaQIAAMBJnB54Bw0apKNHjyolJUW5ubkKCwtTRkaG/aGznJwcubj8fCO6qKhIY8aM0YEDB9SoUSN17NhRb7zxhgYNGmTv8+ijj6qoqEgjR45Ufn6+unfvroyMDHl4eNT5+QEAAMC5nL4Ob33EOrwArIh1eFFVrMOL+uyyWYcXAAAAqG0EXgAAAFgagRcAAACWRuAFAACApRF4AQAAYGkEXgAAAFgagRcAAACWRuAFAACApRF4AQAAYGkEXgAAAFgagRcAAACWRuAFAACApRF4AQAAYGkEXgAAAFgagRcAAACW1sDZBQCoHttkm7NLAADgssAdXgAAAFgagRcAAACWRuAFAACApRF4AQAAYGkEXgAAAFgagRcAAACWRuAFAACApRF4AQAAYGkEXgAAAFgagRcAAACWRuAFAACApRF4AQAAYGkEXgAAAFgagRcAAACWRuAFAACApRF4AQAAYGn1IvDOmjVLISEh8vDwUGRkpNatW1dp39dff109evRQ06ZN1bRpU0VHR5frn5iYKJvN5rDFxsbW9mkAAACgHnJ64F2yZImSk5OVmpqqDRs2qEuXLoqJidGRI0cq7J+VlaUhQ4Zo1apVys7OVnBwsPr06aODBw869IuNjdXhw4ft2+LFi+vidAAAAFDP2IwxxpkFREZG6rrrrtMrr7wiSSotLVVwcLDGjh2riRMn/ubxJSUlatq0qV555RXFx8dL+ukOb35+vpYvX16tmgoLC+Xj46OCggJ5e3tXawygttkm25xdAgCLM6lOjQjABVUlr1XrDu/3339frcJ+7dy5c1q/fr2io6N/LsjFRdHR0crOzr6oMU6fPq3z58+rWbNmDu1ZWVlq0aKFOnTooNGjR+v48eOVjlFcXKzCwkKHDQAAANZQrcDbrl073XjjjXrjjTd09uzZar/4sWPHVFJSIn9/f4d2f39/5ebmXtQYjz32mIKCghxCc2xsrBYuXKjMzExNnTpVq1ev1q233qqSkpIKx0hLS5OPj499Cw4OrvY5AQAAoH6pVuDdsGGDOnfurOTkZAUEBGjUqFEXfNCstkyZMkVvv/223n33XXl4eNjbBw8erDvuuEOdOnVSXFyc3nvvPX355ZfKysqqcJxJkyapoKDAvu3fv7+OzgAAAAC1rVqBNywsTH/5y1906NAhzZ07V4cPH1b37t11zTXXaMaMGTp69OhFjePn5ydXV1fl5eU5tOfl5SkgIOCCx06fPl1TpkzRRx99pM6dO1+wb5s2beTn56ddu3ZVuN/d3V3e3t4OGwAAAKzhklZpaNCgge666y4tXbpUU6dO1a5duzRhwgQFBwcrPj5ehw8fvuDxbm5uCg8PV2Zmpr2ttLRUmZmZioqKqvS4adOm6dlnn1VGRoYiIiJ+s84DBw7o+PHjCgwMvPiTAwAAgCVcUuD96quvNGbMGAUGBmrGjBmaMGGCdu/erZUrV+rQoUPq37//b46RnJys119/XQsWLNC2bds0evRoFRUVKSkpSZIUHx+vSZMm2ftPnTpVTz31lObOnauQkBDl5uYqNzdXp06dkiSdOnVKjzzyiL744gvt3btXmZmZ6t+/v9q1a6eYmJhLOV0AAABchhpU56AZM2Zo3rx52rFjh/r27auFCxeqb9++cnH5KT+HhoZq/vz5CgkJ+c2xBg0apKNHjyolJUW5ubkKCwtTRkaG/UG2nJwc+7iSNHv2bJ07d0533323wzipqal6+umn5erqqs2bN2vBggXKz89XUFCQ+vTpo2effVbu7u7VOV0AAABcxqq1Dm/79u31xz/+UYmJiZVOEzh37pwWL16shISESy6yrrEOLy4HrMMLoLaxDi/qs6rktWrd4V25cqVatWrlcOdVkowx2r9/v1q1aiU3N7fLMuwCAADAWqo1h7dt27Y6duxYufYTJ04oNDT0kosCAAAAakq1Am9lsyBOnTrlsB4uAAAA4GxVmtKQnJwsSbLZbEpJSVHjxo3t+0pKSrR27VqFhYXVaIEAAADApahS4N24caOkn+7wbtmyRW5ubvZ9bm5u6tKliyZMmFCzFQIAAACXoEqBd9WqVZKkpKQk/eUvf2EFAwAAANR71VqlYd68eTVdBwAAAFArLjrw3nXXXZo/f768vb111113XbDvsmXLLrkwAAAAoCZcdOD18fGRzWaz/xkAAAC4HFx04P3lNAamNAAAAOByUa11eM+cOaPTp0/bv963b5/S09P10Ucf1VhhAAAAQE2oVuDt37+/Fi5cKEnKz89Xt27d9OKLL6p///6aPXt2jRYIAAAAXIpqBd4NGzaoR48ekqR33nlHAQEB2rdvnxYuXKiXX365RgsEAAAALkW1Au/p06fVpEkTSdJHH32ku+66Sy4uLvrDH/6gffv21WiBAAAAwKWoVuBt166dli9frv379+vDDz9Unz59JElHjhzhwygAAABQr1Qr8KakpGjChAkKCQlRZGSkoqKiJP10t/faa6+t0QIBAACAS1GtT1q7++671b17dx0+fFhdunSxt99888268847a6w4AAAA4FJVK/BKUkBAgAICAhzaunXrdskFAQAAADWpWoG3qKhIU6ZMUWZmpo4cOaLS0lKH/d9//32NFAcAAABcqmoF3vvvv1+rV6/WsGHDFBgYaP/IYQAAAKC+qVbg/eCDD/T+++/rhhtuqOl6AAAAgBpVrVUamjZtqmbNmtV0LQAAAECNq1bgffbZZ5WSkqLTp0/XdD0AAABAjarWlIYXX3xRu3fvlr+/v0JCQtSwYUOH/Rs2bKiR4gAAAIBLVa3AGxcXV8NlAAAAALWjWoE3NTW1pusAAAAAakW15vBKUn5+vv72t79p0qRJOnHihKSfpjIcPHiwxooDAAAALlW17vBu3rxZ0dHR8vHx0d69ezVixAg1a9ZMy5YtU05OjhYuXFjTdQIAAADVUq07vMnJyUpMTNTOnTvl4eFhb+/bt68++eSTGisOAAAAuFTVusP75Zdf6tVXXy3X3rJlS+Xm5l5yUQAAwPlsk/kkVVSNSTXOLqFC1brD6+7ursLCwnLt3333nZo3b37JRQEAAAA1pVqB94477tAzzzyj8+fPS5JsNptycnL02GOPacCAATVaIAAAAHApqhV4X3zxRZ06dUrNmzfXmTNn1KtXL7Vr105NmjTRn//85yqPN2vWLIWEhMjDw0ORkZFat25dpX1ff/119ejRQ02bNlXTpk0VHR1drr8xRikpKQoMDFSjRo0UHR2tnTt3VrkuAAAAXP6qFXh9fHy0cuVKvf/++3r55Zf10EMPacWKFVq9erU8PT2rNNaSJUuUnJys1NRUbdiwQV26dFFMTIyOHDlSYf+srCwNGTJEq1atUnZ2toKDg9WnTx+H5dCmTZuml19+WXPmzNHatWvl6empmJgYnT17tjqnCwAAgMuYzRhTpdnFpaWlmj9/vpYtW6a9e/fKZrMpNDRUd999t4YNGyabrWoT3CMjI3XdddfplVdesY8fHByssWPHauLEib95fElJiZo2bapXXnlF8fHxMsYoKChIDz/8sCZMmCBJKigokL+/v+bPn6/Bgwf/5piFhYXy8fFRQUGBvL29q3Q+QF3hYRIAQH1Tlw+tVSWvVekOrzFGd9xxh+6//34dPHhQnTp10tVXX619+/YpMTFRd955Z5UKPXfunNavX6/o6OifC3JxUXR0tLKzsy9qjNOnT+v8+fNq1qyZJGnPnj3Kzc11GNPHx0eRkZGVjllcXKzCwkKHDQAAANZQpWXJ5s+fr08++USZmZm68cYbHfb997//VVxcnBYuXKj4+PiLGu/YsWMqKSmRv7+/Q7u/v7+2b99+UWM89thjCgoKsgfcsmXRKhqzsiXT0tLSNHny5It6PQAAAFxeqnSHd/HixXr88cfLhV1JuummmzRx4kS9+eabNVbcb5kyZYrefvttvfvuuw4fgFFVkyZNUkFBgX3bv39/DVYJAAAAZ6pS4N28ebNiY2Mr3X/rrbfq66+/vujx/Pz85Orqqry8PIf2vLw8BQQEXPDY6dOna8qUKfroo4/UuXNne3vZcVUZ093dXd7e3g4bAAAArKFKgffEiRPlpgr8kr+/v3744YeLHs/NzU3h4eHKzMy0t5WWliozM1NRUVGVHjdt2jQ9++yzysjIUEREhMO+0NBQBQQEOIxZWFiotWvXXnBMAAAAWFOV5vCWlJSoQYPKD3F1ddWPP/5YpQKSk5OVkJCgiIgIdevWTenp6SoqKlJSUpIkKT4+Xi1btlRaWpokaerUqUpJSdFbb72lkJAQ+7xcLy8veXl5yWazafz48XruuefUvn17hYaG6qmnnlJQUJDi4uKqVBsAAAAuf1UKvMYYJSYmyt3dvcL9xcXFVS5g0KBBOnr0qFJSUpSbm6uwsDBlZGTY7yTn5OTIxeXnG9GzZ8/WuXPndPfddzuMk5qaqqefflqS9Oijj6qoqEgjR45Ufn6+unfvroyMjEua5wsAAIDLU5XW4S276/pb5s2bV+2C6gPW4cXlgHV4AQD1TX1dh7dKd3gv9yALAACA/z3V+mhhAAAA4HJB4AUAAIClEXgBAABgaQReAAAAWBqBFwAAAJZG4AUAAIClEXgBAABgaQReAAAAWBqBFwAAAJZG4AUAAIClEXgBAABgaQReAAAAWBqBFwAAAJZG4AUAAIClEXgBAABgaQReAAAAWBqBFwAAAJZG4AUAAIClEXgBAABgaQReAAAAWBqBFwAAAJZG4AUAAIClEXgBAABgaQReAAAAWBqBFwAAAJZG4AUAAIClEXgBAABgaQReAAAAWBqBFwAAAJZG4AUAAIClEXgBAABgaU4PvLNmzVJISIg8PDwUGRmpdevWVdp369atGjBggEJCQmSz2ZSenl6uz9NPPy2bzeawdezYsRbPAAAAAPWZUwPvkiVLlJycrNTUVG3YsEFdunRRTEyMjhw5UmH/06dPq02bNpoyZYoCAgIqHffqq6/W4cOH7dtnn31WW6cAAACAes6pgXfGjBkaMWKEkpKSdNVVV2nOnDlq3Lix5s6dW2H/6667Ti+88IIGDx4sd3f3Ssdt0KCBAgIC7Jufn19tnQIAAADqOacF3nPnzmn9+vWKjo7+uRgXF0VHRys7O/uSxt65c6eCgoLUpk0bDR06VDk5ORfsX1xcrMLCQocNAAAA1uC0wHvs2DGVlJTI39/fod3f31+5ubnVHjcyMlLz589XRkaGZs+erT179qhHjx46efJkpcekpaXJx8fHvgUHB1f79QEAAFC/OP2htZp266236p577lHnzp0VExOjFStWKD8/X//4xz8qPWbSpEkqKCiwb/v376/DigEAAFCbGjjrhf38/OTq6qq8vDyH9ry8vAs+kFZVvr6++t3vfqddu3ZV2sfd3f2Cc4IBAABw+XLaHV43NzeFh4crMzPT3lZaWqrMzExFRUXV2OucOnVKu3fvVmBgYI2NCQAAgMuH0+7wSlJycrISEhIUERGhbt26KT09XUVFRUpKSpIkxcfHq2XLlkpLS5P004Nu3377rf3PBw8e1KZNm+Tl5aV27dpJkiZMmKB+/fqpdevWOnTokFJTU+Xq6qohQ4Y45yQBAADgVE4NvIMGDdLRo0eVkpKi3NxchYWFKSMjw/4gW05Ojlxcfr4JfejQIV177bX2r6dPn67p06erV69eysrKkiQdOHBAQ4YM0fHjx9W8eXN1795dX3zxhZo3b16n5wYAAID6wWaMMc4uor4pLCyUj4+PCgoK5O3t7exygArZJtucXQIAAA5Mat3FyqrkNcut0gAAAAD8EoEXAAAAlkbgBQAAgKUReAEAAGBpBF4AAABYGoEXAAAAlkbgBQAAgKUReAEAAGBpBF4AAABYGoEXAAAAlkbgBQAAgKUReAEAAGBpBF4AAABYGoEXAAAAlkbgBQAAgKUReAEAAGBpBF4AAABYGoEXAAAAlkbgBQAAgKUReAEAAGBpBF4AAABYGoEXAAAAlkbgBQAAgKUReAEAAGBpBF4AAABYGoEXAAAAlkbgBQAAgKUReAEAAGBpBF4AAABYGoEXAAAAlkbgBQAAgKUReAEAAGBpTg+8s2bNUkhIiDw8PBQZGal169ZV2nfr1q0aMGCAQkJCZLPZlJ6efsljAgAAwNqcGniXLFmi5ORkpaamasOGDerSpYtiYmJ05MiRCvufPn1abdq00ZQpUxQQEFAjYwIAAMDanBp4Z8yYoREjRigpKUlXXXWV5syZo8aNG2vu3LkV9r/uuuv0wgsvaPDgwXJ3d6+RMQEAAGBtTgu8586d0/r16xUdHf1zMS4uio6OVnZ2dp2OWVxcrMLCQocNAAAA1uC0wHvs2DGVlJTI39/fod3f31+5ubl1OmZaWpp8fHzsW3BwcLVeHwAAAPWP0x9aqw8mTZqkgoIC+7Z//35nlwQAAIAa0sBZL+zn5ydXV1fl5eU5tOfl5VX6QFptjenu7l7pnGAAAABc3px2h9fNzU3h4eHKzMy0t5WWliozM1NRUVH1ZkwAAABc3px2h1eSkpOTlZCQoIiICHXr1k3p6ekqKipSUlKSJCk+Pl4tW7ZUWlqapJ8eSvv222/tfz548KA2bdokLy8vtWvX7qLGBAAAwP8WpwbeQYMG6ejRo0pJSVFubq7CwsKUkZFhf+gsJydHLi4/34Q+dOiQrr32WvvX06dP1/Tp09WrVy9lZWVd1JgAAAD432IzxhhnF1HfFBYWysfHRwUFBfL29nZ2OUCFbJNtzi4BAAAHJrXuYmVV8ppT7/DiZ4QXAACA2sGyZAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAASyPwAgAAwNIIvAAAALA0Ai8AAAAsjcALAAAAS6sXgXfWrFkKCQmRh4eHIiMjtW7dugv2X7p0qTp27CgPDw916tRJK1ascNifmJgom83msMXGxtbmKQAAAKCecnrgXbJkiZKTk5WamqoNGzaoS5cuiomJ0ZEjRyrs//nnn2vIkCEaPny4Nm7cqLi4OMXFxembb75x6BcbG6vDhw/bt8WLF9fF6QAAAKCesRljjDMLiIyM1HXXXadXXnlFklRaWqrg4GCNHTtWEydOLNd/0KBBKioq0nvvvWdv+8Mf/qCwsDDNmTNH0k93ePPz87V8+fJq1VRYWCgfHx8VFBTI29u7WmNUlW2yrU5eBwAAoLaY1LqLlVXJa069w3vu3DmtX79e0dHR9jYXFxdFR0crOzu7wmOys7Md+ktSTExMuf5ZWVlq0aKFOnTooNGjR+v48eOV1lFcXKzCwkKHDQAAANbg1MB77NgxlZSUyN/f36Hd399fubm5FR6Tm5v7m/1jY2O1cOFCZWZmaurUqVq9erVuvfVWlZSUVDhmWlqafHx87FtwcPAlnhkAAADqiwbOLqA2DB482P7nTp06qXPnzmrbtq2ysrJ08803l+s/adIkJScn278uLCwk9AIAAFiEU+/w+vn5ydXVVXl5eQ7teXl5CggIqPCYgICAKvWXpDZt2sjPz0+7du2qcL+7u7u8vb0dNgAAAFiDUwOvm5ubwsPDlZmZaW8rLS1VZmamoqKiKjwmKirKob8krVy5stL+knTgwAEdP35cgYGBNVM4AAAALhtOX5YsOTlZr7/+uhYsWKBt27Zp9OjRKioqUlJSkiQpPj5ekyZNsvcfN26cMjIy9OKLL2r79u16+umn9dVXX+mhhx6SJJ06dUqPPPKIvvjiC+3du1eZmZnq37+/2rVrp5iYGKecIwAAAJzH6XN4Bw0apKNHjyolJUW5ubkKCwtTRkaG/cG0nJwcubj8nMuvv/56vfXWW3ryySf1+OOPq3379lq+fLmuueYaSZKrq6s2b96sBQsWKD8/X0FBQerTp4+effZZubu7O+UcAQAA4DxOX4e3PmIdXgAAgKpjHV4AAADACQi8AAAAsDQCLwAAACyNwAsAAABLI/ACAADA0gi8AAAAsDQCLwAAACyNwAsAAABLI/ACAADA0gi8AAAAsDQCLwAAACyNwAsAAABLI/ACAADA0gi8AAAAsDQCLwAAACyNwAsAAABLI/ACAADA0gi8AAAAsDQCLwAAACyNwAsAAABLI/ACAADA0gi8AAAAsDQCLwAAACyNwAsAAABLI/ACAADA0gi8AAAAsDQCLwAAACyNwAsAAABLI/ACAADA0gi8AAAAsDQCLwAAACyNwAsAAABLqxeBd9asWQoJCZGHh4ciIyO1bt26C/ZfunSpOnbsKA8PD3Xq1EkrVqxw2G+MUUpKigIDA9WoUSNFR0dr586dtXkKAAAAqKecHniXLFmi5ORkpaamasOGDerSpYtiYmJ05MiRCvt//vnnGjJkiIYPH66NGzcqLi5OcXFx+uabb+x9pk2bppdffllz5szR2rVr5enpqZiYGJ09e7auTgsAAAD1hM0YY5xZQGRkpK677jq98sorkqTS0lIFBwdr7NixmjhxYrn+gwYNUlFRkd577z172x/+8AeFhYVpzpw5MsYoKChIDz/8sCZMmCBJKigokL+/v+bPn6/Bgwf/Zk2FhYXy8fFRQUGBvL29a+hML8w22VYnrwMAAFBbTGrdxcqq5LUGdVRThc6dO6f169dr0qRJ9jYXFxdFR0crOzu7wmOys7OVnJzs0BYTE6Ply5dLkvbs2aPc3FxFR0fb9/v4+CgyMlLZ2dkVBt7i4mIVFxfbvy4oKJD004WsM9x8BgAAl7m6zE5lr3Ux926dGniPHTumkpIS+fv7O7T7+/tr+/btFR6Tm5tbYf/c3Fz7/rK2yvr8WlpamiZPnlyuPTg4+OJOBAAAAPKZ4lPnr3ny5En5+Fz4dZ0aeOuLSZMmOdw1Li0t1YkTJ3TFFVfIZqv9qQaFhYUKDg7W/v3762wKxeWCa1MxrkvluDYV47pUjOtSOa5Nxbgulavra2OM0cmTJxUUFPSbfZ0aeP38/OTq6qq8vDyH9ry8PAUEBFR4TEBAwAX7l/03Ly9PgYGBDn3CwsIqHNPd3V3u7u4Obb6+vlU5lRrh7e3NX55KcG0qxnWpHNemYlyXinFdKse1qRjXpXJ1eW1+685uGaeu0uDm5qbw8HBlZmba20pLS5WZmamoqKgKj4mKinLoL0krV6609w8NDVVAQIBDn8LCQq1du7bSMQEAAGBdTp/SkJycrISEBEVERKhbt25KT09XUVGRkpKSJEnx8fFq2bKl0tLSJEnjxo1Tr1699OKLL+q2227T22+/ra+++kqvvfaaJMlms2n8+PF67rnn1L59e4WGhuqpp55SUFCQ4uLinHWaAAAAcBKnB95Bgwbp6NGjSklJUW5ursLCwpSRkWF/6CwnJ0cuLj/fiL7++uv11ltv6cknn9Tjjz+u9u3ba/ny5brmmmvsfR599FEVFRVp5MiRys/PV/fu3ZWRkSEPD486P7+L4e7urtTU1HLTKsC1qQzXpXJcm4pxXSrGdakc16ZiXJfK1edr4/R1eAEAAIDa5PRPWgMAAABqE4EXAAAAlkbgBQAAgKUReAEAAGBpBF4n2Lt3r4YPH67Q0FA1atRIbdu2VWpqqs6dO3fB486ePasHH3xQV1xxhby8vDRgwIByH8Jxufvzn/+s66+/Xo0bN77oD/9ITEyUzWZz2GJjY2u3UCeozrUxxiglJUWBgYFq1KiRoqOjtXPnztottI6dOHFCQ4cOlbe3t3x9fTV8+HCdOnXqgsf07t273HvmgQceqKOKa8+sWbMUEhIiDw8PRUZGat26dRfsv3TpUnXs2FEeHh7q1KmTVqxYUUeV1q2qXJf58+eXe2/U1xV+LsUnn3yifv36KSgoSDabTcuXL//NY7KystS1a1e5u7urXbt2mj9/fq3X6QxVvTZZWVnl3jM2m025ubl1U3AdSUtL03XXXacmTZqoRYsWiouL044dO37zuPryc4bA6wTbt29XaWmpXn31VW3dulUvvfSS5syZo8cff/yCx/3pT3/Sf/7zHy1dulSrV6/WoUOHdNddd9VR1XXj3LlzuueeezR69OgqHRcbG6vDhw/bt8WLF9dShc5TnWszbdo0vfzyy5ozZ47Wrl0rT09PxcTE6OzZs7VYad0aOnSotm7dqpUrV+q9997TJ598opEjR/7mcSNGjHB4z0ybNq0Oqq09S5YsUXJyslJTU7VhwwZ16dJFMTExOnLkSIX9P//8cw0ZMkTDhw/Xxo0bFRcXp7i4OH3zzTd1XHntqup1kX76lKhfvjf27dtXhxXXjaKiInXp0kWzZs26qP579uzRbbfdphtvvFGbNm3S+PHjdf/99+vDDz+s5UrrXlWvTZkdO3Y4vG9atGhRSxU6x+rVq/Xggw/qiy++0MqVK3X+/Hn16dNHRUVFlR5Tr37OGNQL06ZNM6GhoZXuz8/PNw0bNjRLly61t23bts1IMtnZ2XVRYp2aN2+e8fHxuai+CQkJpn///rVaT31ysdemtLTUBAQEmBdeeMHelp+fb9zd3c3ixYtrscK68+233xpJ5ssvv7S3ffDBB8Zms5mDBw9WelyvXr3MuHHj6qDCutOtWzfz4IMP2r8uKSkxQUFBJi0trcL+AwcONLfddptDW2RkpBk1alSt1lnXqnpdqvKzxyokmXffffeCfR599FFz9dVXO7QNGjTIxMTE1GJlzncx12bVqlVGkvnhhx/qpKb64siRI0aSWb16daV96tPPGe7w1hMFBQVq1qxZpfvXr1+v8+fPKzo62t7WsWNHtWrVStnZ2XVRYr2WlZWlFi1aqEOHDho9erSOHz/u7JKcbs+ePcrNzXV4z/j4+CgyMtIy75ns7Gz5+voqIiLC3hYdHS0XFxetXbv2gse++eab8vPz0zXXXKNJkybp9OnTtV1urTl37pzWr1/v8L12cXFRdHR0pd/r7Oxsh/6SFBMTY5n3hlS96yJJp06dUuvWrRUcHKz+/ftr69atdVFuvfa/8H65VGFhYQoMDNQtt9yiNWvWOLucWldQUCBJF8wu9el94/RPWoO0a9cuzZw5U9OnT6+0T25urtzc3MrN3fT397fcPKGqio2N1V133aXQ0FDt3r1bjz/+uG699VZlZ2fL1dXV2eU5Tdn7ouxTC8tY6T2Tm5tb7p8NGzRooGbNml3wHO+99161bt1aQUFB2rx5sx577DHt2LFDy5Ytq+2Sa8WxY8dUUlJS4fd6+/btFR6Tm5tr6feGVL3r0qFDB82dO1edO3dWQUGBpk+fruuvv15bt27VlVdeWRdl10uVvV8KCwt15swZNWrUyEmVOV9gYKDmzJmjiIgIFRcX629/+5t69+6ttWvXqmvXrs4ur1aUlpZq/PjxuuGGGxw+6fbX6tPPGe7w1qCJEydWOHH9l9uvf8gePHhQsbGxuueeezRixAgnVV67qnNdqmLw4MG644471KlTJ8XFxem9997Tl19+qaysrJo7iVpS29fmclXb12XkyJGKiYlRp06dNHToUC1cuFDvvvuudu/eXYNngctRVFSU4uPjFRYWpl69emnZsmVq3ry5Xn31VWeXhnqqQ4cOGjVqlMLDw3X99ddr7ty5uv766/XSSy85u7Ra8+CDD+qbb77R22+/7exSLhp3eGvQww8/rMTExAv2adOmjf3Phw4d0o033qjrr79er7322gWPCwgI0Llz55Sfn+9wlzcvL08BAQGXUnatq+p1uVRt2rSRn5+fdu3apZtvvrnGxq0NtXltyt4XeXl5CgwMtLfn5eUpLCysWmPWlYu9LgEBAeUePvrxxx914sSJKv29iIyMlPTTv7a0bdu2yvU6m5+fn1xdXcut2nKhnw8BAQFV6n85qs51+bWGDRvq2muv1a5du2qjxMtGZe8Xb2/v/+m7u5Xp1q2bPvvsM2eXUSseeugh+wPCv/WvHvXp5wyBtwY1b95czZs3v6i+Bw8e1I033qjw8HDNmzdPLi4XvtkeHh6uhg0bKjMzUwMGDJD00xOhOTk5ioqKuuTaa1NVrktNOHDggI4fP+4Q8uqr2rw2oaGhCggIUGZmpj3gFhYWau3atVVeBaOuXex1iYqKUn5+vtavX6/w8HBJ0n//+1+VlpbaQ+zF2LRpkyRdFu+Ziri5uSk8PFyZmZmKi4uT9NM/OWZmZuqhhx6q8JioqChlZmZq/Pjx9raVK1fW+58nVVGd6/JrJSUl2rJli/r27VuLldZ/UVFR5ZaTstr7pSZt2rTpsv15UhljjMaOHat3331XWVlZCg0N/c1j6tXPmTp/TA7mwIEDpl27dubmm282Bw4cMIcPH7Zvv+zToUMHs3btWnvbAw88YFq1amX++9//mq+++spERUWZqKgoZ5xCrdm3b5/ZuHGjmTx5svHy8jIbN240GzduNCdPnrT36dChg1m2bJkxxpiTJ0+aCRMmmOzsbLNnzx7z8ccfm65du5r27dubs2fPOus0akVVr40xxkyZMsX4+vqaf/3rX2bz5s2mf//+JjQ01Jw5c8YZp1ArYmNjzbXXXmvWrl1rPvvsM9O+fXszZMgQ+/5f/13atWuXeeaZZ8xXX31l9uzZY/71r3+ZNm3amJ49ezrrFGrE22+/bdzd3c38+fPNt99+a0aOHGl8fX1Nbm6uMcaYYcOGmYkTJ9r7r1mzxjRo0MBMnz7dbNu2zaSmppqGDRuaLVu2OOsUakVVr8vkyZPNhx9+aHbv3m3Wr19vBg8ebDw8PMzWrVuddQq14uTJk/afIZLMjBkzzMaNG82+ffuMMcZMnDjRDBs2zN7/+++/N40bNzaPPPKI2bZtm5k1a5ZxdXU1GRkZzjqFWlPVa/PSSy+Z5cuXm507d5otW7aYcePGGRcXF/Pxxx876xRqxejRo42Pj4/JyspyyC2nT5+296nPP2cIvE4wb948I6nCrcyePXuMJLNq1Sp725kzZ8yYMWNM06ZNTePGjc2dd97pEJKtICEhocLr8svrIMnMmzfPGGPM6dOnTZ8+fUzz5s1Nw4YNTevWrc2IESPs/zOzkqpeG2N+WprsqaeeMv7+/sbd3d3cfPPNZseOHXVffC06fvy4GTJkiPHy8jLe3t4mKSnJ4ZeAX/9dysnJMT179jTNmjUz7u7upl27duaRRx4xBQUFTjqDmjNz5kzTqlUr4+bmZrp162a++OIL+75evXqZhIQEh/7/+Mc/zO9+9zvj5uZmrr76avP+++/XccV1oyrXZfz48fa+/v7+pm/fvmbDhg1OqLp2lS2l9eut7FokJCSYXr16lTsmLCzMuLm5mTZt2jj8rLGSql6bqVOnmrZt2xoPDw/TrFkz07t3b/Pf//7XOcXXospyyy/fB/X554zNGGNq8w4yAAAA4Eys0gAAAABLI/ACAADA0gi8AAAAsDQCLwAAACyNwAsAAABLI/ACAADA0gi8AAAAsDQCLwAAACyNwAsAFte7d2+Hz7IHgP81BF4AqMf69eun2NjYCvd9+umnstls2rx5cx1XBQCXFwIvANRjw4cP18qVK3XgwIFy++bNm6eIiAh17tzZCZUBwOWDwAsA9djtt9+u5s2ba/78+Q7tp06d0tKlSxUXF6chQ4aoZcuWaty4sTp16qTFixdfcEybzably5c7tPn6+jq8xv79+zVw4ED5+vqqWbNm6t+/v/bu3VszJwUAdYzACwD1WIMGDRQfH6/58+fLGGNvX7p0qUpKSnTfffcpPDxc77//vr755huNHDlSw4YN07p166r9mufPn1dMTIyaNGmiTz/9VGvWrJGXl5diY2N17ty5mjgtAKhTBF4AqOf++Mc/avfu3Vq9erW9bd68eRowYIBat26tCRMmKCwsTG3atNHYsWMVGxurf/zjH9V+vSVLlqi0tFR/+9vf1KlTJ/3+97/XvHnzlJOTo6ysrBo4IwCoWwReAKjnOnbsqOuvv15z586VJO3atUuffvqphg8frpKSEj377LPq1KmTmjVrJi8vL3344YfKycmp9ut9/fXX2rVrl5o0aSIvLy95eXmpWbNmOnv2rHbv3l1TpwUAdaaBswsAAPy24cOHa+zYsZo1a5bmzZuntm3bqlevXpo6dar+8pe/KD09XZ06dZKnp6fGjx9/wakHNpvNYXqE9NM0hjKnTp1SeHi43nzzzXLHNm/evOZOCgDqCIEXAC4DAwcO1Lhx4/TWW29p4cKFGj16tGw2m9asWaP+/fvrvvvukySVlpbqu+++01VXXVXpWM2bN9fhw4ftX+/cuVOnT5+2f921a1ctWbJELVq0kLe3d+2dFADUEaY0AMBlwMvLS4MGDdKkSZN0+PBhJSYmSpLat2+vlStX6vPPP9e2bds0atQo5eXlXXCsm266Sa+88oo2btyor776Sg888IAaNmxo3z906FD5+fmpf//++vTTT7Vnzx5lZWXp//7v/ypcHg0A6jsCLwBcJoYPH64ffvhBMTExCgoKkiQ9+eST6tq1q2JiYtS7d28FBAQoLi7uguO8+OKLCg4OVo8ePXTvvfdqwoQJaty4sX1/48aN9cknn6hVq1a666679Pvf/17Dhw/X2bNnueML4LJkM7+eyAUAAABYCHd4AQAAYGkEXgAAAFgagRcAAACWRuAFAACApRF4AQAAYGkEXgAAAFgagRcAAACWRuAFAACApRF4AQAAYGkEXgAAAFgagRcAAACW9v9BPWesQ90JsgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -301,154 +267,155 @@ } ], "source": [ - "# Density plot\n", - "fig, ax = plt.subplots(figsize=(8, 5))\n", - "n, bins, patches = hist(data, density=True, range=(-2, 2), ax=ax, color=\"green\")\n", - "ax.set_xlabel(\"Value\")\n", - "ax.set_ylabel(\"Density\")\n", - "ax.set_title(\"Optimal Histogram (Density)\")\n", + "fig, axes = plt.subplots(1, 2, figsize=(13, 4.5), sharex=True, sharey=True)\n", + "\n", + "axes[0].hist(data, bins=60, density=True, color=\"silver\", edgecolor=\"white\")\n", + "axes[0].set_title(\"Fixed-width bins (60)\")\n", + "axes[0].set_xlabel(\"Value\")\n", + "axes[0].set_ylabel(\"Density\")\n", + "axes[0].set_xscale(\"log\")\n", + "axes[0].set_yscale(\"log\")\n", + "\n", + "hist(data, ax=axes[1], color=\"steelblue\", edgecolor=\"white\", linewidth=0.8)\n", + "axes[1].set_title(f\"Khisto: {len(kh_dens)} adaptive bins\")\n", + "axes[1].set_xlabel(\"Value\")\n", + "axes[1].set_xscale(\"log\")\n", + "axes[1].set_yscale(\"log\")\n", + "\n", + "fig.suptitle(\"Tail behaviour on log-log axes\", y=1.03)\n", + "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", - "id": "62d09923", + "id": "2ff5576b", "metadata": {}, "source": [ - "### Cumulative plots with `khisto.matplotlib.hist`\n", + "## 3. NumPy-like API: `khisto.histogram`\n", "\n", - "`khisto.matplotlib.hist` supports matplotlib-style cumulative plots, including reverse cumulative counts and cumulative probabilities." + "`khisto.histogram` is a drop-in replacement for `numpy.histogram`: same return\n", + "value `(hist, bin_edges)`, but the bins adapt to the data instead of being\n", + "fixed-width." ] }, { "cell_type": "code", - "execution_count": null, - "id": "d985437b", + "execution_count": 7, + "id": "d0e40b1c", "metadata": {}, "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "name": "stdout", "output_type": "stream", "text": [ - "Last cumulative count: 1124\n", - "Last cumulative probability: 1.000000\n" + "Number of bins: 24\n", + "Bin edges: [-3.6484375 -3.125 -2.4375 -1.9375 -1.625 -1.125\n", + " -0.5 0.0625 0.1875 0.625 0.875 1.25\n", + " 1.625 1.9375 2.5 2.6875 2.8125 3.125\n", + " 3.3125 3.5 3.8125 5.1875 8.9375 16.875\n", + " 56.03125 ]\n", + "Frequencies: [ 2. 36. 99. 137. 386. 890. 1101. 386. 1668. 788. 818. 515.\n", + " 316. 340. 228. 261. 1006. 435. 234. 94. 124. 100. 28. 8.]\n" ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, + } + ], + "source": [ + "hist_counts, bin_edges = histogram(data)\n", + "\n", + "print(f\"Number of bins: {len(hist_counts)}\")\n", + "print(f\"Bin edges: {bin_edges}\")\n", + "print(f\"Frequencies: {hist_counts}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "55ee75b7", + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "First reverse cumulative count: 1124\n" + "Integral of density: 1.000000\n" ] } ], "source": [ - "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n", - "\n", - "cum_n, cum_bins, _ = hist(data, cumulative=True, ax=axes[0], color=\"steelblue\")\n", - "axes[0].set_title(\"Cumulative counts\")\n", - "axes[0].set_xlabel(\"Value\")\n", - "axes[0].set_ylabel(\"Cumulative count\")\n", - "\n", - "cdf_n, cdf_bins, _ = hist(\n", - " data,\n", - " density=True,\n", - " cumulative=True,\n", - " ax=axes[1],\n", - " color=\"mediumseagreen\",\n", - ")\n", - "axes[1].set_title(\"Cumulative density (CDF)\")\n", - "axes[1].set_xlabel(\"Value\")\n", - "axes[1].set_ylabel(\"Cumulative probability\")\n", - "axes[1].set_ylim(0, 1.05)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "print(f\"Last cumulative count: {cum_n[-1]:.0f}\")\n", - "print(f\"Last cumulative probability: {cdf_n[-1]:.6f}\")\n", - "\n", - "fig, ax = plt.subplots(figsize=(8, 4))\n", - "reverse_n, reverse_bins, _ = hist(\n", - " data,\n", - " cumulative=-1,\n", - " ax=ax,\n", - " color=\"indianred\",\n", - " histtype=\"step\",\n", - ")\n", - "ax.set_title(\"Reverse cumulative counts\")\n", - "ax.set_xlabel(\"Value\")\n", - "ax.set_ylabel(\"Count above threshold\")\n", - "plt.show()\n", + "# With density normalization the integral over the range is ~1\n", + "density, bin_edges = histogram(data, density=True)\n", "\n", - "print(f\"First reverse cumulative count: {reverse_n[0]:.0f}\")" + "widths = np.diff(bin_edges)\n", + "integral = np.sum(density * widths)\n", + "print(f\"Integral of density: {integral:.6f}\")" ] }, { "cell_type": "code", - "execution_count": null, - "id": "51179a02", + "execution_count": 9, + "id": "33828aaa", "metadata": {}, "outputs": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Limited to max 5 bins: got 5 bins\n", + "Bin edges: [-3.6484375 0. 4. 8. 16. 56.03125 ]\n" + ] } ], "source": [ - "# Different histogram types\n", - "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", - "\n", - "hist(data, histtype=\"bar\", ax=axes[0], color=\"steelblue\")\n", - "axes[0].set_title('histtype=\"bar\"')\n", - "\n", - "hist(data, histtype=\"step\", ax=axes[1], color=\"red\")\n", - "axes[1].set_title('histtype=\"step\"')\n", + "# Cap the number of bins\n", + "hist_limited, edges_limited = histogram(data, max_bins=5)\n", + "print(f\"Limited to max 5 bins: got {len(hist_limited)} bins\")\n", + "print(f\"Bin edges: {edges_limited}\")" + ] + }, + { + "cell_type": "markdown", + "id": "3cfba7b7", + "metadata": {}, + "source": [ + "## 4. Matplotlib API: `khisto.matplotlib.hist`\n", "\n", - "hist(data, histtype=\"stepfilled\", ax=axes[2], color=\"purple\", alpha=0.5)\n", - "axes[2].set_title('histtype=\"stepfilled\"')\n", + "`khisto.matplotlib.hist` keeps the familiar matplotlib workflow. With\n", + "variable-width bins, **density** is the view to reach for first." + ] + }, + { + "cell_type": "markdown", + "id": "1720a012", + "metadata": {}, + "source": [ + "### Cumulative plots\n", "\n", - "plt.tight_layout()\n", - "plt.show()" + "`khisto.matplotlib.hist` follows matplotlib's `cumulative` semantics, including\n", + "the cumulative density (CDF), raw cumulative counts, and reverse accumulation." ] }, { "cell_type": "code", - "execution_count": null, - "id": "e9bbabc9", + "execution_count": 27, + "id": "247c1571", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "Text(0, 0.5, 'Cumulative probability')" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] }, "metadata": {}, @@ -456,75 +423,74 @@ } ], "source": [ - "# Horizontal orientation\n", - "fig, ax = plt.subplots(figsize=(6, 6))\n", - "hist(data, orientation=\"horizontal\", ax=ax, color=\"coral\")\n", - "ax.set_xlabel(\"Count\")\n", - "ax.set_ylabel(\"Value\")\n", - "ax.set_title(\"Horizontal Histogram\")\n", - "plt.show()" + "# Cumulative density (CDF) first — the most interpretable cumulative view\n", + "cdf_n, cdf_bins, _ = hist(data, density=True, cumulative=True,\n", + " color=\"mediumseagreen\")\n", + "plt.title(\"Cumulative density (CDF)\")\n", + "plt.xlabel(\"Value\")\n", + "plt.ylabel(\"Cumulative probability\")" ] }, { "cell_type": "markdown", - "id": "5f9e3262", + "id": "52023e06", "metadata": {}, "source": [ - "## 3. Core API: `compute_histograms` and `HistogramResult`\n", + "## 5. Core API: `compute_histograms` and `HistogramResult`\n", "\n", - "When one adaptive histogram is not enough, the core API lets you inspect the full sequence of granularities and see exactly where Khisto chooses to stop." + "When a single histogram is not enough, the core API exposes the full sequence of\n", + "granularities and tells you exactly where Khiops chooses to stop." ] }, { "cell_type": "code", - "execution_count": null, - "id": "1190f8aa", + "execution_count": 16, + "id": "03285190", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Number of granularity levels: 10\n", + "Number of granularity levels: 12\n", "\n", "Granularity levels:\n", " Granularity 0: 1 bins\n", " Granularity 1: 2 bins\n", " Granularity 2: 3 bins\n", - " Granularity 3: 4 bins\n", - " Granularity 4: 7 bins\n", - " Granularity 5: 9 bins\n", - " Granularity 6: 10 bins\n", + " Granularity 3: 3 bins\n", + " Granularity 4: 4 bins\n", + " Granularity 5: 5 bins\n", + " Granularity 6: 8 bins\n", " Granularity 7: 11 bins\n", - " Granularity 8: 12 bins\n", - " Granularity 9: 11 bins <- BEST\n" + " Granularity 8: 18 bins\n", + " Granularity 9: 25 bins\n", + " Granularity 10: 26 bins\n", + " Granularity 11: 24 bins <- BEST\n" ] } ], "source": [ "from khisto.core import compute_histograms\n", "\n", - "# Get all granularity levels\n", "results = compute_histograms(data)\n", "\n", - "print(f\"Number of granularity levels: {len(results)}\")\n", - "print(\"\\nGranularity levels:\")\n", + "print(f\"Number of granularity levels: {len(results)}\\n\")\n", + "print(\"Granularity levels:\")\n", "for result in results:\n", " marker = \" <- BEST\" if result.is_best else \"\"\n", - " print(\n", - " f\" Granularity {result.granularity}: {len(result.frequencies)} bins{marker}\"\n", - " )" + " print(f\" Granularity {result.granularity}: {len(result.frequencies)} bins{marker}\")" ] }, { "cell_type": "code", - "execution_count": null, - "id": "bf2ba150", + "execution_count": 32, + "id": "b93b2015", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -534,21 +500,26 @@ } ], "source": [ - "# Visualize different granularities\n", + "# Each level carries densities, so we visualize the series as densities\n", "n_levels = min(6, len(results))\n", "fig, axes = plt.subplots(2, 3, figsize=(15, 8))\n", "axes = axes.flatten()\n", "\n", - "for i, result in enumerate(results[:n_levels]):\n", + "for i, result in enumerate(results[n_levels:]):\n", " ax = axes[i]\n", - " ax.stairs(result.frequencies, result.bin_edges, fill=True, alpha=0.7)\n", + " ax.stairs(result.densities, result.bin_edges, fill=True, alpha=0.7,\n", + " color=\"steelblue\")\n", " title = f\"Granularity {result.granularity} ({len(result.frequencies)} bins)\"\n", " if result.is_best:\n", - " title += \" * BEST\"\n", - " ax.set_facecolor(\"#ffffee\")\n", + " title += \" — BEST\"\n", + " ax.set_facecolor(\"aliceblue\")\n", " ax.set_title(title)\n", " ax.set_xlabel(\"Value\")\n", - " ax.set_ylabel(\"Count\")\n", + " ax.set_ylabel(\"Density\")\n", + "\n", + "# Hide any unused axes\n", + "for ax in axes[n_levels:]:\n", + " ax.set_visible(False)\n", "\n", "plt.tight_layout()\n", "plt.show()" @@ -556,16 +527,22 @@ }, { "cell_type": "markdown", - "id": "2392ccc5", + "id": "11981a03", "metadata": {}, "source": [ "## Summary\n", "\n", "Khisto gives you a better histogram without making you tune bins by hand:\n", "\n", - "1. **`khisto.histogram`** for a NumPy-like API with adaptive bins\n", - "2. **`khisto.matplotlib.hist`** for readable plots with the usual matplotlib workflow\n", - "3. **`khisto.core.compute_histograms`** for full control over the histogram series" + "1. **`khisto.histogram`** — a NumPy-like API with adaptive bins.\n", + "2. **`khisto.matplotlib.hist`** — readable plots with the usual matplotlib\n", + " workflow; reach for `density=True` first.\n", + "3. **`khisto.core.compute_histograms`** — full control over the granularity\n", + " series, with `HistogramResult` exposing counts, probabilities and densities.\n", + "\n", + "To go further, the\n", + "[Khiops histograms guide](https://github.com/KhiopsML/khiops-doc/blob/dev/docs/learn/histograms.md)\n", + "builds the intuition from the simplest histogram to the most complex." ] } ], diff --git a/docs/index.rst b/docs/index.rst index 1a4c8b2..a15c127 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -80,8 +80,8 @@ Get started :hidden: Histograms - Core Matplotlib + Core .. toctree:: :maxdepth: 2 diff --git a/sandbox/khisto_demo.ipynb b/sandbox/khisto_demo.ipynb index 8af7d60..53aebc5 100644 --- a/sandbox/khisto_demo.ipynb +++ b/sandbox/khisto_demo.ipynb @@ -130,7 +130,7 @@ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m khisto \u001b[38;5;28;01mimport\u001b[39;00m matplotlib\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m matplotlib.hist([data, [\u001b[32m1\u001b[39m, \u001b[32m2\u001b[39m, \u001b[32m3\u001b[39m], [\u001b[32m2\u001b[39m,\u001b[32m2\u001b[39m,\u001b[32m2\u001b[39m,\u001b[32m2\u001b[39m]], max_bins=\u001b[32m20\u001b[39m, alpha=\u001b[32m0.5\u001b[39m)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/python/khisto-python/src/khisto/matplotlib/hist.py:122\u001b[39m, in \u001b[36mhist\u001b[39m\u001b[34m(x, range, max_bins, density, cumulative, histtype, orientation, log, color, label, ax, edgecolor, linewidth, alpha, **kwargs)\u001b[39m\n\u001b[32m 119\u001b[39m ax = plt.gca()\n\u001b[32m 121\u001b[39m \u001b[38;5;66;03m# Compute histogram using khisto\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m122\u001b[39m hist_values, bin_edges = \u001b[30;43mkhisto_histogram\u001b[39;49m\u001b[30;43m(\u001b[39;49m\n\u001b[32m 123\u001b[39m \u001b[30;43m \u001b[39;49m\u001b[30;43mx\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mrange\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mrange\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mmax_bins\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mmax_bins\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mdensity\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mdensity\u001b[39;49m\n\u001b[32m 124\u001b[39m \u001b[30;43m\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 125\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m cumulative_mode != \u001b[32m0\u001b[39m:\n\u001b[32m 126\u001b[39m hist_values = _apply_cumulative(\n\u001b[32m 127\u001b[39m hist_values,\n\u001b[32m 128\u001b[39m bin_edges,\n\u001b[32m 129\u001b[39m density=density,\n\u001b[32m 130\u001b[39m reverse=cumulative_mode < \u001b[32m0\u001b[39m,\n\u001b[32m 131\u001b[39m )\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/python/khisto-python/src/khisto/matplotlib/hist.py:122\u001b[39m, in \u001b[36mhist\u001b[39m\u001b[34m(x, range, max_bins, density, cumulative, histtype, orientation, log, color, label, ax, edgecolor, linewidth, alpha, **kwargs)\u001b[39m\n\u001b[32m 119\u001b[39m ax = plt.gca()\n\u001b[32m 121\u001b[39m \u001b[38;5;66;03m# Compute histogram using khisto\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m122\u001b[39m hist_values, bin_edges = \u001b[30;43mkhisto_histogram\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mx\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mrange\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mrange\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mmax_bins\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mmax_bins\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mdensity\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mdensity\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 123\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m cumulative_mode != \u001b[32m0\u001b[39m:\n\u001b[32m 124\u001b[39m hist_values = _apply_cumulative(\n\u001b[32m 125\u001b[39m hist_values,\n\u001b[32m 126\u001b[39m bin_edges,\n\u001b[32m 127\u001b[39m density=density,\n\u001b[32m 128\u001b[39m reverse=cumulative_mode < \u001b[32m0\u001b[39m,\n\u001b[32m 129\u001b[39m )\n", "\u001b[36mFile \u001b[39m\u001b[32m~/python/khisto-python/src/khisto/array/histogram/api.py:107\u001b[39m, in \u001b[36mhistogram\u001b[39m\u001b[34m(a, range, max_bins, density)\u001b[39m\n\u001b[32m 53\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mhistogram\u001b[39m(\n\u001b[32m 54\u001b[39m a: ArrayLike,\n\u001b[32m 55\u001b[39m \u001b[38;5;28mrange\u001b[39m: Optional[\u001b[38;5;28mtuple\u001b[39m[\u001b[38;5;28mfloat\u001b[39m, \u001b[38;5;28mfloat\u001b[39m]] = \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[32m 56\u001b[39m max_bins: Optional[\u001b[38;5;28mint\u001b[39m] = \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[32m 57\u001b[39m density: \u001b[38;5;28mbool\u001b[39m = \u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[32m 58\u001b[39m ) -> \u001b[38;5;28mtuple\u001b[39m[NDArray[np.float64], NDArray[np.float64]]:\n\u001b[32m 59\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Compute an optimal histogram using the Khiops binning algorithm.\u001b[39;00m\n\u001b[32m 60\u001b[39m \n\u001b[32m 61\u001b[39m \u001b[33;03m Parameters\u001b[39;00m\n\u001b[32m (...)\u001b[39m\u001b[32m 105\u001b[39m \u001b[33;03m Analysis, 180:0-0, 2023.\u001b[39;00m\n\u001b[32m 106\u001b[39m \u001b[33;03m \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m107\u001b[39m arr = \u001b[30;43mnp\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43masarray\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43ma\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mdtype\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mnp\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mfloat64\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 109\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m arr.ndim != \u001b[32m1\u001b[39m:\n\u001b[32m 110\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m 111\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mExpected 1-D array, got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00marr.ndim\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m-D array instead. \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 112\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mReshape your data or flatten it before calling histogram.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 113\u001b[39m )\n", "\u001b[31mValueError\u001b[39m: setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (3,) + inhomogeneous part." ] @@ -153,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "23c19584", "metadata": {}, "outputs": [ @@ -174,7 +174,7 @@ " )" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, @@ -195,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "2749c664", "metadata": {}, "outputs": [ @@ -219,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "1cca2392", "metadata": {}, "outputs": [ @@ -241,7 +241,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "2ad6d7e5", "metadata": {}, "outputs": [ @@ -273,7 +273,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "id": "b6c4ea8c", "metadata": {}, "outputs": [ @@ -297,6 +297,7 @@ ], "source": [ "from khisto.matplotlib import hist\n", + "from khisto.matplotlib.hist import _hist\n", "\n", "# Basic histogram plot\n", "fig, ax = plt.subplots(figsize=(8, 5))\n", @@ -311,7 +312,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "id": "09479225", "metadata": {}, "outputs": [ @@ -339,7 +340,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 8, "id": "6c89bf07", "metadata": {}, "outputs": [ @@ -366,7 +367,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 12, "id": "25d8d0e5", "metadata": {}, "outputs": [ @@ -403,7 +404,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 15, "id": "d985437b", "metadata": {}, "outputs": [ @@ -487,7 +488,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "id": "51179a02", "metadata": {}, "outputs": [ @@ -521,7 +522,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "id": "e9bbabc9", "metadata": {}, "outputs": [ @@ -558,7 +559,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "id": "1190f8aa", "metadata": {}, "outputs": [ @@ -594,7 +595,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "id": "bf2ba150", "metadata": {}, "outputs": [ diff --git a/src/khisto/core/backend.py b/src/khisto/core/backend.py index d71de4e..457b298 100644 --- a/src/khisto/core/backend.py +++ b/src/khisto/core/backend.py @@ -235,13 +235,14 @@ def _process_histogram_file(file_path: Path) -> list[HistogramResult]: ] -def compute_histograms(x: np.ndarray) -> list[HistogramResult]: +def compute_histograms(x: NDArray[np.float64]) -> list[HistogramResult]: """Compute optimal histogram of an array using khisto CLI binary input. Parameters ---------- - x : np.ndarray - Array of numeric values. + x : NDArray[np.float64] + Array of numeric values. Only 1-dimensional arrays are supported. + Missing values (NaN) are filtered out. Returns ------- @@ -257,10 +258,14 @@ def compute_histograms(x: np.ndarray) -> list[HistogramResult]: If input array is empty after filtering. """ x = np.asarray(x, dtype=np.float64) + + if len(x) == 0: + raise ValueError("Input array is empty") + x = x[~np.isnan(x)] if len(x) == 0: - raise ValueError("Input array is empty after filtering") + raise ValueError("Input array is empty after filtering missing values") # Use delete=False so the files are closed before the subprocess reads them. # On Windows, files keep an exclusive lock while open, whence, diff --git a/src/khisto/matplotlib/hist.py b/src/khisto/matplotlib/hist.py index 89bfc0a..f9cc606 100644 --- a/src/khisto/matplotlib/hist.py +++ b/src/khisto/matplotlib/hist.py @@ -6,65 +6,24 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Any, Literal, Optional +from typing import TYPE_CHECKING, Any, Optional -import matplotlib.pyplot as plt import numpy as np from matplotlib.axes import Axes from khisto.array import histogram as khisto_histogram if TYPE_CHECKING: - from numpy.typing import ArrayLike, NDArray - - -def _normalize_cumulative(cumulative: bool | float) -> int: - """Normalize cumulative mode to 0 (disabled), 1, or -1 (reverse).""" - if isinstance(cumulative, (bool, np.bool_)): - return 1 if cumulative else 0 - if isinstance(cumulative, (int, float, np.number)): - if cumulative < 0: - return -1 - if cumulative > 0: - return 1 - return 0 - raise TypeError("cumulative must be a boolean or a number") - - -def _apply_cumulative( - hist_values: NDArray[np.float64], - bin_edges: NDArray[np.float64], - *, - density: bool = False, - reverse: bool = False, -) -> NDArray[np.float64]: - """Accumulate histogram values using matplotlib-compatible semantics.""" - if density: - source_values = hist_values * np.diff(bin_edges) - else: - source_values = hist_values - - if reverse: - return np.cumsum(source_values[::-1])[::-1] - return np.cumsum(source_values) + from numpy.typing import ArrayLike def hist( x: ArrayLike, range: Optional[tuple[float, float]] = None, max_bins: Optional[int] = None, - density: bool = False, - cumulative: bool | float = False, - histtype: str = "bar", - orientation: Literal["vertical", "horizontal"] = "vertical", - log: bool = False, - color: Optional[str] = None, - label: Optional[str] = None, + density: bool = True, *, ax: Optional[Axes] = None, - edgecolor: Optional[str] = None, - linewidth: Optional[float] = None, - alpha: Optional[float] = None, **kwargs: Any, ) -> tuple[np.ndarray, np.ndarray, Any]: """Compute and plot an optimal histogram. @@ -80,13 +39,17 @@ def hist( Maximum number of bins. If not provided, the algorithm selects the optimal number of bins automatically. density : bool, optional - If True, return and plot probability density values. If False, - return and plot counts. Default is False. - cumulative : bool or float, optional - If True, return and plot cumulative values. If negative, accumulate - in reverse order. When used with ``density=True``, the returned values - are cumulative probabilities so that the last (or first, in reverse) - bin equals 1. + If True, returns and plots a probability density; otherwise, counts. + Default is True. + + With adaptive binning, bin widths vary, so density and frequency + histograms differ visually. Therefore, density is the default, + unlike in matplotlib. + ax : matplotlib.axes.Axes, optional + Axes object to plot on. If not provided, the current axes will be used. + **kwargs : + other keyword arguments are described in ``plt.hist()``. The ``bins``, + ``weights``, and stacked/multiple dataset features are not supported. Returns ------- @@ -99,8 +62,7 @@ def hist( See Also -------- - matplotlib.pyplot.hist : Matplotlib's histogram function. The ``bins``, - ``weights``, and stacked/multiple dataset features are not supported. + matplotlib.pyplot.hist : Matplotlib's histogram function. khisto.array.histogram : Underlying histogram computation. """ unsupported_kwargs = { @@ -112,84 +74,13 @@ def hist( if name in kwargs: raise TypeError(f"{name} is not supported. {hint}") - cumulative_mode = _normalize_cumulative(cumulative) + # Compute histogram using khisto + _, bin_edges = khisto_histogram(x, range=range, max_bins=max_bins, density=density) - # Get axes if ax is None: + # optional dependency; only import if strictly needed. + import matplotlib.pyplot as plt + ax = plt.gca() - # Compute histogram using khisto - hist_values, bin_edges = khisto_histogram( - x, range=range, max_bins=max_bins, density=density - ) - if cumulative_mode != 0: - hist_values = _apply_cumulative( - hist_values, - bin_edges, - density=density, - reverse=cumulative_mode < 0, - ) - - # Handle log scale - if log: - if orientation == "vertical": - ax.set_yscale("log") - else: - ax.set_xscale("log") - - # Build kwargs for plotting - bar_kwargs: dict[str, Any] = {} - if color is not None: - bar_kwargs["color"] = color - if edgecolor is not None: - bar_kwargs["edgecolor"] = edgecolor - if linewidth is not None: - bar_kwargs["linewidth"] = linewidth - if alpha is not None: - bar_kwargs["alpha"] = alpha - if label is not None: - bar_kwargs["label"] = label - bar_kwargs.update(kwargs) - - # Compute bin widths and centers - bin_widths = np.diff(bin_edges) - bin_centers = bin_edges[:-1] + bin_widths / 2 - - # Plot based on histtype - if histtype == "bar": - if orientation == "vertical": - patches = ax.bar( - bin_centers, - hist_values, - width=bin_widths, - align="center", - **bar_kwargs, - ) - else: # horizontal - patches = ax.barh( - bin_centers, - hist_values, - height=bin_widths, - align="center", - **bar_kwargs, - ) - elif histtype in ("step", "stepfilled"): - # Create step plot data - step_x = np.repeat(bin_edges, 2)[1:-1] - step_y = np.repeat(hist_values, 2) - - if histtype == "stepfilled": - bar_kwargs.setdefault("alpha", 0.5) - if orientation == "vertical": - patches = ax.fill_between(step_x, step_y, step=None, **bar_kwargs) - else: - patches = ax.fill_betweenx(step_x, step_y, step=None, **bar_kwargs) - else: - if orientation == "vertical": - patches = ax.plot(step_x, step_y, **bar_kwargs)[0] - else: - patches = ax.plot(step_y, step_x, **bar_kwargs)[0] - else: - raise ValueError(f"Unknown histtype: {histtype}") - - return hist_values, bin_edges, patches + return ax.hist(x, bin_edges, density=density, range=range, **kwargs) diff --git a/test.py b/test.py new file mode 100644 index 0000000..cbc776a --- /dev/null +++ b/test.py @@ -0,0 +1,26 @@ +# Copyright (c) 2025-2026 Orange. All rights reserved. +# This software is distributed under the BSD 3-Clause-clear License, the text of which is available +# at https://spdx.org/licenses/BSD-3-Clause-Clear.html or see the "LICENSE" file for more details. + +# %% +import numpy as np +import matplotlib.pyplot as plt +from khisto.matplotlib import hist + +# Generate 10,000 samples from a Pareto distribution +long_tail_data = np.random.pareto(3, size=10000) + +# Plot an adaptive histogram on logarithmic axes. +n, bins, patches = hist(long_tail_data, density=True) +plt.xscale("symlog") +plt.yscale("log") +plt.show() + +# Generate 10,000 samples from a Normal distribution +normal_data = np.random.normal(size=10000) + +# Plot an adaptive histogram +n, bins, patches = hist(normal_data, density=True) +plt.show() + +# %% diff --git a/tests/plot/test_matplotlib_histogram.py b/tests/plot/test_matplotlib_histogram.py index 5a24806..acb1685 100644 --- a/tests/plot/test_matplotlib_histogram.py +++ b/tests/plot/test_matplotlib_histogram.py @@ -60,7 +60,7 @@ def test_density_histogram(self, normal_data): def test_frequency_histogram(self, normal_data): """Test frequency histogram is the default behavior.""" fig, ax = plt.subplots() - n, bins, patches = hist(normal_data, ax=ax) + n, bins, patches = hist(normal_data, ax=ax, density=False) # Frequencies should sum to total count assert np.sum(n) == len(normal_data) @@ -146,7 +146,7 @@ def test_cumulative_hist_matches_array_api(self, normal_data): def test_reverse_cumulative_frequency_histogram(self, normal_data): """Test reverse cumulative frequency histogram.""" fig, ax = plt.subplots() - n, bins, patches = hist(normal_data, cumulative=-1, ax=ax) + n, bins, patches = hist(normal_data, density=False, cumulative=-1, ax=ax) assert np.isclose(n[0], len(normal_data)) plt.close(fig) From c5cedcc8995db7b0309d026ecf69ad5d97fa72e8 Mon Sep 17 00:00:00 2001 From: Elouen Ginat Date: Fri, 26 Jun 2026 16:49:00 +0200 Subject: [PATCH 4/7] doc: get api comparison markdown back --- docs/api_comparison.md | 246 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 246 insertions(+) create mode 100644 docs/api_comparison.md diff --git a/docs/api_comparison.md b/docs/api_comparison.md new file mode 100644 index 0000000..382d242 --- /dev/null +++ b/docs/api_comparison.md @@ -0,0 +1,246 @@ +# API Comparison + +This document compares the current Khisto APIs with NumPy and Matplotlib. + +## NumPy Comparison + +### `numpy.histogram` vs `khisto.histogram` + +Khisto's `histogram` function is designed as a drop-in replacement for `numpy.histogram`. + +#### Signature Comparison + +```python +# NumPy +numpy.histogram( + a, + bins=10, + range=None, + density=None, + weights=None, +) + +# Khisto +khisto.histogram( + a, + range=None, + max_bins=None, + density=False, +) +``` + +#### Key Differences + +| Feature | NumPy | Khisto | +|---|---|---| +| **Binning method** | Fixed-width bins | Optimal variable-width bins | +| **Bins parameter** | `bins` (int or edges) | `max_bins` (optional limit) | +| **Default bins** | 10 fixed bins | Auto-determined optimal | +| **Weights support** | Yes | No | +| **Returns** | `(hist, bin_edges)` | `(hist, bin_edges)` | + +#### Usage Comparison + +```python +import numpy as np +from khisto import histogram + +data = np.random.normal(0, 1, 1000) + +# NumPy - fixed 10 bins +np_hist, np_edges = np.histogram(data) + +# Khisto - optimal bins (automatic) +khisto_hist, khisto_edges = histogram(data) + +# NumPy - specified bin count +np_hist, np_edges = np.histogram(data, bins=20) + +# Khisto - maximum bin count +khisto_hist, khisto_edges = histogram(data, max_bins=20) + +# Both support density normalization +np_density, _ = np.histogram(data, density=True) +khisto_density, _ = histogram(data, density=True) + +# Both support range specification +np_hist, _ = np.histogram(data, range=(-2, 2)) +khisto_hist, _ = histogram(data, range=(-2, 2)) +``` + +#### When to Use Each + +| Use NumPy | Use Khisto | +|---|---| +| Need fixed-width bins | Want optimal data representation | +| Need weighted histograms | Want automatic bin selection | +| Need specific bin edges | Want adaptive bin widths | +| Performance-critical loops | Data visualization | + +--- + +## Matplotlib Comparison + +### `matplotlib.pyplot.hist` vs `khisto.matplotlib.hist` + +Khisto's `hist` function works similarly to matplotlib's `hist`, but with optimal binning. + +#### Signature Comparison + +```python +# Matplotlib +matplotlib.pyplot.hist( + x, + bins=10, + range=None, + density=False, + weights=None, + cumulative=False, + bottom=None, + histtype='bar', + align='mid', + orientation='vertical', + rwidth=None, + log=False, + color=None, + label=None, + stacked=False, + **kwargs, +) + +# Khisto +khisto.matplotlib.hist( + x, + range=None, + max_bins=None, + density=False, + cumulative=False, + histtype='bar', + orientation='vertical', + log=False, + color=None, + label=None, + ax=None, + edgecolor=None, + linewidth=None, + alpha=None, + **kwargs, +) +``` + +#### Key Differences + +| Feature | Matplotlib | Khisto | +|---|---|---| +| **Binning** | Fixed-width | Optimal variable-width | +| **Bins param** | `bins` | `max_bins` | +| **Axes param** | Implicit (current) | Optional `ax` parameter | +| **Cumulative** | Supported | Supported | +| **Reverse cumulative** | Supported with negative `cumulative` | Supported with negative `cumulative` | +| **Stacked** | Supported | Not supported | +| **Weights** | Supported | Not supported | +| **Unsupported histogram args** | None | `bins`, `stacked`, and `weights` raise a `TypeError` | +| **Multiple datasets** | Supported | Not supported; only 1-D arrays are accepted | + +#### Usage Comparison + +```python +import numpy as np +import matplotlib.pyplot as plt +from khisto.matplotlib import hist + +data = np.random.normal(0, 1, 1000) + +# Matplotlib - fixed bins +fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4)) + +ax1.hist(data, bins=30) +ax1.set_title("Matplotlib (30 bins)") + +hist(data, ax=ax2) +ax2.set_title("Khisto (optimal bins)") + +plt.tight_layout() +plt.show() +``` + +#### Common Parameters (Same Behavior) + +```python +# Both support these parameters identically: + +# density normalization +plt.hist(data, density=True) +hist(data, density=True) + +# cumulative view +plt.hist(data, density=True, cumulative=True) +hist(data, density=True, cumulative=True) + +# reverse cumulative view +plt.hist(data, cumulative=-1) +hist(data, cumulative=-1) + +# histogram type +plt.hist(data, histtype='step') +hist(data, histtype='step') + +# orientation +plt.hist(data, orientation='horizontal') +hist(data, orientation='horizontal') + +# log scale +plt.hist(data, log=True) +hist(data, log=True) + +# color and label +plt.hist(data, color='blue', label='Data') +hist(data, color='blue', label='Data') +``` + +--- + +## Migration Guide + +### From NumPy + +```python +# Before (NumPy) +import numpy as np +hist, edges = np.histogram(data, bins=30) + +# After (Khisto) +from khisto import histogram +hist, edges = histogram(data, max_bins=30) # max_bins is optional +``` + +### From Matplotlib + +```python +# Before (Matplotlib) +import matplotlib.pyplot as plt +n, bins, patches = plt.hist(data, bins=30) + +# After (Khisto) +from khisto.matplotlib import hist +n, bins, patches = hist(data, max_bins=30) # max_bins is optional +``` + +--- + +## Feature Matrix + +| Feature | NumPy | Matplotlib | Khisto | +|---|---|---|---| +| Fixed-width bins | Yes | Yes | No | +| Optimal bins | No | No | Yes | +| Variable-width bins | Manual | Manual | Auto | +| Density | Yes | Yes | Yes | +| Range | Yes | Yes | Yes | +| Weights | Yes | Yes | No | +| Cumulative | No | Yes | Yes | +| Reverse cumulative | No | Yes | Yes | +| Plotting | No | Yes | Yes | +| Step histogram | No | Yes | Yes | +| Horizontal | No | Yes | Yes | +| Log scale | No | Yes | Yes | \ No newline at end of file From 0bc37480f3691e8a35a231f69a1180fad07ce666 Mon Sep 17 00:00:00 2001 From: Elouen Ginat Date: Fri, 26 Jun 2026 16:55:04 +0200 Subject: [PATCH 5/7] fix: remove density=True param in readme quickstart because it's the default now --- README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index fc3db94..1685c8d 100644 --- a/README.md +++ b/README.md @@ -35,21 +35,21 @@ import numpy as np import matplotlib.pyplot as plt from khisto.matplotlib import hist +# Generate 10,000 samples from a Normal distribution +normal_data = np.random.normal(size=10000) + +# Plot an adaptive histogram +n, bins, patches = hist(normal_data) +plt.show() + # Generate 10,000 samples from a Pareto distribution long_tail_data = np.random.pareto(3, size=10000) # Plot an adaptive histogram on logarithmic axes. -n, bins, patches = hist(long_tail_data, density=True) +n, bins, patches = hist(long_tail_data) plt.xscale("symlog") plt.yscale("log") plt.show() - -# Generate 10,000 samples from a Normal distribution -normal_data = np.random.normal(size=10000) - -# Plot an adaptive histogram -n, bins, patches = hist(normal_data, density=True) -plt.show() ``` ## Development From 28a3844df664554ace994a156d3b2f12ffd33afc Mon Sep 17 00:00:00 2001 From: Elouen Ginat Date: Fri, 26 Jun 2026 16:55:24 +0200 Subject: [PATCH 6/7] fix: remove left over test file --- test.py | 26 -------------------------- 1 file changed, 26 deletions(-) delete mode 100644 test.py diff --git a/test.py b/test.py deleted file mode 100644 index cbc776a..0000000 --- a/test.py +++ /dev/null @@ -1,26 +0,0 @@ -# Copyright (c) 2025-2026 Orange. All rights reserved. -# This software is distributed under the BSD 3-Clause-clear License, the text of which is available -# at https://spdx.org/licenses/BSD-3-Clause-Clear.html or see the "LICENSE" file for more details. - -# %% -import numpy as np -import matplotlib.pyplot as plt -from khisto.matplotlib import hist - -# Generate 10,000 samples from a Pareto distribution -long_tail_data = np.random.pareto(3, size=10000) - -# Plot an adaptive histogram on logarithmic axes. -n, bins, patches = hist(long_tail_data, density=True) -plt.xscale("symlog") -plt.yscale("log") -plt.show() - -# Generate 10,000 samples from a Normal distribution -normal_data = np.random.normal(size=10000) - -# Plot an adaptive histogram -n, bins, patches = hist(normal_data, density=True) -plt.show() - -# %% From 27fd83678b5c9c29c7af524f794f2d3bf2e18632 Mon Sep 17 00:00:00 2001 From: Elouen Ginat Date: Fri, 26 Jun 2026 16:56:10 +0200 Subject: [PATCH 7/7] fix: new khiops hist doc in the demo. Better function reference in doc for hist --- docs/demo.ipynb | 2 +- src/khisto/matplotlib/hist.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/demo.ipynb b/docs/demo.ipynb index 4eedab5..1f44575 100644 --- a/docs/demo.ipynb +++ b/docs/demo.ipynb @@ -27,7 +27,7 @@ "\n", "> 📚 For a didactic walk-through of optimal histograms — from the simplest to the\n", "> most complex — see the\n", - "> [Khiops histograms guide](https://github.com/KhiopsML/khiops-doc/blob/dev/docs/learn/histograms.md).\n" + "> histogram documentation in [Khiops fundations](https://khiops.org/learn/understand/)\n" ] }, { diff --git a/src/khisto/matplotlib/hist.py b/src/khisto/matplotlib/hist.py index f9cc606..5f24719 100644 --- a/src/khisto/matplotlib/hist.py +++ b/src/khisto/matplotlib/hist.py @@ -48,7 +48,7 @@ def hist( ax : matplotlib.axes.Axes, optional Axes object to plot on. If not provided, the current axes will be used. **kwargs : - other keyword arguments are described in ``plt.hist()``. The ``bins``, + other keyword arguments are described in ``matplotlib.pyplot.hist``. The ``bins``, ``weights``, and stacked/multiple dataset features are not supported. Returns