diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yaml similarity index 100% rename from .github/workflows/ci.yml rename to .github/workflows/ci.yaml diff --git a/.github/workflows/docs.yaml b/.github/workflows/docs.yaml index bd5e466..e87c0d3 100644 --- a/.github/workflows/docs.yaml +++ b/.github/workflows/docs.yaml @@ -44,10 +44,12 @@ jobs: uses: astral-sh/setup-uv@v6 with: enable-cache: true + - name: Install pandoc + run: sudo apt-get install -y pandoc - name: Install doc build requirements run: | uv venv .build-env - uv pip install --python .build-env -r docs/requirements.txt + uv sync - name: Build Sphinx Documentation run: | . .build-env/bin/activate @@ -58,7 +60,7 @@ jobs: with: name: khisto-python-docs path: ./docs/_build/html/ - # Publish to GH pages on Git tag and manually + # Publish to GH pages on Git tag push publish: if: github.ref_type == 'tag' && github.event_name == 'workflow_dispatch' && inputs.deploy-gh-pages == true needs: build diff --git a/.github/workflows/pack-pip.yml b/.github/workflows/pack-pip.yaml similarity index 100% rename from .github/workflows/pack-pip.yml rename to .github/workflows/pack-pip.yaml diff --git a/.gitignore b/.gitignore index b7786b4..79f27e2 100644 --- a/.gitignore +++ b/.gitignore @@ -74,6 +74,7 @@ instance/ # Sphinx documentation docs/_build/ +docs/**/generated/ # PyBuilder .pybuilder/ diff --git a/README.md b/README.md index 74026fe..46a6cda 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,11 @@ # Khisto +[![CI](https://github.com/khiops/khisto-python/actions/workflows/ci.yaml/badge.svg)](https://github.com/khiops/khisto-python/actions/workflows/ci.yaml) +[![Docs](https://github.com/khiops/khisto-python/actions/workflows/docs.yaml/badge.svg)](https://khiops.github.io/khisto-python/) +[![PyPI](https://img.shields.io/pypi/v/khisto)](https://pypi.org/project/khisto/) +[![Python](https://img.shields.io/pypi/pyversions/khisto)](https://pypi.org/project/khisto/) +[![License](https://img.shields.io/pypi/l/khisto)](LICENSE) + **Optimal Binning Histograms for Python** 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. @@ -10,6 +16,7 @@ Khisto is a Python library for creating histograms using the **Khiops optimal bi - **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 | @@ -135,7 +142,13 @@ uv run pytest ## Documentation -See the [API](docs/API.md) and [API Comparison](docs/API_COMPARISON.md) for detailed information on available functions, parameters, and how Khisto compares to standard histogram implementations. +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 diff --git a/docs/API.md b/docs/API.md deleted file mode 100644 index 8ecf7ae..0000000 --- a/docs/API.md +++ /dev/null @@ -1,313 +0,0 @@ -# Khisto API Reference - -Complete API reference for the Khisto library. - -## Table of Contents - -- [Array API](#array-api) - - [histogram](#histogram) -- [Core API](#core-api) - - [compute_histogram](#compute_histogram) - - [HistogramResult](#histogramresult) -- [Matplotlib API](#matplotlib-api) - - [hist](#hist) -- [How It Works](#how-it-works) - ---- - -## Array API - -### `histogram` - -```python -khisto.histogram( - a: ArrayLike, - range: Optional[tuple[float, float]] = None, - max_bins: Optional[int] = None, - density: bool = False, -) -> tuple[NDArray[np.floating], NDArray[np.floating]] -``` - -Compute an optimal histogram using the Khiops binning algorithm. - -#### Parameters - -| Parameter | Type | Default | Description | -|-----------|------|---------|-------------| -| `a` | `ArrayLike` | required | Input data. The input is converted to a floating-point array and flattened to one dimension. | -| `range` | `tuple[float, float]` | `None` | Lower and upper range of the bins. Values outside are ignored. | -| `max_bins` | `int` | `None` | Maximum number of bins. If not provided, the optimal number is determined automatically. | -| `density` | `bool` | `False` | If `False`, return counts; if `True`, return probability density values. | - -#### Returns - -| Return | Type | Description | -|--------|------|-------------| -| `hist` | `NDArray[np.floating]` | The values of the histogram. | -| `bin_edges` | `NDArray[np.floating]` | Array of length `len(hist) + 1` containing the bin edges. | - -#### See Also - -- [`numpy.histogram`](https://numpy.org/doc/stable/reference/generated/numpy.histogram.html) — NumPy's histogram function (`bins` and `weights` are not supported in Khisto). - -#### Examples - -Basic usage: - -```python -import numpy as np -from khisto import histogram - -data = np.random.normal(0, 1, 1000) - -# Compute histogram -hist, bin_edges = histogram(data) -print(f"Number of bins: {len(hist)}") -print(f"Bin edges: {bin_edges}") -``` - -With density normalization: - -```python -density, bin_edges = histogram(data, density=True) -# Verify normalization: integral should be ~1 -widths = np.diff(bin_edges) -print(f"Integral: {np.sum(density * widths)}") # ~1.0 -``` - -Limiting maximum bins: - -```python -hist, bin_edges = histogram(data, max_bins=5) -print(f"Number of bins: {len(hist)}") # <= 5 -``` - -Concatenating nested inputs into a single dataset: - -```python -data = [np.array([0.0, 1.0]), np.array([2.0, 3.0, 4.0])] -hist, bin_edges = histogram(data) -print(hist.sum()) # 5 -``` - ---- - -## Core API - -The core API provides direct access to the Khiops histogram computation with detailed output. - -### `compute_histogram` - -```python -khisto.core.compute_histogram( - x: ArrayLike, -) -> list[HistogramResult] -``` - -Compute optimal histograms at all granularity levels using the Khiops binning algorithm. - -#### Parameters - -| Parameter | Type | Default | Description | -|-----------|------|---------|-------------| -| `x` | `ArrayLike` | required | Input data array. | - -#### Returns - -| Return | Type | Description | -|--------|------|-------------| -| `results` | `list[HistogramResult]` | List of `HistogramResult` objects for all granularity levels, from coarsest to finest. | - -#### See Also - -- [`khisto.histogram`](#histogram) — Simplified interface returning `(hist, bin_edges)`. - -#### Examples - -Basic usage: - -```python -import numpy as np -from khisto.core import compute_histogram - -data = np.random.normal(0, 1, 1000) -results = compute_histogram(data) - -# Find the optimal histogram -for r in results: - if r.is_best: - print(f"Optimal: {len(r.frequency)} bins") - print(f"Bin edges: {r.bin_edges}") -``` - ---- - -### `HistogramResult` - -```python -@dataclass -class HistogramResult: - lower_bound: NDArray[np.floating] - upper_bound: NDArray[np.floating] - frequency: NDArray[np.int64] - probability: NDArray[np.floating] - density: NDArray[np.floating] - is_best: bool - granularity: int -``` - -A structured result containing all histogram information. - -#### Attributes - -| Attribute | Type | Description | -|-----------|------|-------------| -| `lower_bound` | `NDArray[np.floating]` | Lower bounds of each bin. | -| `upper_bound` | `NDArray[np.floating]` | Upper bounds of each bin. | -| `frequency` | `NDArray[np.int64]` | Count of samples in each bin. | -| `probability` | `NDArray[np.floating]` | Probability mass in each bin (frequency / total). | -| `density` | `NDArray[np.floating]` | Probability density (probability / bin_width). | -| `is_best` | `bool` | Whether this is the optimal histogram. | -| `granularity` | `int` | Granularity level (number of bins at this level). | - -#### Properties - -| Property | Type | Description | -|----------|------|-------------| -| `bin_edges` | `NDArray[np.floating]` | Array of bin edges (length = n_bins + 1). | -| `bin_widths` | `NDArray[np.floating]` | Width of each bin. | -| `bin_centers` | `NDArray[np.floating]` | Center of each bin. | - -#### Examples - -```python -import numpy as np -from khisto.core import compute_histogram - -data = np.random.normal(0, 1, 1000) -results = compute_histogram(data) -result = next(r for r in results if r.is_best) - -# Access bin information -print(f"Bin edges: {result.bin_edges}") -print(f"Bin widths: {result.bin_widths}") -print(f"Bin centers: {result.bin_centers}") - -# Access histogram values -print(f"Frequencies: {result.frequency}") -print(f"Probabilities: {result.probability}") -print(f"Densities: {result.density}") - -# Check optimality -print(f"Is best: {result.is_best}") -print(f"Granularity: {result.granularity}") -``` - ---- - -## Matplotlib API - -### `hist` - -```python -khisto.matplotlib.hist( - x: ArrayLike, - range: Optional[tuple[float, float]] = None, - max_bins: Optional[int] = None, - density: bool = False, - cumulative: bool | float = False, - **kwargs, -) -> tuple[NDArray[np.floating], NDArray[np.floating], Any] -``` - -Compute and plot an optimal histogram. - -#### Parameters - -| Parameter | Type | Default | Description | -|-----------|------|---------|-------------| -| `x` | `ArrayLike` | required | Input data, or a sequence of array-like objects. Nested inputs are concatenated and histogrammed as one dataset. | -| `max_bins` | `int` | `None` | Maximum number of bins. If `None`, uses optimal binning. | -| `density` | `bool` | `False` | If `True`, return and plot probability densities. If `False`, return counts. | -| `cumulative` | `bool or float` | `False` | Cumulative mode, following `matplotlib.pyplot.hist`. Negative values accumulate in reverse order. | - -Other parameters are passed to matplotlib for styling. `ax` can be provided to draw on a specific axes. The `bins`, `weights`, and `stacked` arguments are not supported. - -#### Returns - -| Return | Type | Description | -|--------|------|-------------| -| `n` | `NDArray[np.floating]` | The values of the histogram bins (probability density by default). | -| `bins` | `NDArray[np.floating]` | The bin edges. | -| `patches` | `Any` | Container of individual artists (bars or StepPatch). | - -#### See Also - -- [`matplotlib.pyplot.hist`](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.hist.html) — Matplotlib's histogram function. -- [`khisto.histogram`](#histogram) — Underlying non-cumulative histogram computation. - -#### Examples - -Basic plot: - -```python -import numpy as np -import matplotlib.pyplot as plt -from khisto.matplotlib import hist - -data = np.random.normal(0, 1, 10000) - -# Density is usually the clearest view with variable-width bins. -n, bins, patches = hist(data, density=True) -plt.xlabel('Value') -plt.ylabel('Density') -plt.title('Optimal Histogram') -plt.show() -``` - -Cumulative density: - -```python -n, bins, patches = hist(data, density=True, cumulative=True) -plt.ylabel('Cumulative probability') -plt.show() -``` - -Heavy-tailed Pareto example: - -```python -shape = 3 -long_tail_data = np.random.pareto(shape, size=10000) + 1 - -n, bins, patches = hist(long_tail_data, density=True) -plt.xscale('log') -plt.yscale('log') -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 - ---- - -## Type Aliases - -```python -ArrayLike = Union[list, np.ndarray, ...] -``` - -Any array-like object that can be converted to a NumPy array. diff --git a/docs/API_COMPARISON.md b/docs/API_COMPARISON.md deleted file mode 100644 index 90cdade..0000000 --- a/docs/API_COMPARISON.md +++ /dev/null @@ -1,236 +0,0 @@ -# API Comparison - -This document compares the Khisto API with NumPy and Matplotlib, highlighting similarities and differences. - -## 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, - **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 | -| **Stacked** | Supported | Not supported | -| **Weights** | Supported | Not supported | -| **Multiple datasets** | Supported | Sequences are concatenated into one dataset | - -#### 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) - -# 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 | ✓ | ✓ | ✗ | -| Optimal bins | ✗ | ✗ | ✓ | -| Variable-width bins | Manual | Manual | Auto | -| Density | ✓ | ✓ | ✓ | -| Range | ✓ | ✓ | ✓ | -| Weights | ✓ | ✓ | ✗ | -| Cumulative | ✗ | ✓ | ✓ | -| Plotting | ✗ | ✓ | ✓ | -| Step histogram | ✗ | ✓ | ✓ | -| Horizontal | ✗ | ✓ | ✓ | -| Log scale | ✗ | ✓ | ✓ | diff --git a/docs/_static/css/custom.css b/docs/_static/css/custom.css index 9868fd3..d03f79a 100644 --- a/docs/_static/css/custom.css +++ b/docs/_static/css/custom.css @@ -22,3 +22,30 @@ h5 { img.sidebar-logo { width: 40px; } + +/* Hero tagline */ +.hero-tagline { + font-size: 1.25em; + color: var(--color-foreground-secondary); + margin-bottom: 1.5rem; +} + +/* Card styling overrides for Furo + sphinx-design */ +.sd-card { + border-radius: 0px !important; + transition: box-shadow 0.2s ease; +} + +.sd-card:hover { + box-shadow: 0 4px 16px rgba(0, 0, 0, 0.12) !important; +} + +/* Gallery images */ +.sd-card img { + border-radius: 4px; +} + +/* Install code block on landing page */ +.install-cmd .highlight { + font-size: 1.05em; +} \ No newline at end of file diff --git a/docs/api_comparison.rst b/docs/api_comparison.rst new file mode 100644 index 0000000..4dc73ab --- /dev/null +++ b/docs/api_comparison.rst @@ -0,0 +1,351 @@ +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 +"""""""""""""""""""" + +.. code-block:: 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 +""""""""""""""" + +.. list-table:: + :header-rows: 1 + :widths: 20 40 40 + + * - 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 +"""""""""""""""" + +.. code-block:: 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 +"""""""""""""""" + +.. list-table:: + :header-rows: 1 + :widths: 50 50 + + * - 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 +"""""""""""""""""""" + +.. code-block:: 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 +""""""""""""""" + +.. list-table:: + :header-rows: 1 + :widths: 20 40 40 + + * - 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 (not relevant to the Khiops approach) + * - **Unsupported histogram args** + - None + - ``bins``, ``stacked``, and ``weights`` raise a ``TypeError`` + * - **Multiple datasets** + - Supported + - Not supported. Only 1-D arrays are accepted. + +Usage Comparison +"""""""""""""""" + +.. code-block:: 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) +"""""""""""""""""""""""""""""""""" + +.. code-block:: 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 +^^^^^^^^^^ + +.. code-block:: 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 +^^^^^^^^^^^^^^^ + +.. code-block:: 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 +-------------- + +.. list-table:: + :header-rows: 1 + :widths: 25 15 15 15 + + * - 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 diff --git a/docs/array/histogram/index.rst b/docs/array/histogram/index.rst index 112f3f6..c25d72a 100644 --- a/docs/array/histogram/index.rst +++ b/docs/array/histogram/index.rst @@ -2,6 +2,9 @@ khisto.array.histogram ====================== +The fastest way to use Khisto: a NumPy-like ``(hist, bin_edges)`` API with +adaptive bins, optional ``max_bins`` control, and no plotting overhead. + .. automodule:: khisto.array.histogram Main Modules @@ -11,4 +14,5 @@ Main Modules :recursive: :nosignatures: + histogram api diff --git a/docs/conf.py b/docs/conf.py index c7e973d..2c8928e 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -6,16 +6,33 @@ # -- Project information ----------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information import os +import re import sys from pathlib import Path +import tomllib -sys.path.append("..") -sys.path.append(os.path.join("..", "src")) +DOCS_DIR = Path(__file__).resolve().parent +ROOT_DIR = DOCS_DIR.parent + +sys.path.append(str(ROOT_DIR)) +sys.path.append(str(ROOT_DIR / "src")) + + +def _read_release() -> str: + pyproject_file = ROOT_DIR / "pyproject.toml" + data = tomllib.loads(pyproject_file.read_text(encoding="utf-8")) + + try: + return data["project"]["version"] + except KeyError as exc: + raise RuntimeError( + f"Could not determine khisto version from {pyproject_file}" + ) from exc project = 'khisto-python' copyright = '2026, The Khiops Team' author = 'The Khiops Team' -release = "0.1.0" # TODO: use pyproject metadata here +release = _read_release() # -- General configuration --------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration @@ -33,6 +50,8 @@ "sphinx.ext.intersphinx", "numpydoc", "sphinx_copybutton", + "sphinx_design", + "nbsphinx", ] ## Numpydoc extension config @@ -55,7 +74,7 @@ } templates_path = ['_templates'] -exclude_patterns = ['_templates', '_build', 'Thumbs.db', '.DS_Store'] +exclude_patterns = ['_templates', '_build', 'Thumbs.db', '.DS_Store', '**.ipynb_checkpoints'] diff --git a/docs/core/index.rst b/docs/core/index.rst index bc65fb8..d3280d0 100644 --- a/docs/core/index.rst +++ b/docs/core/index.rst @@ -2,6 +2,9 @@ khisto.core ============ +Use ``khisto.core`` when you want to go beyond the default answer and inspect +the full histogram series returned by the Khiops backend. + .. automodule:: khisto.core Main Modules @@ -11,4 +14,6 @@ Main Modules :recursive: :nosignatures: + compute_histograms + HistogramResult backend diff --git a/docs/demo.ipynb b/docs/demo.ipynb new file mode 100644 index 0000000..c3255ae --- /dev/null +++ b/docs/demo.ipynb @@ -0,0 +1,593 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2bc0c481", + "metadata": {}, + "source": [ + "# Khisto Demo\n", + "\n", + "A good histogram should reveal structure without asking you to guess the right bin count first.\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." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e24a8a4b", + "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" + ] + } + ], + "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", + "\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.\")" + ] + }, + { + "cell_type": "markdown", + "id": "0859187a", + "metadata": {}, + "source": [ + "## 1. NumPy-like API: `khisto.histogram`\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." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "56410772", + "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" + ] + } + ], + "source": [ + "from khisto import histogram\n", + "\n", + "# Compute optimal histogram\n", + "hist, bin_edges = histogram(data)\n", + "\n", + "print(f\"Number of bins: {len(hist)}\")\n", + "print(f\"Bin edges: {bin_edges}\")\n", + "print(f\"Frequencies: {hist}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "1b7d0305", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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", + "\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", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "2749c664", + "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", + "\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": 20, + "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}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "2ad6d7e5", + "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" + ] + } + ], + "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}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1eba79b4", + "metadata": {}, + "source": [ + "## 2. Matplotlib API: `khisto.matplotlib.hist`\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." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "b6c4ea8c", + "metadata": {}, + "outputs": [ + { + "data": { + "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", + "\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", + "\n", + "print(f\"Returned {len(n)} bin values\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "6c89bf07", + "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()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "25d8d0e5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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, 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", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "62d09923", + "metadata": {}, + "source": [ + "### Cumulative plots with `khisto.matplotlib.hist`\n", + "\n", + "`khisto.matplotlib.hist` supports matplotlib-style cumulative plots, including reverse cumulative counts and cumulative probabilities." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "d985437b", + "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" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First reverse cumulative count: 1124\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", + "\n", + "print(f\"First reverse cumulative count: {reverse_n[0]:.0f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "51179a02", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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", + "\n", + "hist(data, histtype=\"stepfilled\", ax=axes[2], color=\"purple\", alpha=0.5)\n", + "axes[2].set_title('histtype=\"stepfilled\"')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "e9bbabc9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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()" + ] + }, + { + "cell_type": "markdown", + "id": "5f9e3262", + "metadata": {}, + "source": [ + "## 3. 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." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "1190f8aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of granularity levels: 10\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 7: 11 bins\n", + " Granularity 8: 12 bins\n", + " Granularity 9: 11 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", + "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", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "bf2ba150", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize different granularities\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", + " ax = axes[i]\n", + " ax.stairs(result.frequencies, result.bin_edges, fill=True, alpha=0.7)\n", + " title = f\"Granularity {result.granularity} ({len(result.frequencies)} bins)\"\n", + " if result.is_best:\n", + " title += \" * BEST\"\n", + " ax.set_facecolor(\"#ffffee\")\n", + " ax.set_title(title)\n", + " ax.set_xlabel(\"Value\")\n", + " ax.set_ylabel(\"Count\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2392ccc5", + "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" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "khisto-python", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/index.rst b/docs/index.rst index b983be7..224ac1d 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -1,12 +1,88 @@ -.. khisto-python documentation master file, created by - sphinx-quickstart on Fri Mar 6 17:40:33 2026. - You can adapt this file completely to your liking, but it should at least - contain the root `toctree` directive. +.. khisto-python documentation master file -khisto-python documentation -=========================== +=========================================== +Khisto — Histograms that fit your data +=========================================== -This is the complete API reference for the Khisto Python library. +.. rst-class:: hero-tagline + + Drop-in replacements for ``numpy.histogram`` and ``plt.hist`` with + adaptive, variable-width bins powered by the Khisto algorithm. + Dense regions get fine bins, sparse regions get wide ones — no tuning needed. + +.. grid:: 2 + :gutter: 3 + + .. grid-item-card:: Standard Gaussian + :img-top: images/gaussian-quick-start.png + + Bins concentrate around the interesting areas — exactly + matching the density of a normal distribution. + + .. grid-item-card:: Heavy-tailed Pareto + :img-top: images/pareto-quick-start.png + + Log-log axes reveal how adaptive bins track a power-law decay + over four orders of magnitude. + +Get started +----------- + +.. div:: install-cmd + + .. code-block:: bash + + pip install khisto # core (NumPy only) + pip install "khisto[matplotlib]" # + plotting + +.. code-block:: python + + import numpy as np + from khisto import histogram + + data = np.random.normal(0, 1, 10_000) + hist, bin_edges = histogram(data) # optimal bins, no guessing + +.. grid:: 1 1 3 3 + :gutter: 3 + :class-container: sd-mt-3 + + .. grid-item-card:: :octicon:`package;1.5em` NumPy-like API + :link: array/histogram/index + :link-type: doc + + ``histogram(data)`` returns ``(hist, bin_edges)`` — same shape as + ``numpy.histogram``, better bins. + + .. grid-item-card:: :octicon:`graph;1.5em` Matplotlib integration + :link: matplotlib/index + :link-type: doc + + ``khisto.matplotlib.hist`` plots like ``plt.hist`` with density, + cumulative, step, and log-scale support. + + .. grid-item-card:: :octicon:`telescope;1.5em` Core engine + :link: core/index + :link-type: doc + + ``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 + + A runnable notebook tour covering all features. .. toctree:: :maxdepth: 2 @@ -17,3 +93,10 @@ This is the complete API reference for the Khisto Python library. Core Matplotlib +.. toctree:: + :maxdepth: 2 + :caption: Guides + :hidden: + + API Comparison + Demo diff --git a/docs/matplotlib/index.rst b/docs/matplotlib/index.rst index c5224d8..3352018 100644 --- a/docs/matplotlib/index.rst +++ b/docs/matplotlib/index.rst @@ -2,6 +2,9 @@ khisto.matplotlib ================= +Use ``khisto.matplotlib.hist`` when you want the convenience of ``plt.hist`` +with bins that adapt to the data instead of flattening it. + .. automodule:: khisto.matplotlib Main Modules diff --git a/docs/requirements.txt b/docs/requirements.txt deleted file mode 100644 index 4570321..0000000 --- a/docs/requirements.txt +++ /dev/null @@ -1,9 +0,0 @@ -sphinx>=6.1.0 -furo>=2022.12.7 -ipykernel>=6.9.1 -nbconvert==6.4.4 -nbformat==5.3.0 -numpy>=2.4.3 -matplotlib>=3.10.8 -numpydoc>=1.5.0 -sphinx-copybutton>=0.5.0 diff --git a/pyproject.toml b/pyproject.toml index 9740499..fdb47a1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,32 +1,86 @@ [project] name = "khisto" -dynamic = ["version"] +version = "0.2.0" description = "Optimal histogram visualization using the Khiops algorithm" readme = "README.md" license = "BSD-3-Clause-Clear" license-files = ["LICENSE"] requires-python = ">=3.10" dependencies = ["numpy>=2.0"] +authors = [ + {name = "Elouen Ginat", email = "elouen.ginat@orange.com"}, +] +keywords = [ + "histogram", + "binning", + "optimal", + "khiops", + "statistics", + "data-analysis", + "density-estimation", + "distribution", + "numpy", + "matplotlib", + "visualization", +] +classifiers = [ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", + "Intended Audience :: Science/Research", + "Operating System :: OS Independent", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Topic :: Scientific/Engineering", + "Topic :: Scientific/Engineering :: Mathematics", + "Topic :: Scientific/Engineering :: Visualization", + "Typing :: Typed", +] + +[project.urls] +Homepage = "https://github.com/khiops/khisto-python" +Documentation = "https://khiops.github.io/khisto-python/" +Repository = "https://github.com/khiops/khisto-python" +Issues = "https://github.com/khiops/khisto-python/issues" +Changelog = "https://github.com/khiops/khisto-python/blob/main/CHANGELOG.md" [tool.khiops] -khiops-version = "11.0.1-a.3" +khiops-version = "11.0.1-rc.1" [project.optional-dependencies] matplotlib = ["matplotlib>=3.8"] all = ["matplotlib>=3.8"] [dependency-groups] -dev = [ +test = [ "pytest>=8.3", "pytest-xdist>=3.6", "pytest-cov>=6", "pytest-sugar>=1.0", +] +lint = [ "pre-commit>=4.1", "pre-commit-hooks>=5.0", "ruff>=0.9", +] +docs = [ + "sphinx>=6.1", + "furo>=2022.12.7", + "numpydoc>=1.5", + "sphinx-copybutton>=0.5", + "sphinx-design>=0.6", + "nbsphinx>=0.9", + "pypandoc>=1.17", "ipykernel>=7", "matplotlib>=3.8", ] +dev = [ + {include-group = "test"}, + {include-group = "lint"}, + {include-group = "docs"}, +] [build-system] requires = ["scikit-build-core>=0.11.6", "ninja"] diff --git a/sandbox/khisto_demo.ipynb b/sandbox/khisto_demo.ipynb index bd862f6..8af7d60 100644 --- a/sandbox/khisto_demo.ipynb +++ b/sandbox/khisto_demo.ipynb @@ -86,7 +86,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -119,6 +119,83 @@ { "cell_type": "code", "execution_count": 4, + "id": "e09c38c8", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (3,) + inhomogeneous part.", + "output_type": "error", + "traceback": [ + "\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/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." + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from khisto import matplotlib\n", + "matplotlib.hist([data, [1, 2, 3], [2,2,2,2]], max_bins=20, alpha=0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "23c19584", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([[ 2., 25., 79., 116., 88., 57., 44., 65., 86., 83., 90.,\n", + " 73., 64., 47., 32., 26., 12., 6., 4., 1.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.,\n", + " 0., 1., 0., 1., 0., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 4., 0., 0., 0., 0., 0., 0., 0.]]),\n", + " array([-3.62063367, -3.15868593, -2.69673818, -2.23479044, -1.77284269,\n", + " -1.31089495, -0.84894721, -0.38699946, 0.07494828, 0.53689603,\n", + " 0.99884377, 1.46079152, 1.92273926, 2.384687 , 2.84663475,\n", + " 3.30858249, 3.77053024, 4.23247798, 4.69442572, 5.15637347,\n", + " 5.61832121]),\n", + " )" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist([data, [1, 2, 3], [2,2,2,2]], bins=20, alpha=0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "id": "2749c664", "metadata": {}, "outputs": [ @@ -142,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "id": "1cca2392", "metadata": {}, "outputs": [ @@ -164,7 +241,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "2ad6d7e5", "metadata": {}, "outputs": [ @@ -196,13 +273,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "b6c4ea8c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -234,13 +311,41 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, + "id": "09479225", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Basic histogram plot\n", + "fig, ax = plt.subplots(figsize=(8, 5))\n", + "n, bins, patches = hist(data, ax=ax, label=1)\n", + "# ax.set_xlabel(\"Value\")\n", + "ax.set_xlabel(1)\n", + "ax.set_ylabel(\"Count\")\n", + "ax.set_title(\"Optimal Histogram\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "id": "6c89bf07", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -261,13 +366,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 17, "id": "25d8d0e5", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -298,13 +403,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 18, "id": "d985437b", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAGGCAYAAACqvTJ0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZ4RJREFUeJzt3XlYVOX///EXCCIg4IK7uC+ooFnmjqaomOK+55pbmUtmmbmllqmZpX20tHIr00zLpcxcMndNxX3NXXHDBQVUQIXz+8Mf820EFHCYQef5uK65Lua+73POe2Yobl9zzn0cDMMwBAAAAAAAAFiRo60LAAAAAAAAgP0hlAIAAAAAAIDVEUoBAAAAAADA6gilAAAAAAAAYHWEUgAAAAAAALA6QikAAAAAAABYHaEUAAAAAAAArI5QCgAAAAAAAFZHKAUAAAAAAACrI5QC8FyoWbOmXnnllWdmvwAAwL789ddfcnBw0IYNG56J/abVsWPH5ODgoLlz59q6FJu8N9u3b5ezs7NOnDhhtWOmxrp16+Tq6qqzZ8/auhRAEqEUAEkrVqxQs2bNlC9fPrm4uKhAgQKqWbOmpkyZops3b9q6vHRXqVIl1atXz9ZlPHN43wAA1nL16lUNGzZMFSpUkIeHh7JmzaqyZcuqS5cu2rJli63LS3crVqyQg4ODXbzW9Jae76VhGBo4cKA6d+6skiVLJupP6e9xSEiIHBwcTA9nZ2flzJlTlSpV0oABA7R///5E+350m/8+vL29TeMCAwNVtWpVDRkyxOKvH0gLQinAjsXHx6tr165q0aKF/P39tWHDBkVGRiokJESdOnXS+PHjNXLkSFuXaVNbtmzJMN88AgBgj/755x/5+flp1apVGjt2rEJDQ3Xt2jXNnj1bMTExCggI0PXr121dps3Uq1dPhmFwZncSrP3erFu3Tjt37lT//v0T9aXl93j8+PEyDEOxsbE6ceKEPv30U124cEEvvviiRowYkWQNCdv89/Hofvv27avFixfr5MmTlnvxQBo52boAALbzySef6IcfftCCBQvUoUMHU3u+fPn05ptvqkWLFlqyZIkNKwQAAPbsxo0batasmQoWLKgtW7bIzc3N1Fe1alUtWrRI//vf/+Tg4GDDKoGHZsyYoXLlyqlixYpm7U/7e+zo6KgcOXIoMDBQgYGBGjJkiD755BOVLl1anTt3TnWdTZo0kaenp7755ht99tlnqd4esCTOlALs1N27d/XZZ5+pWrVqZoHUf+XJk0d9+vQxPc+WLZvefPPNRONat26tEiVKmLX5+fkpODhYhw8f1iuvvCI3NzeVKVNGq1atkiQdOHBAderUkbu7uwoXLqx58+Yl2m9qjpeU1q1bm05bzpQpk3LlyqWWLVvq2LFjpjHe3t7avXu31q1bZxpbsGBBU/+ja0q1aNFCuXPn1v379xMdr0uXLsqWLZuio6NNbStXrtQrr7wiT09Pubq6qlq1aqb34ElWrlypwMBAZcuWTV5eXgoMDNTmzZvNxnzzzTeqUKGCsmTJomzZsik4OFh79+41G5OWz+3EiROqX7++3NzclD9/fo0ZM0aGYaT4fdu4caMCAwPl7e0tLy8vVa1aVfPnzzfbBwAATzJ9+nRdvXpVEyZMMPuH/H8NGDBAOXPmlCRNmTJFDg4OunLlitmYQ4cOycHBQT/++KOp7ZdffpGDg4N27dqlsWPHKn/+/PLy8lLXrl0VHR0twzD00UcfqWDBgnJzc1OzZs0SnXGSmuMlJWFcwsPV1VX+/v764osvTH8zp02bpiZNmkiSAgICTGNnzpwpKfG6SQcOHJCDg4OmTJmS6HinT5+Wo6Ojxo8fb2q7efOm3nnnHRUpUkSZM2dW/vz51a9fP0VGRj629oT6GzRoIDc3N+XJk0fDhg1TXFxckmNTcpyEzyQkJESTJk2Sj4+PXF1dVbt2bR06dMhsf9HR0RoyZIiKFy8uV1dXFS1aVD169FBoaKhpzKPvzePey8OHD8vBwUGTJk1KVPvx48fl6OiocePGJftePHjwQKtXr1bdunUT9aX29/hJRo0apWzZsmnChAkpGv8oFxcXVa9eXb/99luatgcsiVAKsFPbtm1TVFSUXn311XQ7xs2bNzVixAhNmzZNFy9eVN26ddWiRQtt375dH3zwgb788ktduHBBzZs3V7du3XT06FGLHv+XX34xnbYcHR2tdevW6c6dOwoKClJERIQk6fr163rppZcUGBhoGnvhwoVk99mzZ09du3Yt0R/xyMhI/frrr3rttdfk6uoq6eG3ZcHBwapRo4YOHz6sCxcuqGnTpmrcuPETJwHTpk1TcHCw/P39FRISotDQUI0YMcJsgjls2DD17dtXXbp00cWLF7Vz507FxcWpRo0a2r17dxrfNenWrVsaMmSIJk6cqCtXrmjIkCEaPXq05s+fbxrzuPft7NmzevXVV1WmTBkdPHhQly9f1ldffaXVq1dn2EU/AQAZ06pVq+Ti4qI6deqk2zE+//xz5ciRQ4cPH9bq1au1cuVKvfPOOxo1apSyZ8+ugwcPasOGDfrnn3+SvCzrafj5+ZldZnXhwgUNHDhQw4cP15dffilJ6tevn37//XdJ0ubNm01je/bsmeQ+y5cvr0qVKmnWrFmJ+mbPni1HR0d17dpVkhQREaHq1atr1apVmjNnjsLDw/Xbb79p48aNCgoK0oMHD5Kt/fz586pVq5aio6O1a9cuHT16VPnz59fo0aMTjU3tcaZMmaJMmTJp37592rdvn27evKmWLVuaBV6DBg3S999/r7lz5yo8PFybN29WQECApk2blmzNj3svy5Urp9q1a2vGjBmJvkSbPn26HB0d1a1bt2T3vXfvXt2+fVuVKlVK1Gfp32M3NzfVrFlTR44c0bVr19K0j8qVK+v48eMKCwuzSE1AmhkA7NLMmTMNScbcuXNTvI2Xl5fxxhtvJGpv1aqVUbx4cbO2cuXKGc7Ozsb58+dNbZGRkYaLi4uRLVs248yZM6b227dvG66ursbgwYPTfLwaNWoYtWvXfuJruHDhgiHJWLhwoantpZdeMgIDA5Mc/+h+Hzx4YBQoUMB49dVXzcbNmDHDkGSEhIQYhmEYN27cMNzd3Y2OHTsm2mfz5s2N0qVLJ1vjtWvXDFdXV6Nt27bJjrl48aLh5ORkdO/e3aw9KirKyJkzp9nrScvndvbsWbP2ihUrGgEBAWZtyb1vCxcuNCQZ//77b7L1AwCQEgULFjSKFCmS4vGTJ082JBmXL182az948KAhyZg3b56pbfHixYYk48033zQbO2zYMMPFxcXo06ePWfvIkSONTJkyGZGRkWk63tq1aw1Jxvr165/4Onr27Gn4+vqanv/++++GJGPz5s2Jxia134R5yY4dO0xtcXFxRsGCBY3g4GBT29ChQ41MmTIZR48eNdvn/v37DUnGTz/9lGyNffr0MVxcXBK99jfffNOQZMyZMyfVx0n4THr37m02bvny5YYkY926daY2X19fo0OHDsnWZxhJvzePey9//vlnQ5KxatUqU9vdu3eN7NmzG40bN37ssX755RdDkrFmzZpEfan9Pd61a5chyRg/fnyyYxLe5/3795ttk9Tju+++S7R9Ur8jgC1wphSAdOPn5ycfHx/Tcw8PDxUoUEA+Pj4qUqSIqd3d3V0+Pj46ffq0RY9//vx5vf766/Lx8ZGzs7PZJWZpXdgxU6ZM6tatm9asWaOLFy+a2mfPnq0KFSropZdekiStX79ed+7cUZs2bRLto169evr333+T/WZq/fr1io6O1muvvZZsHZs2bdKDBw/UsmVLs/asWbOqYcOGpv608PPzU+HChRO1pfTz8fPzk6Ojo3r37q0///xTd+7cSVMdAABYw6Nnjfv6+io2NjbRHWbLlCmjuLg4nTt3zqLHnz17tqpWrSpPT0+zy8meZhHqDh06yM3NTbNnzza1rV69WhcuXFCPHj1Mbb///rv8/f3l6+trtn358uXl7e2tjRs3JnuMdevWqXLlysqbN69Ze/PmzRONTe1xGjdubPbcz89PkszmIhUqVNCyZcs0YcIEHT9+PNk6U6NFixbKly+fvv76a1PbTz/9pJs3b5q9b0m5deuWpIfzXWsw/v/ZXI+uQ5XUQudJnVXn6ekp6f/qBmyFUAqwUwmhw/nz5596X0Yy6wTly5cvUZuHh0ey7Sn9o5jc8f7r7t27CggI0L59+7Ro0SKFh4crPj7edIyk1oRKqR49eig+Pl5z586VJB0+fFg7d+40m6wkrC3RqlUrOTk5KVOmTHJ0dJSjo6P69esn6eGil0m5evWqJKlAgQLJ1pCw7aMTwYS2+/fvmy5RTE5qPjdPT88Ufz7lypXT0qVLFRMTo+DgYGXLlk01atTQDz/8kKLtAQBIULhwYV2+fPmp/m5Lj587PPp3LyFUSK49JX8PUzJXkR5ert+jRw+1aNFChw8f1v3792UYhgYOHJjmL5ekh3+327Rpo59++sm01uWsWbOUJ08eBQcHm8ZduXJF+/fvl5OTk9l8xcHBQdevX092riI9nIvkyZMnUXtSbak9zqPvfVIBytdff61u3brp888/V+nSpZU/f3717t3bbE2p1HJ2dlavXr30xx9/mPYzffp05c6d2+x9S0q2bNkkKcm1uCz1e/xfCcsmJDVvS4mEOrNnz26xmoC0IJQC7FT16tXl4eGhP//8M8XbeHl5KSoqKlH7f88Y+q/k7iCS0jvkpPZ4/7VhwwadP39en376qapVqyYPDw85ODjozJkzKTr24xQtWlR16tTRnDlzZBiGZs2aJRcXF3Xs2NE0xtvbW9LDbyUfPHiguLg4xcfHKz4+3vStVdmyZZPcf65cuZ74OnPkyCFJSZ5tFRYWJmdnZ3l5eUmy3OeWGk2bNtU///yjGzduaPny5cqVK5e6du1qCvIAAEiJhg0bKjY2VuvXr0/R+IS/fY/+3Xvc39Snma+k5Xj/9cMPP6hatWoaMmSIfHx85OT08Obolpiv9OjRQ5GRkfrll190/fp1/f777+rSpYvpGNLD+UqNGjX04MEDs/lKwlxl0aJFye4/Z86cyc5DHpXa46Tkvc+RI4e+/vprhYWF6fDhwxo8eLCWLFmiV155RfHx8U/cPjlvvPGGHBwc9M033ygkJEQhISHq0qWLnJ2dH7tdwhe+jy56L6X+9/hJ7t69q61bt8rPz88050yty5cvS5IKFSpkkZqAtCKUAuyUm5ubBg8erO3btyc74QgLC9P06dNNz4sXL57ozicXL17Uvn370qVGSxzPxcXF7HlSZ+u4u7srNjY2VbX17NlTp06d0tq1azVv3jy1aNHCFBRJUmBgoFxdXfXzzz+nar+SVLduXbm6umrBggXJjqldu7acnJy0dOlSs/Y7d+5o1apVqlWrlmnSmV6fW0ret2zZsqlRo0ZasmSJXFxctGnTpqc6JgDAvvTp00e5cuXSsGHDzO5u+19Tp041nWlTvHhxSUr0d2/FihXpUp8ljvfoXCUsLExr1qwxa3N3d5ekVM1XAgICVLp0ac2aNUvz5s3TvXv31L17d7MxTZo00a5du9IUgtWtW1e7du1KFEItX7480dinOc6TODo6qmzZsnrnnXc0cOBAnT59+rE3rXnSe5k/f341a9ZMM2fONN1g5kmX7knSCy+8oKxZsyokJCRRX2p/j59kzJgxunXrloYOHZqi8UnZuXOnSpUqleSZbYA1EUoBdmz48OHq0qWLOnXqpA8//FAnTpzQvXv3dOXKFX3zzTcqX768Dh8+bBrfq1cvHThwQFOmTFFkZKT279+vvn37qmrVqulS39Mcr1q1avL29taoUaN09uxZ3bhxQ1OmTDF9K/Rffn5+OnTokE6ePJni0+1btmypHDlyqGfPnrp+/XqiyYq3t7cmT56sWbNm6f3339epU6cUHR2tEydO6LvvvlPr1q2T3be3t7cmTpyoxYsX65133tGpU6cUFRWlDRs2qFWrVpIeTpgGDRqkOXPmaPLkyQoPD9eJEyfUrl073b592+xWz+n1uSX3vn3zzTd6++23tWvXLkVFRenWrVv66quvFBsbm653TwIAPH9y5syp5cuX69y5cwoICNAff/yhiIgIRUdHa8eOHWrbtq0GDBhg+jtUs2ZN+fr6atSoUTp27JjCw8M1derUJC+psoSnPV7Tpk21adMm/fjjj7pz54727t2r1q1bJ1rPytfXV05OTlq1apViYmJSXF/37t21adMmffHFF6pRo0aiNZ2GDRum4sWLq3Hjxvrzzz918+ZN3bhxQ1u2bFH37t1Nd6pLypAhQ5QlSxa1bdtWR48e1c2bNzV9+nRdv3490dinOU5y6tatqwULFujs2bOKjY3V4cOHtXTpUpUsWfKxSyCk5L3s27evwsLCNH/+fFWvXj3R+5YUJycnNWzYUH///XeivtT+Hj/KMAzdvHlTf//9t1q3bq1Jkybpww8/fOz6o48TGxurbdu2qWnTpmnaHrAoKy6qDiCD+u2334wmTZoYuXPnNpydnY18+fIZNWrUMKZMmWKEh4ebxsXHxxsff/yxkS9fPiNLlixG7dq1jSNHjiR7F7ek7lJSoUIFIygoKFF7UndyS83xkrr73s6dO42AgADD3d3dyJMnj/H2228bt27dMiQZo0aNMo27dOmSERQUZGTNmtWQZBQoUOCx+03Qv39/Q5JRpEgRIz4+Pskx69atM1599VUjR44cRpYsWYzSpUsbffr0MY4dO5bk+P/6/fffjdq1axtZs2Y1smXLZgQGBhqbNm0yG/P1118b/v7+RubMmQ1PT0/j1VdfNd0BMIElPre+ffsa7u7uZm3JvW+3b982pk6dalSpUsXw8PAwsmfPblSvXt2YP3/+E18zAABJuXLlivHBBx8Y/v7+hru7u+Hu7m6UKVPG6NKlS6K7qB0+fNh45ZVXDBcXFyNfvnzG2LFjjQMHDiR7971du3aZbb906VJDkrF9+3az9uTu2pbS4yV1J7h79+4ZQ4cONQoWLGi4uroaVapUMTZs2GAMGTLEePSfal9//bVRtGhRI1OmTGZ3VHvcXf2uXLliODs7G5KM2bNnJ/neRkREGEOHDjVKly5tZM6c2ciVK5dRu3ZtY+7cuUZsbGyS2yQ4cOCAUa9ePcPV1dXIlSuX8f777xuHDh1KdPe9lB4nuc/k2rVrhiTjs88+M7WFhIQYXbp0MYoUKWJkyZLFKFy4sPHmm28aFy5ceOx7/rj38r/Kli1rSDJmzZr12Pfgv/766y9DkrFnz54k+1P6e/zonfQyZcpkZM+e3XjxxReN/v37G/v27Uu075TcsS/B4sWLDQcHB+P48eMpfm1AenEwjBSeFgAAAAAAgB2oWrWqDh8+rMuXLytr1qwp3q5atWoqU6aM2Z0PM5o6deood+7caVpmArA0Lt8DAAAAAOD/O3v2rHbs2KEOHTqkKpCSpC+++ELz5s3TiRMn0qm6p/P3339r+/bt+vTTT21dCiBJ4kwpAAAAAAAkRUdH64033tDChQt1+PBhlSxZ0tYlAc81zpQCAAAAANi9Dz74QO7u7tq0aZO+//57AinACjhTCgAAAAAAAFbHmVIAAAAAAACwOkIpAAAAAAAAWJ2TrQt4lsTHx+vSpUvy8PCQg4ODrcsBAAA2ZBiGoqKilD9/fjk62vf3fMyRAABAgtTMkQilUuHSpUvy8fGxdRkAACADCQ0NVcGCBW1dhk0xRwIAAI9KyRyJUCoVPDw8JD18Yz09PW1cDQAAsKXIyEj5+PiY5gf2jDkSAABIkJo5EqFUKiScju7p6cmECwAASBKXq4k5EgAASCwlcyT7XgABAAAAAAAANkEoBQAAAAAAAKsjlAIAAAAAAIDVEUoBAAAAAADA6gilAAAAAAAAYHWEUgAAAAAAALA6QikAAAAAAABYnU1Dqfj4eK1YsULBwcEqUaKEduzYkeS45cuXKzAwUH5+furQoYNOnjyZbmMAAACeZRcuXNCoUaNUrlw5dezYMUXbhIeHq3///ipfvryqVaumadOmyTCMdK4UAADYO5uGUkOGDNH06dPVrFkznTp1StHR0YnGrFixQq1bt1aTJk00a9YsGYahgIAAhYeHW3wMAADAs+zmzZuqWbOmJKl48eK6ePHiE7eJj49Xo0aNtHv3bn311Vd65513NHz4cI0fPz69ywUAAHbOwbDh12D37t1T5syZdeHCBfn4+Gj9+vV65ZVXzMZUqlRJ/v7+mjNnjmmbfPnyadCgQRo+fLhFxzxJZGSkvLy8FBERIU9PT0u8BQAA4BmVEecF8fHxMgxDmTJlUs+ePXXy5Elt2LDhsdusWLFCTZo00ZkzZ1SkSBFJ0ueff64xY8bo6tWrypIlyxOPmxHfCwAAYBupmRfY9EypzJkzP7Y/KipKe/bsUVBQkNk29erVM02wLDUGAADgWefo6KhMmTKlapsNGzaodOnSpkBKkho1aqSoqCjt3r3bwhUCAAD8HydbF/A4Fy5ckGEYyps3r1l73rx5deDAAYuOSUpsbKxiY2NNzyMjI5/q9QAAAGQ0oaGhSc6RpIdzqKQwRwIAAJaQoUOp+Ph4SZKzs7NZe+bMmRUXF2fRMUkZP368xowZ8xSvAACA5AV9/IetS3jurR7Z2NYlZHjx8fFJzpEkJTtPYo4EAEhPASsG2boEu7A5+Atbl2Dby/eexNvbW5J048YNs/br16+b+iw1JilDhw5VRESE6REaGvoUrwYAACDj8fb2TnKOlNCXFOZIAADAEjJ0KJUnTx75+Pho+/btZu1bt25VpUqVLDomKS4uLvL09DR7AAAAPE9efvllHT582OwSvC1btihTpkyqWLFiktswRwIAAJaQoUMpSXrzzTc1c+ZMHTt2TJL07bff6vTp0+rVq5fFxwAAADzvrly5ohIlSmjVqlWSpFatWsnT01MjR45UXFycbty4oQkTJqhVq1bKlSuXjasFAADPM5uuKbVkyRK9//77pvUKOnbsKFdXVw0YMEADBgyQJA0ZMkQXLlxQhQoV5O7urkyZMunHH3+Uv7+/aT+WGgMAAPCse+WVV3ThwgVdu3ZN9+7dU4kSJSRJJ0+elCQ9ePBAp06d0u3btyVJXl5e+v3339W5c2fNnTtX0dHRql+/vr755hubvQYAAGAfHAzDMGx18KioKIWFhSVqz5Ejh3LkyGHWdufOHYWHhytfvnxycko6S7PUmORERkbKy8tLERERnKYO4LnHItx4HqTnQucZdV5w7tw53b9/P1F7QjgVFxenM2fOKF++fHJ3dzcbc+nSJbm6uip79uypOmZGfS8AID2wCDeeF+m10Hlq5gU2PVPKw8NDHh4eKRrr7u6eaOKUXmMAAACeVYULF35sf6ZMmUwB1aPy58+fHiUBAAAkKcOvKQUAAAAAAIDnD6EUAAAAAAAArI5QCgAAAAAAAFZHKAUAAAAAAACrI5QCAAAAAACA1RFKAQAAAAAAwOoIpQAAAAAAAGB1hFIAAAAAAACwOkIpAAAAAAAAWB2hFAAAAAAAAKyOUAoAAAAAAABWRygFAAAAAAAAqyOUAgAAAAAAgNURSgEAAAAAAMDqCKUAAAAAAABgdYRSAAAAAAAAsDpCKQAAAAAAAFgdoRQAAAAAAACsjlAKAAAAAAAAVkcoBQAAAAAAAKsjlAIAAAAAAIDVEUoBAAAAAADA6gilAAAAAAAAYHWEUgAAAAAAALA6QikAAAAAAABYHaEUAAAAAAAArI5QCgAAAAAAAFZHKAUAAAAAAACrI5QCAAAAAACA1RFKAQAAAAAAwOoIpQAAAAAAAGB1hFIAAAAAAACwOkIpAAAAAAAAWB2hFAAAAAAAAKyOUAoAAAAAAABWRygFAAAAAAAAqyOUAgAAAAAAgNU52boAAM+moI//sHUJAAAAGU7AikG2LgEAnhmcKQUAAAAAAACrI5QCAAAAAACA1RFKAQAAAAAAwOoIpQAAAAAAAGB1hFIAAAAAAACwOkIpAAAAAAAAWB2hFAAAAAAAAKyOUAoAAAAAAABW52TrAp4kPj5eixYt0sqVK3Xz5k0VKlRIPXr00Isvvmg2LiQkRNOnT1dYWJj8/f313nvvKWfOnKkeAwAA8CyLjY3VtGnTtHHjRrm7u6tjx44KDg5+7Dbnzp3T9OnTdezYMWXJkkU1atRQz5495erqaqWqAQCAPcrwZ0qNGDFCffr00csvv6zevXtLkqpWraqtW7eaxmzbtk01atSQh4eHOnfubHp+586dVI0BAAB41rVu3Vrffvut2rRpo4oVK6ply5aaOXNmsuMvXryoSpUq6ejRo+rWrZsaNmyoKVOmqFWrVlasGgAA2KMMf6bUzz//rLfeekv9+/eXJDVp0kQbNmzQkiVLVKNGDUnSsGHD1LhxY02ZMkWS1KhRI+XPn18zZ87U22+/neIxAAAAz7INGzZoxYoV2r9/v8qXLy9JunPnjoYNG6Zu3brJySnx1O/vv/9WeHi4fv75Z2XJkkWS5O7urrZt2yoyMlKenp5WfQ0AAMB+ZPgzpfz9/XXw4EHFx8dLkq5cuaJLly6pQoUKkqTo6Ght3rxZzZs3N23j4eGhwMBArVmzJsVjAAAAnnVr1qxR0aJFTYGUJLVo0ULXrl3T3r17k9ymXLlyMgxDBw8eNLXt2bNHxYoVk4eHR7rXDAAA7FeGD6W+//57ubq6qmjRoqpZs6b8/f310UcfqUuXLpKk0NBQxcfHq2DBgmbbFSxYUGfPnk3xmKTExsYqMjLS7AEAAGBply9fVlxc3FPv5+zZs0nOdxL6kvLiiy9q+fLlatasmapVq6ayZctqw4YNWrdunRwcHJLchjkSAACwhAwfSs2bN0/r1q3TwIED9f7776tdu3b65JNPTN/m3bt3T5ISLcTp5uZm6kvJmKSMHz9eXl5epoePj4/FXhcAAECCb775RoUKFdLQoUN14sSJNO/n3r17Sc53EvqScu3aNQ0bNkyVKlXS4MGD9d577+natWv69NNPkz0OcyQAAGAJGTqUunPnjt577z2NHTtW77zzjpo2bapp06apQoUKGj58uCQpe/bskqTw8HCzbW/cuGHqS8mYpAwdOlQRERGmR2hoqMVeGwAAQIIBAwZoyJAh+vPPP1WqVCkFBARo7ty5qb4hS/bs2ZOc7yT0JeXLL7/UrVu39Ouvv6ply5bq3r275s2bpxkzZmjPnj1JbsMcCQAAWEKGDqUiIiIUGxurIkWKmLUXKVJEYWFhkqQCBQooV65ciSZNe/bs0QsvvJDiMUlxcXGRp6en2QMAAMDScuTIoQEDBmjfvn3avXu3KlSooEGDBilfvnzq2bOntm3blqL9vPDCCzp69KhiYmJMbQnzn4T1OB919epVFShQQM7Ozqa2hLlXwnzrUcyRAACAJWToUCp//vwqXLiw5syZowcPHkh6uObCihUrVK1aNdO4rl27atasWbp69aokaeXKldq3b5+6du2aqjEAAAC29uKLL2ratGnas2ePypYtq1mzZqlGjRoqX768li9f/thtW7duLenh2U/Sw0v2Jk2apPr166tAgQKSpOvXr6tevXravHmzJKl69erau3evdu/ebdrPzJkzlSVLFlWsWDE9XiIAAICkDB5KSdLChQsVEhKiIkWKqHr16ipVqpTKly+vjz76yDRmzJgxKlu2rEqWLKkXX3xRrVq10sSJE1WjRo1UjQEAALCl+/fva+nSpWrSpIlKlCihe/fu6auvvtLhw4fVtGlTdejQQX///Xey2+fJk0fz58/X+PHj5efnp0KFCunWrVuaNWuWaUxMTIzWrVtnOguqa9eu6t69u2rWrKkqVaqodOnS+vLLLzVnzhzlzZs33V8zAACwX062LuBJqlatqn///VcnT57UjRs3VLhw4UR3lXFzc9PKlSt1/PhxhYWFqUyZMvL29k71GAAAAFs4ffq0vvrqK82bN0/37t1Thw4dtHPnTr344oumMWPHjtXdu3e1bds21a1bN9l9NWvWTBcvXtT+/fvl5uamChUqmN1FL1euXFq7dq3Kly8vSXJwcND06dP18ccf69SpU3J1dVXJkiUTLZgOAABgaRk+lJIkJycn+fr6PnFcqVKlVKpUqaceAwAAYE3z5s3Tjh07NHHiRLVt29Z0x7xHtWzZMkX7c3d3V/Xq1ZPsc3FxUb169RK1e3t784UdAACwqmcilAIAAHievfDCC3r55ZfVqFGjRH0rV66UJDVq1Eg1a9a0dmkAAADpJsOvKQUAAPC827t3r3bu3Jlk344dOxQSEmLligAAANIfoRQAAEAGFR0drb179yp37ty2LgUAAMDiuHwPAADARj766CN99NFHio+Pl/RwMfP/iouLU+7cuTVjxgxblAcAAJCuCKUAAABs5LXXXlPlypX1448/SpI6depk6nNwcJCXl5f8/f3l7u5uqxIBAADSDaEUAACAjZQoUUIlSpRQ+fLlJUn58+e3cUUAAADWQygFAABgY4RRAADAHrHQOQAAgA2MHj1aDg4OGj16tOnn5B6jR4+2dbkAAAAWx5lSAAAANtClSxfVrFlTxYoVkyTVrFkz2bEJYwAAAJ4nhFIAAAA2UKxYMbOwieAJAADYmzRdvlevXr009QEAAAAAAABSGkOpdevWJdkeHx+v9evXP1VBAAAA9uBJ60ixphQAAHjeperyvZMnTyb5s/QwkNq2bZsKFChgmcoAAACeYwlrSqUEl/YBAIDnUapCqZIlSyb5c4IsWbJo6tSpT18VAADAc+7RNaUAAADsTapCqTNnzkiSihYtavo5gbOzs/LkySMnJ9ZOBwAAAAAAwOOlak2pIkWKqEiRIoqKijL9nPAoUKAAgRQAAEAKJawpNXr06CeuL8WaUgAA4HmUphQpa9asunv3ro4dO6bw8PBE/dyBDwAA4PES1pRKuITvcetLcZkfAAB4HqUplFqzZo1ee+013bhxI8l+wzCeqigAAIDn3aNrShE8AQAAe5OmUGrgwIHq2bOnhgwZouzZs1u6JgAAALt04sQJ/fXXX7p06ZLy58+v+vXrq0SJErYuCwAAIF2kak2pBOfOndPIkSMJpAAAACxkyJAhKlOmjD755BOtWrVKn3zyicqUKaNhw4bZujQAAIB0kaZQytfXV2fPnrVwKQAAAPbpr7/+0ldffaU//vhDFy5c0K5du3ThwgWtWLFC//vf/7Ru3TpblwgAAGBxaQql+vTpo65du2r9+vUKDQ3VhQsXzB4AAABIuZCQEHXu3FlBQUFm7UFBQercubNCQkJsVBkAAED6SdOaUr169ZIk1a1bN8l+FjoHAABIucKFC+vQoUNJ9kVGRqpw4cJWrggAACD9pSmUOnr0qKXrAAAAsFvBwcEaPXq0Jk2apNdff105c+bUjRs3NGfOHO3evVszZsywdYkAAAAWl6ZQytfX19J1AAAA2JVx48Zp3Lhxpuf37t3T4MGDNXjwYDk7O+v+/fuSJGdnZ02dOpUFzwEAwHMnTaHUvn37Htv/wgsvpGW3AAAAdqNly5YqW7ZsisbyhSAAAHgepSmUqlix4mP7WVMKAADg8Xx9fQmbAACAXUtTKHXt2jWz5/Hx8Tpx4oTefvtt9evXzyKFAQAAAAAA4PmVplDK29s7UVvu3Ln1/fffq3PnzurWrdvT1gUAAGBXbt26palTp+rAgQO6efOmWV+XLl3UpUsXG1UGAACQPtIUSiWnUKFCOn78uCV3CQAA8NyLjo7Wyy+/rLx58youLk6Ojo4qVqyYfvvtN+XMmVP58+e3dYkAAAAW55iWjWJiYhI9Ll++rBEjRqh48eKWrhEAAOC59vvvvytXrlzatGmTGjRooHr16umHH37QkSNHFBMTozx58ti6RAAAAItL05lSrq6uSbbnzZtXP//881MVBAAAYG9OnjypWrVqycHBQS4uLgoPD5ck5c+fX61atdK6devk7+9v4yoBAAAsK02h1ObNmxO1Zc+eXSVKlJCLi8tTFwUAAGBP7t27pyxZskiSChYsqI0bN5r6wsPDVbRoUVuVBgAAkG7SFErVrFnT0nUAAABAUuPGjfXWW2+pXbt2ypIlixYvXqwPPvjA1mUBAABY3FMtdH7y5EkdPXpUhmGobNmyKlGihKXqAgAAsBtvvfWW6eccOXJo06ZN+vLLLxUdHa3ffvtNfn5+NqwOAAAgfaQplIqIiFD37t21ZMkSOTo+XCs9Pj5eLVu21OzZs+Xl5WXRIgEAAJ5nuXPnNntesWJFzZ071zbFAAAAWEma7r43cOBAnTp1Sps3bzbdfW/z5s06efKk3nnnHUvXCAAAYBdOnDih6dOna+TIkZo+fbpOnjxp65IAAADSTZrOlFq+fLm2bt2qMmXKmNpq1qyphQsXst4UAABAGgwZMkSff/658ubNq3z58uny5csaMGCABg8erHHjxtm6PAAAAItLUygVHR0tb2/vRO05c+bU3bt3n7ooAAAAe/LXX3/pq6++0h9//KGgoCBT++rVq9WqVSsFBgYqMDDQhhUCAABYXpou36tWrZpGjBihe/fumdpiY2M1fPhwVatWzWLFAQAA2IOQkBB17tzZLJCSpKCgIHXu3FkhISE2qgwAACD9pOlMqcmTJysoKEjLli1ThQoVJEn79u2To6OjVq9ebdECAQAAnneFCxfWoUOHkuyLjIxU4cKFrVwRAABA+kvTmVIVKlTQiRMnNHLkSBUvXlwlSpTQhx9+qBMnTphCKgAAAKRMcHCwdu3apUmTJunGjRuSpBs3bmjSpEnavXu3GjdubOMKAQAALC9NZ0pJkoeHh/r162fJWgAAAOzGuHHjzBYwv3fvngYPHqzBgwfL2dlZ9+/flyQ5Oztr6tSpGjZsmK1KBQAASBdpCqUiIyP1xx9/qEOHDmbtP/30kxo3bixPT0+LFAcAAPC8atmypcqWLZuisb6+vulcDQAAgPWlKZR69913VaVKlUTtt2/f1vvvv68ZM2Y8dWEAAADPM19fX8ImAABg19K0ptSSJUvUqlWrRO2tWrXSkiVLnrooAAAAe3X9+nXt379f169ft3UpAAAA6SpNZ0rFx8frxo0byp49u1n7jRs3dO/ePYsU9qiVK1fq77//lpubmzp37qySJUua9Z8/f17ff/+9wsLC5O/vr27dusnFxSXVYwAAAGxh586d6tu3r0JCQkxtlSpV0ldffaXKlSunal+//vqrNm7cKHd3d7Vr104vvPDCE7e5dOmSFixYoPPnz+vll19Wx44d5eiYpu8vAQAAUiRNM4369evrvffe0+3bt01tUVFRGjRokOrVq2ex4iTpwYMHatGihXr37i0vLy95eXmpffv2ZrdNPnLkiCpUqKA9e/bIx8dH//vf/1S3bl3TAqEpHQMAAGALYWFhql+/vkqVKqWNGzfqxIkT2rRpk0qVKqX69esrLCwsxfvq3bu3+vbtq1y5cikiIkIvv/yyfvvtt8dus2HDBvn6+mrHjh0qXbq0tmzZoh49ejztywIAAHisNJ0p9dlnnykgIECFCxdWxYoVZRiG9u7dKw8PD23cuNGiBU6ePFnr1q3T4cOH5ePjI0nq27ev7ty5YxozZMgQvfjii1qyZIkcHBzUpUsXFS1aVPPmzVP37t1TPAYAAMAWli1bpipVqmj+/PmmthIlSiggIEANGjTQsmXL9MYbbzxxP7t379Z3332njRs3qlatWpIe3r1vwIABatKkiRwcHBJtc/v2bbVr1049evTQ5MmTTe0XL160wCsDAABIXprOlCpcuLAOHjyo0aNHy8fHR4ULF9aYMWN04MABFSlSxKIFzpgxQ507dzYFUpKUJUsW5cyZU9LD2yevXr1a7du3N0208uXLpzp16uj3339P8RgAAABbCQ8PT/ZOfGXKlFF4eHiK9vP777+rQIECpkBKkl577TWdO3dOBw4cSHKbpUuX6tq1a/rggw/M2gsUKJDC6gEAANImTWdKSZKXl5f69+9vyVoSiYiI0OnTp1W1alXNnTtXu3fvVv78+dW+fXsVLVpU0sN1ou7fv58oDCtatKg2b96c4jFJiY2NVWxsrOl5ZGSkZV4YAADAf/j5+WnGjBkaNmyYcufObWq/cuWKli5dqq+++ipF+zl58qQKFy5s1pYwZzp58qQqVKiQaJs9e/aoePHiioqK0pdffql79+7p5ZdfVps2bZJdU4o5EgAAsIQMvXplVFSUJOnjjz/WypUrVbJkSR06dEhlypQxXSYYHR0tSfLw8DDb1sPDw9SXkjFJGT9+vGkdKy8vL7OztQAAACylcePGKlGihEqWLKlOnTpp8ODB6tSpk0qVKqVSpUqpcePGKdpPdHR0kvOdhL6kREVFKTIyUk2aNJG7u7ty5syp9957T8HBwTIMI8ltmCMBAABLSPOZUtbg6ekpSSpWrJgWLVpkar9z544+/PBDbdy40TTm5s2bZtuGh4eb+lIyJilDhw7VoEGDTM8jIyOZdAEAAItzdHTUmjVrNGfOHP3555/asmWL8ufPry+++EKvv/56iu+C5+npqQsXLpi1JVz6l9ycx9PTU1evXtXy5ctVtWpVSdKrr76qihUrasOGDapTp06ibZgjAQAAS8jwoVShQoVUvnx5s3Z/f3/9+OOPkiQfHx95enrqyJEjevXVV01jDh8+LD8/vxSPSYqLi4tcXFws+ZIAAAAS2bRpkySpZ8+e6tmzZ5r34+fnp2XLlunBgwdycno4zTt8+LAkqVy5cklu4+/vL0lm8y0/Pz85ODjo/PnzSW7DHAkAAFhChr58T5I6deqkNWvW6N69e5KkBw8eaM2aNapUqZKkh98stmvXTrNnzzbdkW/Xrl36559/1KFDhxSPAQAAsJWtW7dqzZo1T72fVq1a6c6dO6Yv7wzD0LRp01S5cmUVL15c0sMzx3v27Kndu3dLkpo2bSoPDw+tWLHCtJ+VK1dKkl588cWnrgkAACA5aQ6l7ty5o+XLl5vdOvj48ePJrj2QVsOGDVP27NlVrlw5vfbaaypXrpxu376tL774wjRm3LhxcnJyUoUKFdSyZUvVq1dPffr0MTsrKiVjAAAAbKFixYraunXrU++nSJEi+vLLL/XWW28pODhYlSpV0q5duzRz5kzTmDt37mjWrFk6c+aMJClnzpyaPXu2evbsqaZNm6pZs2bq0KGDxo0bZzqLCgAAID04GGlIkY4fP64GDRooJiZGYWFhpiCqc+fOaty4sdq3b2/RIg3D0JYtW3Tu3DkVKlRI1atXN52SnuD+/ftav369wsLC5O/vrxdeeCHRflIy5nEiIyPl5eWliIiIx65FBdiDoI//sHUJAPBEq0embIHwtLDkvOD06dNq2rSpfH191bp1a3l7e5v1FytWTMWKFUvx/s6ePatt27bJzc1NgYGBZouf3717VwsWLFC9evXM7kwcFhamjRs3ysnJSZUqVVKhQoVSfDzmSMD/CVgx6MmDACAD2Bz8xZMHpUFq5gVpCqUaNWokPz8/ffrpp3J0dDSFUiEhIXrzzTcVEhKStsozOCZcwP8hlALwLHhWQqnRo0drzJgxyfaPGjVKo0ePfqpjpCfmSMD/IZQC8KzICKFUmhY63759uxYsWCAHBwezdl9fXx08eDAtuwQAALBbo0ePztChEwAAQHpI05pS8fHxpoXH/xtMnT17Vl5eXpapDAAAAAAAAM+tNIVS9evX16RJkyT9Xyh1/fp1DRgwQA0bNrRcdQAAAHYiOjpakydPVlBQkPz9/RUUFKQpU6YoJibG1qUBAACkizSFUp9//rkWL16sMmXKyDAM1alTR0WLFtXZs2c1YcIES9cIAADwXIuOjla1atX06aefqmTJkmrfvr1KliypCRMmqHr16gRTAADguZSmNaUKFy6sAwcO6Mcff1RISIji4+PVsmVLde3alcUtAQAAUmnRokWKjo7Wv//+a7YUwieffKLKlStr0aJF6tKliw0rBAAAsLw0hVJr165VYGCg+vTpY+l6AAAA7M7169fVuHHjRGtzenl5qVGjRrp27ZqNKgMAAEg/abp8r1GjRipYsKDeffdd7d2719I1AQAA2JXy5cvrn3/+UVxcnFl7XFycduzYoQoVKtioMgAAgPSTpjOlLl68qJ9//lnz58/XF198obJly6pTp07q2LGjChUqZOkaAQAAnmvFixdXRESE6tatqy5duihv3ry6cuWKfvjhB0VEREiS/vrrL0lSsWLFVKxYMVuWCwAAYBFpCqVy586t/v37q3///jp16pTmz5+vuXPnavjw4QoICNDGjRstXScAAMBz64cfftCRI0ckSZs2bUrUX79+fdPPo0aN0ujRo61VGgAAQLpJ0+V7/1W8eHENGzZMX375pcqXL5/kRAoAAADJGz16tAzDSNGDQAoAADwvniqU2rFjhwYMGKACBQqoefPmKlasmH799VdL1QYAAAAAAIDnVJou3xs1apTmz5+v06dPq1atWho7dqzatGmjbNmyWbg8AAAAAAAAPI/SFEotXbpUvXr10muvvSYfHx9L1wQAAAAAAIDnXJpCqQMHDli6DgAAAAAAANiRFIdSx44dkyT5+vqafk6Or6/v01UFAAAAAACA51qKQ6kyZcpIkgzDMP2cHMMwnq4qAAAAO2MYhn799Vft2LFDAQEBatq0qc6cOaOoqCiVL1/e1uUBAABYXIpDqdDQ0CR/BgAAwNNr1aqVtm/fLg8PD7m7u6tp06bKkiWLGjZsqP379ytLliy2LhEAAMCiHFM6sGDBgipYsKAkqVu3bqbnjz66deuWXrUCAAA8l9auXatDhw7p+PHj6tixo6k9X758Kl++vJYtW2a74gAAANJJikOp/1q3bl2S7fHx8Vq/fv1TFQQAAGBv9u/fr6ZNm8rDw0MODg5mfUWKFNHp06dtVBkAAED6SdXd906ePJnkz9LDQGrbtm0qUKCAZSoDAACwE66urrpx40aSffv371fbtm2tXBEAAED6S1UoVbJkySR/TpAlSxZNnTr16asCAACwI40bN9bw4cPVo0cP05lSsbGx+uyzz7R582Z9//33Nq4QAADA8lIVSp05c0aSVLRoUdPPCZydnZUnTx45OaVqlwAAAHavSJEimjZtmurXry8HBwe5urpq/PjxcnBw0Ny5c5UvXz5blwgAAGBxqUqQihQpIkmKiopS1qxZ06MeAAAAu9SpUyfVq1dPK1eu1OXLl5U7d241btxY+fPnt3VpAAAA6SJNpzURSAEAAFjO33//rUyZMqlWrVrq3r27rcsBAACwijTdfe/BgweaOnWqatWqpSJFiqhgwYJmDwAAAKTcv//+q7p166pIkSIaOnSoDh8+bOuSAAAA0l2aQqlPPvlEkydPVsuWLXXu3DmNGDFCDRo00JUrV9S+fXtL1wgAAPBc69Onj0JDQ/X2229rzZo18vPzU8WKFfX555/r0qVLti4PAAAgXaQplPr+++/1888/a+DAgZKkN954Q7Nnz9Y333yjffv2WbA8AAAA+5A/f34NGjRIu3fv1tGjRxUcHKyvv/5aPj4+mj59uq3LAwAAsLg0hVLnz59XxYoVJUmurq6KioqSJLVt21bbt2+3XHUAAAB2qFSpUqpTp45q164tR0dHXb161dYlAQAAWFyaQqm4uDg5OT1cI71o0aLasmWLpIfrIbi6ulquOgAAADuyd+9evffee/Lx8VHDhg117do1zZs3T++//76tSwMAALC4NN1977/efPNNdejQQdWqVdPOnTvVqVMnS9QFAABgN/7880+9++67Onr0qKpVq6bhw4erbdu28vb2tnVpAAAA6SZNodT9+/dNP/fv31+FChXS9u3b1b59e3Xp0sVixQEAANiDsLAwdejQQZ06dVLRokVtXQ4AAIBVpCmUSrh0L0GzZs3UrFkzixQEAABgb7p162brEgAAAKwuxaHUsWPHUrxTX1/fNBUDAABgL44dO6Zjx46Z5k2Pm2v5+voyvwIAAM+dFIdSZcqUSfFODcNIUzEAAAD2YsmSJRo3bpyGDRsmSRo3blyyY4cNG2YaBwAA8LxIcSgVGhqannUAAADYlUeDJkInAABgb1IcShUsWDA96wAAALBbX3zxhSRp0KBBqeoDAAB4lqVpofN9+/Y9tv+FF15Iy24BAADsUmRkZLJ9N27ckLu7uxWrAQAAsI40hVIVK1Z8bD9rSgEAADzZ8ePHTQ9JWrFihVl/VFSUli5dqg8//NAW5QEAAKSrNIVS165dM3seHx+vEydO6O2331a/fv0sUhgAAMDzbtGiRRo7dqwePHgg6eHi5wkcHBzk5eWlwMBAtWzZ0lYlAgAApJs0hVLe3t6J2nLnzq3vv/9enTt3Vrdu3Z62LgAAgOfeiBEjNGLECNaNAgAAdilNoVRyChUqZDr9HAAAAClDGAUAAOxRmkKpmJiYRG03b97UhAkTVLx48acuCgAAwF7Fx8fr7t27Zm2ZM2dW5syZbVQRAABA+nBMy0aurq6JHvnz59eiRYs0depUS9cIAADw3Fu7dq1eeuklubq6ysPDw+wxbtw4W5cHAABgcWk6U2rz5s2J2rJnz64SJUrIxcXlqYsCngVBH/9h6xIAAM+Jc+fOqXXr1hoxYoSOHj0qR0dHNWrUSN9++61Onjyp7t2727pEIFUCVnBJKgDgydIUStWsWdPSdQAAANittWvX6tVXX9XgwYM1evRoxcfHq2XLlmrevLmqVaumQ4cOqVChQrYuEwAAwKLSdPnef8XExCR6AAAAIOUuXbqkUqVKSZI8PT118+ZNSZKjo6Nq1aqlAwcO2LI8AACAdJGmM6VOnDiht956S1u3blV0dHSifsMwnrqwpBw+fFhLly5VlSpVVL9+fbO+qKgoLVu2TGFhYfL391dQUFCi7VMyBgAAwNri4+Pl6Pjwu8LSpUvru+++U3R0tDJlyqRt27apW7duqdpfSEiINm3aJHd3dzVt2lT58uVL8bbTp0/XjRs3NHjwYJZlAAAA6SpNZ0p17dpVWbJk0aJFi7R58+ZEj/Rw584dtWnTRhMnTtQff5iv5XPhwgX5+/tr6tSpOnXqlF5//XW1adPGLBxLyRgAAABbyJEjh3LkyCFJatiwobJmzar8+fOrQIECCg0NVevWrVO8r48//lh16tTR4cOHtXz5cpUuXVrbtm1L0bbfffedhg4dqpEjRyb5xSMAAIAlpelMqb179+ry5cvKli2bhctJ3ltvvaXGjRtr7dq1ifqGDBmiXLlyaevWrXJ2dtbAgQNVrlw5/frrr6ZJXErGAAAA2MKAAQNMP2fKlEmbNm3S6tWrFR0drYYNGyp79uwp2s+xY8c0evRo/frrr2revLkkqVOnTurdu7cOHTr02G2PHDmiMWPGaOzYserfv3+aXwsAAEBKpelMqcKFC+v69euWriVZ8+fP14EDB/TJJ58k6ouLi9OyZcvUpUsXOTs7S3p42ntAQIB++eWXFI8BAADIKFxdXdW8eXN16NAhxYGUJC1dulQ5c+ZU06ZNTW29evXS4cOHdezYsWS3i4mJUbt27fTFF1+oYMGCT1U7AABASqXpTKkxY8bo9ddf12effabixYvLwcHBrN/b29sixUnSyZMnNWjQIK1fv16ZM2dO1H/+/HndvXvXtDhoglKlSmnHjh0pHpOU2NhYxcbGmp5HRkY+zUsBAAAwOXbs2GODov/y9fWVr69vivZZvHhx0/pUkkzzn2PHjiW7j4EDB+qll15S27ZttWzZsicehzkSAACwhDSFUnny5NHBgwdVrVq1JPsttU7TvXv31K5dO3344YcqW7ZskmNu374tSfLy8jJrz5Ytm6kvJWOSMn78eI0ZMybN9QMAACRnyZIlGjduXIrGDhs2TMOGDXviuNu3byc530noS8qvv/6qtWvXat++fSmqRWKOBAAALCNNoVSfPn3UoEEDvfXWW+m6rtSPP/6oU6dO6ebNmxo7dqwkKSwsTDt37tTYsWM1fPhwubu7S0r8DV1ERISpLyVjkjJ06FANGjTI9DwyMlI+Pj5P/8IAAIDdS2nQlBru7u66fPmyWVtERISpLynvvPOOKlWqpC+//FKSdPToUUnSpEmTVL9+fdWuXTvRNsyRAACAJaQplDp37pz++eefRN/EWVq5cuXUr18/xcTEmNoMw1BcXJxiYmJkGIYKFSokV1dXnTx5Ug0aNDCNO3HihEqXLi1JKRqTFBcXF26FDAAAnhmlS5fW6tWrZRiGaXmFEydOmPqS0qdPH925c8c037p//76kh5foJfz8KOZIAADAEtIUSpUoUUKXL19O91CqSpUqqlKlilnbihUrVK1aNdOZU46OjmrSpInmzZun3r17y8nJSadOndKmTZs0b948SZKTk9MTxwAAANjKoUOHHnt3PD8/P/n5+T1xP82bN9fIkSO1cuVKNW7cWJI0e/Zs+fr6mpZCiIqK0pdffqnWrVvL19dXQ4cONdvHsmXLtHjxYg0fPtyqd1oGAAD2J02hVNeuXdWpUyd99tlnKlGiRKKFzq1915ZPP/1UNWrUUJ06dfTyyy/rl19+UcOGDdW2bdtUjQEAALCFlStXauLEiWZtCWcvubq6avTo0SkKpcqVK6ehQ4fqtddeU+fOnXXp0iWtXr1aK1euNI2JiIjQyJEjU7x4OgAAQHpxMNKwKvmjIdSjLLXQeVK++uorFS1aVI0aNTJrv3nzphYvXqywsDD5+/uradOmZneeSemYx4mMjJSXl5ciIiLk6elpkdeDZ1fQx3/YugQAwBOsHtk43fad3vOC+Ph4rVy5Uh988IH++ecfZc2aNcXbbtmyRZs2bZKbm5tatGihwoULm9U9ceJEdejQQeXKlUu07dGjRzV//nyNGDFCWbJkSdHxmCPhUQErBj15EADApjYHf5Eu+03NvCBNodSTbl/8vH7rxoQL/0UoBQAZ37McSiXo3r27goKC1K5du3Q7xtNijoRHEUoBQMaXEUKpNF2+97yGTgAAABlN1qxZFRoaausyAAAALC5NodS+ffse2//CCy+kZbcAAAB26cqVK7py5YpZ24MHD7Rv3z7NmTNHy5Yts01hAAAA6ShNoVTFihUf25+ea0oBAAA8b2bMmKExY8Ykas+WLZuGDBmiwMBAG1QFAACQvtIUSl27ds3seXx8vE6cOKG3335b/fr1s0hhAAAA9uL9999PNIdydnaWl5eXjSoCAABIf2kKpby9vRO15c6dW99//706d+6sbt26PW1dAAAAdsPNzU1ubm62LgMAAMCq0hRKJadQoUI6fvy4JXcJAABgNyIjIxUaGqr79++btefNm1d58+a1UVUAAADpI02hVExMTKK2mzdvasKECSpevPhTFwUAAGBP4uPj1bt3b82ZM0fx8fGJ+keNGqXRo0dbvzAAAIB0lKZQytXVNcn2vHnz6ueff36qggAAAOzNr7/+qlWrVmnNmjUqV66cnJzMp2hc2gcAAJ5HaQqlNm/enKgte/bsKlGihFxcXJ66KAAAAHty6tQptW/fnrvsAQAAu5KmUKpmzZqWrgMAAMBu+fn56ZtvvrF1GQAAAFblmJrBV69e1ahRo5LtHzVqlK5du/bURQEAANiTxo0by9HRUX379tWqVau0ZcsWs8f58+dtXSIAAIDFpSqU+vzzz+Xl5ZVsv6enpz7//POnLgoAAMCe3L17V5cvX9bXX3+tV199VQEBAWaP2bNn27pEAAAAi0tVKLVixQo1atQo2f5GjRppxYoVT10UAACAPfn555919epV/fPPP4qKilJ0dLTZY8SIEbYuEQAAwOJStabU6dOnVbRo0WT7ixYtqtOnTz91UQAAAPYkPDxcbdq0UZUqVWxdCgAAgNWk6kwpV1dXXb9+Pdn+69evy9XV9amLAgAAsCd+fn46ePCgrcsAAACwqlSdKVWlShX98MMPGjp0aJL98+bN4xs+AACAVCpRooROnDih119/Xc2aNVPWrFnN+osVK6ZixYrZqDoAAID0kapQatCgQQoODtaDBw80cOBAeXh4SJKioqI0ZcoUjR07Vn/++We6FAoAAPC8+vHHH3X69GmdPn1ac+fOTdQ/atQojR492up1AQAApKdUhVL169fXZ599pnfffVejRo1S/vz5ZRiGLl++LCcnJ02ZMkV169ZNr1oBAACeS6NHjyZ0AgAAdidVoZQkDRgwQE2bNtXixYt1/PhxOTg4qGTJkmrbtq0KFy6cHjUCAAAAAADgOZPqUEqSihQposGDB1u6FgAAALt06NAhHTp0KNl+Pz8/+fn5WbEiAACA9JemUAoAAACWs3LlSk2cONGs7c6dO4qJiZGrq6tGjx5NKAUAAJ47jrYuAAAAwN69//77un79utnjzp07+v3331WsWDG99dZbti4RAADA4gilAAAAMiBHR0cFBwercuXK+uOPP2xdDgAAgMURSgEAAGRgWbNmVWhoqK3LAAAAsDjWlAIAALCxK1eu6MqVK2ZtDx480L59+zRnzhwtW7bMNoUBAACkI0IpAAAAG5sxY4bGjBmTqD1btmwaMmSIAgMDbVAVAABA+iKUQroI+pi1LwAASKn3339f/fr1M2tzdnaWl5eXjSpCegpYMcjWJQAAkCEQSgEAANiYm5ub3NzcbF0GAACAVbHQOQAAgA2NHDlSW7duTbJv69atGjlypJUrAgAAsA5CKQAAABs5d+6cFi1apKpVqybZX7VqVS1atEjnzp2zcmUAAADpj1AKAADARrZs2aIqVaooU6ZMSfZnypRJlStXTvZMKgAAgGcZoRQAAICNnD9/XgULFnzsmIIFC+r8+fNWqggAAMB6CKUAAABsJFu2bAoNDX3smNDQUGXPnt1KFQEAAFgPoRQAAICN1K5dW8uWLUv2TKjz589r+fLlqlWrlpUrAwAASH+EUgAAADZStmxZvfrqq6pevbrmzJmj8+fP6/79+zp//rzmzJmj6tWrKzg4WGXKlLF1qQAAABbnZOsCAAAA7Nns2bPVo0cPde/ePVFf+/btNXPmTBtUBQAAkP4IpQAAAGwoa9as+vnnnzVmzBht3rxZ4eHhypEjh2rVqqXSpUvbujwAAIB0QygFAACQAfj6+srX19fWZQAAAFgNa0oBAAAAAADA6gilAAAAAAAAYHWEUgAAAAAAALA6QikAAAAAAABYHaEUAAAAAAAArI5QCgAAAAAAAFZHKAUAAAAAAACrI5QCAAAAAACA1TnZuoCUuHbtmkJCQuTk5KSKFSvK29s70Zi4uDht27ZNYWFh8vf3V+nSpdM0BgAA4Fl36dIl/fPPP3J3d1etWrXk6ur62PHx8fHat2+fzp07pyJFiqhixYpWqhQAANizDB1KGYah3r17688//1T58uV19+5dhYSEaPLkyerVq5dp3M2bNxUUFKQrV66oXLly2rJli9544w1NmjQpVWMAAACedbNnz1b//v1VtWpVhYWFKSIiQmvXrpWvr2+S4zdu3Ki+ffvKxcVFhQoV0o4dO1S4cGGtWLFCOXPmtHL1AADAnmT4UKpKlSr6+uuv5ezsLEn69ttv1adPHzVo0ECFCxeWJA0fPlyRkZE6fPiwPDw8tG3bNtWsWVNBQUGqX79+iscAAAA8y0JDQ9WnTx9NmzZNvXr1Unx8vIKDg9WjRw9t3bo1yW3u37+vX3/91XQGeVRUlCpVqqQhQ4Zo5syZ1iwfAADYmQy9ppSjo6N69uxpCqQkqXnz5oqLi9Phw4clPQyufvrpJ/Xo0UMeHh6SpOrVq6ty5cqaP39+iscAAAA863755Re5urqqW7dukh7OpQYMGKBt27bpzJkzSW5Tr149syUNPDw8FBgYqAMHDlijZAAAYMcy9JlSSVmzZo0cHBxUrlw5SQ+/Ebx165b8/PzMxvn7+2vPnj0pHpOU2NhYxcbGmp5HRkZa6mUAAABY3MGDB1W6dGmzL/T8/f0lSYcOHVLRokWfuI8HDx5o/fr1ql69erJjmCMBAABLyNBnSj3q9OnTGjhwoPr162e6dC8iIkKSlD17drOxOXLkMPWlZExSxo8fLy8vL9PDx8fHYq8FAADA0iIiIpKc7yT0pcTgwYN16dIlDR8+PNkxzJEAAIAlPDOh1IULF1SvXj3VrFlTX3zxhak94W4yt2/fNhsfFRVl6kvJmKQMHTpUERERpkdoaKhFXgsAAEB6cHV1TXK+k9D3JOPGjdO3336r5cuXq1ixYsmOY44EAAAs4Zm4fO/ixYt65ZVX5Ofnp0WLFsnJ6f/K9vHxkbOzs86dO2e2zblz50yTqZSMSYqLi4tcXFws+EoAAADST7FixbRx40aztoT5z+PmPJI0YcIEjR07VitWrNArr7zy2LHMkQAAgCVk+DOlEgKpsmXL6pdfflHmzJnN+l1cXBQYGKhFixaZ2q5du6a///5bjRs3TvEYAACAZ13jxo114cIFbd++3dS2cOFCFSxYUBUqVJAk3b17Vz/++KPOnz9vGjNx4kR99NFH+v3331W3bl2r1w0AAOxThj5TKjY2VoGBgYqMjFTz5s3NQqVq1aqpePHikqRPP/1UNWrUUIcOHVStWjXNnj1bfn5+pjvPpHQMAADAs6xKlSrq0qWL2rRpo4EDB+rSpUuaOnWqFi5cKEfHh99FhoeHq3Pnzlq8eLEKFSqkuXPnasiQIerevbsuX76sH3/8UZLk7u6uFi1a2PLlAACA51yGDqXu37+vSpUqSZL+/vtvs76CBQuaQqny5ctr3759mjVrlvbv369u3bqpd+/eZmdVpWQMAADAs27OnDlasGCBNm3aJDc3N23ZskVVqlQx9bu7u6tjx46mm8Y4OjqqY8eOio2N1apVq0zjcuTIQSgFAADSlYNhGIati3hWREZGysvLSxEREfL09LR1ORla0Md/2LoEAAC0emT6XabPvOD/8F6kTsCKQbYuAQAAbQ7+4smD0iA184IMv6YUAAAAAAAAnj+EUgAAAAAAALA6QikAAAAAAABYHaEUAAAAAAAArI5QCgAAAAAAAFZHKAUAAAAAAACrI5QCAAAAAACA1RFKAQAAAAAAwOoIpQAAAAAAAGB1hFIAAAAAAACwOkIpAAAAAAAAWB2hFAAAAAAAAKyOUAoAAAAAAABWRygFAAAAAAAAqyOUAgAAAAAAgNURSgEAAAAAAMDqCKUAAAAAAABgdYRSAAAAAAAAsDpCKQAAAAAAAFgdoRQAAAAAAACsjlAKAAAAAAAAVkcoBQAAAAAAAKsjlAIAAAAAAIDVEUoBAAAAAADA6gilAAAAAAAAYHWEUgAAAAAAALA6QikAAAAAAABYHaEUAAAAAAAArI5QCgAAAAAAAFZHKAUAAAAAAACrI5QCAAAAAACA1RFKAQAAAAAAwOoIpQAAAAAAAGB1hFIAAAAAAACwOkIpAAAAAAAAWB2hFAAAAAAAAKyOUAoAAAAAAABWRygFAAAAAAAAqyOUAgAAAAAAgNURSgEAAAAAAMDqCKUAAAAAAABgdYRSAAAAAAAAsDonWxeAjCPo4z9sXQIAAECGE7BikK1LAADgucSZUgAAAAAAALA6QikAAAAAAABYHaEUAAAAAAAArM7uQqnQ0FCFhIQoMjLS1qUAAACki9jYWO3Zs0f//vtvum4DAADwNOwmlIqJiVGrVq1UunRpde7cWXnz5tXUqVNtXRYAAIBF/fnnnypQoIDatGmjatWqqVKlSrp8+bLFtwEAAHhadhNKjRkzRjt37tSpU6d09OhRLViwQAMGDNCOHTtsXRoAAIBFXL9+Xe3atdPbb7+tU6dO6dKlS3J2dlaPHj0sug0AAIAl2E0oNWfOHPXs2VP58uWTJDVv3lx+fn6aM2eOjSsDAACwjMWLFysuLk7vvvuuJClLlix67733tGrVqmTPfErLNgAAAJbgZOsCrOHSpUsKCwvTSy+9ZNZeuXJl7d27N9ntYmNjFRsba3oeEREhSem2HlWLT1eny34BALBX6bmGZMK+DcNIt2Ok1t69e1WmTBm5ubmZ2ipXrizDMLRv3z7Tl3NPu42150iSFLRqaLrtGwAAe5Ref7dTM0eyi1AqPDxckpQzZ06z9pw5c5r6kjJ+/HiNGTMmUbuPj49lCwQAAOnCa1z6HyMqKkpeXl7pf6AUCA8PT3K+k9BnqW2YIwEA8Ozz0tfpuv+UzJHsIpRydnaW9HCx8/+Kjo5W5syZk91u6NChGjRokOl5fHy8aeLm4OCgyMhI+fj4KDQ0VJ6enulTPFKNzyVj4nPJmPhcMh4+k4wpqc/FMAxFRUUpf/78Nq7u/zg7Oyc535GU7JwnLds8aY4k8bucEfGZZEx8LhkTn0vGxOeSMT36uaRmjmQXoZSPj48cHR118eJFs/aLFy+qUKFCyW7n4uIiFxcXs7Zs2bIlGufp6cl/EBkQn0vGxOeSMfG5ZDx8JhnTo59LRjlDKkHhwoW1a9cus7aE+U9yc560bJPSOZLE73JGxGeSMfG5ZEx8LhkTn0vG9N/PJaVzJLtY6NzNzU3Vq1fXb7/9Zmq7c+eO/vrrL9WvX9+GlQEAAFhO/fr1derUKR05csTUtnz5cuXIkUMvvviiJOnevXvasmWLbty4keJtAAAA0oNdnCklSWPHjlX9+vU1dOhQVatWTVOnTlXu3LnVu3dvW5cGAABgEYGBgWrQoIHatGmjMWPG6NKlS/rkk080efJk03IGV69eVUBAgBYvXqzWrVunaBsAAID0YDehVO3atbV+/Xp99dVX2rlzp/z9/TVv3jxlzZo1zft0cXHRqFGjEp2+Dtvic8mY+FwyJj6XjIfPJGN6lj6XpUuX6osvvtC3334rNzc3zZs3T23atDH1u7i4qEaNGvL29k7xNmnxLL1n9oLPJGPic8mY+FwyJj6XjOlpPhcHIyPdxxgAAAAAAAB2wS7WlAIAAAAAAEDGQigFAAAAAAAAqyOUAgAAAAAAgNURSqWTU6dOacuWLYqMjLR1KZAUHh6uvXv3Kjw83Nal2KXIyEiFhITo/Pnzti4F/59hGKZbwMfGxtq6HDzi5s2b2rJli86dO2frUvD/3b17V3v37lVYWJitS3nm3b9/X1u2bNGhQ4dsXQokxcXF6ejRozpx4oQePHhg63Ls0vHjx7Vnzx7+HmcgUVFR2rt3r65cuWLrUpCE/fv3a8uWLWJ57Izj7NmzOnDgQJr+jhBKpYMLFy6oWrVqCggI0IEDB2xdjl3bv3+/goKCVLJkSXXv3l0+Pj7q0KGD7t69a+vS7MbXX3+tvHnzqnPnzipTpoyaN2+u6OhoW5dl12bNmqVixYqpQYMGatWqlfLmzavvvvvO1mXh/4uPj1fbtm1Vu3ZtTZ8+3dblQNKECROUJ08edenSRdWrV1fv3r0VFxdn67KeWcOHD1ft2rU1cOBAW5di9z755BMVKFBArVq1UoMGDVSkSBGtWLHC1mXZjStXrqhKlSqqUqWK2rRpo/z58+uPP/6wdVl27dy5c2rfvr0KFSqk7t27q3Tp0qpXrx7hVAayYcMGvfzyywoICCDIzQBOnDihqlWrqlKlSurRo4fKlSunbdu2pWofhFIWFhcXp9dee03du3e3dSnQw/9I3nvvPd24cUN79+7Vv//+q82bN2vEiBG2Ls0uhISEqF+/fpo/f76OHj2qU6dOaffu3Ro1apStS7NrV65c0caNG3Xq1CkdPXpUU6dO1RtvvKGQkBBblwY9DEDc3d1VsmRJW5cCSV9++aXGjh2r1atX6+DBgzp16pSqVq2qe/fu2bq0Z9Lq1av122+/qWnTprYuxe7FxcUpOjpaR44c0ZEjR3TmzBn17NlT7dq14x/gVtKrVy85ODjo0qVLOnXqlN555x21b99eV69etXVpduvMmTNq2bKl6d8O586d061bt9S7d29blwZJ169fV7du3dS/f39blwI9vBqmXr16Klq0qC5evKhdu3Zp/fr1qf5/GKGUhY0ZM0Y5c+ZUz549bV0KJLVu3Vr169c3PS9YsKCaNGmiLVu22LAq+zFnzhyVK1dOLVq0kCTlzZtXPXv21Jw5czjd1oaGDx+uQoUKmZ536tRJ7u7uqf5WA5a3fft2zZgxQzNnzrR1KZB07949ffzxx3r77bdVvXp1U3v37t3l6upqw8qeTVeuXFGPHj30448/yt3d3dbl2L1MmTJp7NixypEjh6mtT58+unv3rvbs2WPDyuxDWFiY/vjjDw0ePNj0/5N3331XhmFo0aJFNq7Ofr3yyitq27atHB0f/jM5W7Zs6tChA/92yCC6deumXr166eWXX7Z1KZA0c+ZMXb9+XTNmzJCLi4skKX/+/GrevHmq9kMoZUEbN27UnDlzuAwmAzMMQ7t371aJEiVsXYpd2Lt3r1566SWztsqVK+v69eu6cOGCjarCo44eParbt2/z34WN3bp1S6+99pq+++47eXt727oc6OEl4Ddu3FCTJk109epV7dmzRzdv3rR1Wc8kwzDUuXNnvfXWW6pUqZKty0Eydu3aJUkqXry4jSt5/u3fv1+GYZjNk1xdXVWuXDnt3bvXhpXhUbt27WKOlAFMnjxZERER+uCDD2xdCv6/devWKSAgQFmzZtX+/ft18uTJNC1v4JQOtT03tm/f/tg3NWvWrHrhhRckSTdu3FCnTp00a9YseXt769atW9Yp0s7ExsaaJkzJyZ07t0qVKpVk3+eff679+/fr22+/TY/y8Ijw8HDlzJnTrC3heXh4uHx8fGxRFv4jJiZGr7/+uipXrqygoCBbl2PXevbsqWbNmvE5ZCCXLl2SJC1cuFALFy5U3rx59e+//6pLly6aPn266Zt0e3Tx4kWdOXPmsWPKli1rOgtnwoQJio2N5R8T6ezEiRNPXIy/UqVKypIlS6L269evq3///mrbtq1Kly6dXiXi/0u4+U5S8yRuzJNxLF26VIsWLdLy5cttXYpd2717t8aPH69du3YpU6ZMti4H/9+lS5eUJ08eVaxYUdLD/69lzpxZ8+bNU40aNVK8H0Kpxxg1atRjF8QuWbKk5syZI0l65513VKZMGbm5uWnLli26ePGiJOngwYPKmTOnypQpY5Wan3c3b9584oQ2KChII0eOTNQ+b948DRs2TD/88IMpTET6cnZ2VkxMjFlbwiLnmTNntkVJ+I/79++rbdu2unbtmjZt2sQfeRtatGiRNmzYoIULF5ouEYiOjtaFCxe0devWVP1hh+U4OztLeng24dmzZ5UlSxYdOnRIVapUUfny5dW3b18bV2g7mzdv1rRp0x47Zvz48QoICNDx48c1ZswYzZo1y3SZ8LVr1xQREaEtW7aoYsWKXM5nIYsXL9bKlSsfO+bnn39WgQIFzNoiIiLUsGFD5c2bl8uHrSTh/y8xMTHy8PAwtUdHR5s9h+2sX79eHTt21Lhx49SkSRNbl2PXOnfurPbt2ys0NFShoaH6999/JUnbtm1TyZIl+aLbRpydnbV27VqtWbNGgYGBiouLU69evdSmTRudP39eTk4pi5scDBZ2sYj+/fubnWobExOj3bt3y9/fX8HBwRo3bpwNq8P8+fP1+uuva86cOerYsaOty7EbwcHBcnJy0rJly0xtCxYsUKdOnRQZGamsWbParjg7d//+fbVr10779u3Thg0bzNaYgvUtXLgw0T/w9+zZo5w5c6p48eLasGGDbQqzc0eOHFG5cuW0YMECdejQwdQeFBSk7Nmza+HChTas7tmxd+/eRIvSHj9+XPfu3ZOfn5/mzp3LpTE2FBkZaVp/c82aNfLy8rJxRfYhJCREL7/8svbu3Wv2ZWmpUqXUrFkzffbZZ7YrDtq4caMaN26sDz74gBskZQANGjQwO1nk+vXr+vfff1W9enW98cYb6tKliw2rs19t27bV/v37TSGh9PBqs+rVq+vo0aPy9fVN0X44U8pCpk6davb85MmTKlmypL7++mvVrFnTRlVBkn766Sd1795ds2fPJpCysvr162vkyJG6c+eO6Vvw5cuXq2rVqgRSNvTgwQO1b9+eQCoDad++vdq3b2/W5uvrq+bNm2vChAk2qgplypRRoUKFTGc/J7h48WKyl4kjsYoVKyZaJLhTp066cuWK/vrrLxtVBelhINWgQQNJBFLW9sILL8jb21u//fabKZQ6evSoTpw4YXaTHljf5s2b1bhxYw0ZMoRAKoNYs2aN2fOFCxeqQ4cOWrduXZKXI8M6goKCtG7dOsXGxpoWOk9YNzg166MSSuG59ttvv6lz587q3bu3ihQpYpoUu7i4cNcGK+jZs6e++uorNWvWTP3799eOHTu0ZMmSRH9YYF1dunTRn3/+qZkzZ+r8+fM6f/68JMnHx0eFCxe2cXVAxuHg4KCJEyfqzTfflJubm4oXL65Fixbp7Nmzdn3pHp4P9+/f16uvvqozZ85o9uzZOnjwoKmvZMmSypMnjw2re/45OTnpk08+0YABA+Tl5aUCBQpo9OjRqlu3rikohPXt3r1bjRo1Ut26dVWnTh2zQL1GjRpycHCwYXVAxtK5c2dNmzZNbdu21RtvvKFr165p+PDh6tGjB6FURuDq6qoaNWrwjZONnTp1SlWrVtWBAwd04MABU3vu3Lm1ZMkSG1ZmH9zd3bVlyxZNmDBB//vf/5Q7d279/fffCggIsHVpdu3mzZt68cUX9fXXX5u1d+rUSW+++aaNqsKjXnrpJRUpUsTWZdi9du3aKXv27Jo1a5aWLVum0qVLa//+/dyd7CmVLl1auXLlsnUZdu3u3btycHBQyZIlNX78eLO+Dz74QMHBwTaqzH707t1b3t7emjdvnm7fvq22bdvq3XfftXVZdu306dOqUKGCwsPDE61j+/fff7MmagaRK1cu1ahRw65vOJIRZM6cWevXr9ekSZM0efJkZc+eXR999JG6deuWqv2wphQAAAAAAACsjmgRAAAAAAAAVkcoBQAAAAAAAKsjlAIAAAAAAIDVEUoBAAAAAADA6gilAAAAAAAAYHWEUgAAAAAAALA6QikAAAAAAABYHaEUAKRCdHS0Fi5cqKioKFuXAgAAkKHs2rVL27dvt3UZAJ4hhFIAnnuRkZFauHChwsLCkuw/c+aMfv75Z92/f/+J+7px44Y6dOigixcvWrpMAAAAq9u2bZvWrVuXbP/vv/+uffv2pWhf33zzjb788ksLVQbAHhBKAXjuubu769133012kvThhx9q0qRJcnZ2tnJlAAAAtnXgwAE1adJEERERifpOnjypZs2a8WUcgHRDKAXguZcpUyZ169ZN33//veLi4sz6IiIi9Ouvv6pHjx4yDEMLFy7UwoUL9csvv2jXrl168ODBY/d9/fp1LVy4UPHx8aa2e/fuaeHChbp161aiY61atUpr1qzR1atXLfb6AAAA0qpDhw5ycHDQggULEvXNnj1b+fPnV8OGDXXw4EHTPGnVqlW6dOnSE/e9YcMGHThwwKxtz5492rJlS6Kx+/fv17Jly7Rnzx6zeRWA5xuhFAC70KNHD12+fFmrVq0ya1+wYIEcHBz02muvyTAMLVu2TMuWLdNPP/2k9u3b66WXXtLly5eT3e+xY8fUoUMH3bt3z9QWGRmpDh066OzZs6a2n376SUWKFNGnn36qL774QqVKldJ3331n8dcJAACQGl5eXmrdurVmz55t1h4XF6fvv/9e3bp1U6ZMmXT06FHTPOnzzz9XyZIlNWXKlMfue+zYsYnCrtmzZ2vSpEmm5xEREapXr56aNm2q2bNnq127dqpRo4auX79usdcIIONysnUBAGANxYoVU506dTR79mw1btzY1D5r1iy1adNGnp6ekqSFCxea+uLi4tS8eXN99NFHmj59epqP/e+//6pXr15au3atqlWrJunh+g2BgYEKDAxUsWLF0rxvAACAp9WzZ0/VqlVLBw8elL+/vyTpzz//1OXLl9W9e3dJUtu2bdW2bVvTNjt27FCtWrXUunVrFSxYMM3HHjBggDw8PHTy5Ek5OzsrLi5OzZo10wcffKCZM2c+3QsDkOERSgGwGz169FC3bt107do15cqVSwcOHNDu3bs1efJks3GHDh3SmTNndOfOHeXJk0c7d+58quPOnz9fefPm1cWLF7V48WIZhiFJ8vDw0NatWwmlAACATQUEBKhUqVKaNWuW6eynWbNmqU6dOmbzlFu3bmn//v0KCwtTfHy8XF1dtXfv3jSHUjExMVq4cKHeffddLV++XIZhyDAMFSpUSKtXr7bESwOQwRFKAbAbLVu2VL9+/TRv3jwNGjRIs2bNUqlSpRQQECBJunPnjho1aqQjR46oUqVK8vT01NmzZ596/aezZ88qJiZGv/zyi1l73bp1lT179qfaNwAAgCX06NFDn332mSZOnKhbt27pjz/+0Pfff2/q/+mnn/Tmm2+qVKlSKliwoFxcXHT//v2nmiddunRJ9+7d0549e3T69GmzvoT5GYDnG6EUALuRJUsWdezYUbNnz1bfvn31448/asiQIab+WbNm6eLFizp//rxcXV0lSZMmTXrsegmOjg+X5vvvgpwxMTFmYzw9PZU7d26zSwMBAAAykq5du2r48OH67bffdPbsWWXNmlUtWrQw9ffr10+TJk1Sr169TG0eHh6mM8CT4ujomGjR8v/OkxKWT3jrrbfUtGlTS70UAM8QFjoHYFd69uypw4cPa+jQoYqMjFTXrl1NfVeuXFGhQoVMgZRhGFqyZMlj91egQAFJD2+ZnGD9+vVmYxo2bKh9+/bpn3/+MWuPiIjQnTt3nur1AAAAWEKePHkUHBysWbNmafbs2erUqZOyZMkiSYqNjdXNmzdVunRp0/hVq1bp9u3bj91ngQIFzOZIDx48MLvznre3t1566SXNmDEj0bYXL1582pcE4BnAmVIA7EqFChVUqVIlTZ48WS1atFCePHlMfU2aNNHEiRP13nvvqXTp0vrll1909OhRubu7J7u/woULq1atWurataveeusthYaGav78+WZjgoOD1aVLFwUFBal///4qWrSojh49quXLl2vDhg2P3T8AAIC19OzZU8HBwZLMb/7i4uKihg0bqm/fvhowYIAuX76sadOmmb7IS07nzp0VFBSkDz74QMWLF9fChQt148YNszHffPON6tevr/r166tly5a6e/eu1q5dK39/f3322WeWf5EAMhTOlAJgd0aMGKF27dpp0KBBZu3VqlXThg0bFBMTo+3bt6tly5ZatGiRmjVrZhrj5uamdu3amU43l6QVK1aobdu2+ueff+Tu7q7169erXbt2ZutFzZ07VwsWLFBERIS2bdumAgUKaMeOHaYzrQAAAGytYcOG6tq1q95++22VL1/erG/RokXq3LmztmzZosjISP3111/q0aOHihcvbhpTuXJlVa9e3fS8bt26WrNmjW7fvq0jR45oyJAhmjhxotl6US+99JKOHDmiwMBA7dixQ2FhYXrvvfcIpAA74WA87iJgAAAAAAAAIB1wphQAAAAAAACsjlAKAAAAAAAAVkcoBQAAAAAAAKsjlAIAAAAAAIDVEUoBAAAAAADA6gilAAAAAAAAYHWEUgAAAAAAALA6QikAAAAAAABYHaEUAAAAAAAArI5QCgAAAAAAAFZHKAUAAAAAAACrI5QCAAAAAACA1f0/FQPpVsIgTS8AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -322,7 +427,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -382,13 +487,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 19, "id": "51179a02", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -416,13 +521,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 20, "id": "e9bbabc9", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -453,7 +558,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "1190f8aa", "metadata": {}, "outputs": [ @@ -489,13 +594,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "bf2ba150", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -539,6 +644,12 @@ "3. **`khisto.matplotlib.hist`** - Matplotlib-compatible, plots directly\n", "4. **`khisto.core.compute_histogram`** - Full access to `HistogramResult` with all details" ] + }, + { + "cell_type": "markdown", + "id": "fd106168", + "metadata": {}, + "source": [] } ], "metadata": { diff --git a/src/khisto/__init__.py b/src/khisto/__init__.py index 3031513..ed8f3ad 100644 --- a/src/khisto/__init__.py +++ b/src/khisto/__init__.py @@ -2,9 +2,10 @@ # 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 logging import os +from importlib.metadata import version from pathlib import Path -import logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) @@ -13,7 +14,7 @@ KHISTO_BIN_DIR = os.environ.get("KHISTO_BIN_DIR", "khisto") -__version__ = "0.2.0" +__version__ = version("khisto") from .array import histogram # noqa: E402 from .core import HistogramResult # noqa: E402 diff --git a/src/khisto/array/histogram/api.py b/src/khisto/array/histogram/api.py index 7ca1c97..7332ecc 100644 --- a/src/khisto/array/histogram/api.py +++ b/src/khisto/array/histogram/api.py @@ -34,20 +34,19 @@ def _select_histogram( """ if max_bins is not None: # Find the finest granularity that respects max_bins - selected = None - for r in histogram_results: + for r in reversed(histogram_results): if len(r) <= max_bins: - selected = r - else: - break + return r # If no histogram respects the constraint, use the coarsest one - return selected if selected is not None else histogram_results[0] + return histogram_results[0] else: - # Return the best (optimal) histogram + # Return the best histogram (optimal in terms of interpretability) + # There is only one best histogram, so we return the first one we find for r in reversed(histogram_results): if r.is_best: return r # Fallback to finest granularity if no best is marked + # It is assumed to be the best because it is the finest granularity return histogram_results[-1] @@ -62,7 +61,7 @@ def histogram( Parameters ---------- a : array_like - Input data. The histogram is computed over the flattened array. + Input data. Must be 1-dimensional. range : tuple of (float, float), optional The lower and upper range of the bins. Values outside the range are ignored. If not provided, the range is ``(a.min(), a.max())``. @@ -105,7 +104,13 @@ def histogram( histograms for large-scale data sets. Computational Statistics & Data Analysis, 180:0-0, 2023. """ - arr = np.asarray(a, dtype=np.float64).flatten() + arr = np.asarray(a, dtype=np.float64) + + if arr.ndim != 1: + raise ValueError( + f"Expected 1-D array, got {arr.ndim}-D array instead. " + "Reshape your data or flatten it before calling histogram." + ) if max_bins is not None and max_bins <= 0: raise ValueError("max_bins must be a positive integer or None.") diff --git a/src/khisto/core/backend.py b/src/khisto/core/backend.py index 54ec160..d71de4e 100644 --- a/src/khisto/core/backend.py +++ b/src/khisto/core/backend.py @@ -7,23 +7,32 @@ from __future__ import annotations import json +import os +import re import subprocess import tempfile from dataclasses import dataclass, field -from typing import Any, Optional +from pathlib import Path +from typing import TYPE_CHECKING, Any import numpy as np -from numpy.typing import NDArray from khisto import KHISTO_BIN_DIR, logger +if TYPE_CHECKING: + from numpy.typing import NDArray + + +def camel_to_snake(name: str) -> str: + return re.sub(r"(? _HistogramPayload: - return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__}) + return cls( + **{ + ck: v + for k, v in data.items() + if (ck := camel_to_snake(k)) in cls.__dataclass_fields__ + } + ) @dataclass class _SeriesPayload: """Histogram series from khisto JSON.""" - histogramNumber: int = 0 - interpretableHistogramNumber: int = 0 - truncationEpsilon: float = 0.0 - removedSingularIntervalNumber: int = 0 + histogram_number: int = 0 + interpretable_histogram_number: int = 0 + truncation_epsilon: float = 0.0 + removed_singular_interval_number: int = 0 granularities: list[int] = field(default_factory=list) - intervalNumbers: list[int] = field(default_factory=list) - peakIntervalNumbers: list[int] = field(default_factory=list) - spikeIntervalNumbers: list[int] = field(default_factory=list) - emptyIntervalNumbers: list[int] = field(default_factory=list) + interval_numbers: list[int] = field(default_factory=list) + peak_interval_numbers: list[int] = field(default_factory=list) + spike_interval_numbers: list[int] = field(default_factory=list) + empty_interval_numbers: list[int] = field(default_factory=list) levels: list[float] = field(default_factory=list) - informationRates: list[float] = field(default_factory=list) + information_rates: list[float] = field(default_factory=list) histograms: list[_HistogramPayload] = field(default_factory=list) @classmethod def from_dict(cls, data: dict[str, Any]) -> _SeriesPayload: - kwargs = {k: v for k, v in data.items() if k in cls.__dataclass_fields__} + kwargs = { + ck: v + for k, v in data.items() + if (ck := camel_to_snake(k)) in cls.__dataclass_fields__ + } if "histograms" in kwargs: kwargs["histograms"] = [ _HistogramPayload.from_dict(h) for h in kwargs["histograms"] @@ -67,18 +86,18 @@ class _KhistoOutput: tool: str = "" version: str = "" - bestHistogram: Optional[_HistogramPayload] = None - histogramSeries: Optional[_SeriesPayload] = None + best_histogram: _HistogramPayload = field(default_factory=_HistogramPayload) + histogram_series: _SeriesPayload = field(default_factory=_SeriesPayload) @classmethod def from_dict(cls, data: dict[str, Any]) -> _KhistoOutput: - best = data.get("bestHistogram") - series = data.get("histogramSeries") + if "bestHistogram" not in data or "histogramSeries" not in data: + raise ValueError("Missing required fields: bestHistogram, histogramSeries") return cls( tool=data.get("tool", ""), version=data.get("version", ""), - bestHistogram=_HistogramPayload.from_dict(best) if best else None, - histogramSeries=_SeriesPayload.from_dict(series) if series else None, + best_histogram=_HistogramPayload.from_dict(data["bestHistogram"]), + histogram_series=_SeriesPayload.from_dict(data["histogramSeries"]), ) @@ -127,9 +146,41 @@ class HistogramResult: spike_interval_number: int = 0 empty_interval_number: int = 0 + def __post_init__(self) -> None: + """Validate the histogram data.""" + + # Verify all arrays have the same length + n_bins = { + len(self.lower_bounds), + len(self.upper_bounds), + len(self.frequencies), + len(self.probabilities), + len(self.densities), + } + if len(n_bins) != 1: + raise ValueError("all array sizes must be equal") + elif len(self.lower_bounds) < 1: + raise ValueError("all arrays must have at least one element") + + if not np.all(self.lower_bounds <= self.upper_bounds): + raise ValueError("lower_bounds must be less than upper_bounds") + if not np.all(self.frequencies >= 0): + raise ValueError("frequencies must be non-negative") + if not np.all(self.probabilities >= 0): + raise ValueError("probabilities must be non-negative") + if not np.all(self.densities >= 0): + raise ValueError("densities must be non-negative") + + # Verify lower_bounds are equal to upper_bounds for adjacent bins + if not np.all(self.lower_bounds[1:] == self.upper_bounds[:-1]): + raise ValueError( + "lower_bounds must be equal to upper_bounds for adjacent bins" + ) + @property def bin_edges(self) -> NDArray[np.float64]: - """Return bin edges array (n_bins + 1 values).""" + """Return bin edges array (n_bins + 1 values). + lower_bounds and upper_bounds are equal for adjacent bins.""" return np.concatenate([self.lower_bounds, [self.upper_bounds[-1]]]) @property @@ -147,18 +198,6 @@ def __len__(self) -> int: return len(self.lower_bounds) -def _to_result(h: _HistogramPayload, **kwargs: Any) -> HistogramResult: - """Convert a JSON histogram payload to a HistogramResult.""" - return HistogramResult( - lower_bounds=np.asarray(h.lowerBounds, dtype=np.float64), - upper_bounds=np.asarray(h.upperBounds, dtype=np.float64), - frequencies=np.asarray(h.frequencies, dtype=np.int64), - probabilities=np.asarray(h.probabilities, dtype=np.float64), - densities=np.asarray(h.densities, dtype=np.float64), - **kwargs, - ) - - def _format_runtime_error( summary: str, cmd: list[str], details: str | None = None ) -> str: @@ -169,28 +208,28 @@ def _format_runtime_error( return message -def _process_histogram_file( - file_path: str, -) -> list[HistogramResult]: +def _process_histogram_file(file_path: Path) -> list[HistogramResult]: """Process exploratory JSON generated by khisto CLI.""" - with open(file_path, "r") as temp_output_file: - khisto_output: _KhistoOutput = _KhistoOutput.from_dict( - json.load(temp_output_file) - ) + with open(file_path, "r", encoding="utf-8") as file: + khisto_output: _KhistoOutput = _KhistoOutput.from_dict(json.load(file)) - histogram_series = khisto_output.histogramSeries - best_idx = histogram_series.interpretableHistogramNumber - 1 + histogram_series = khisto_output.histogram_series + best_idx = histogram_series.interpretable_histogram_number - 1 return [ - _to_result( - h, + HistogramResult( + lower_bounds=np.asarray(h.lower_bounds, dtype=np.float64), + upper_bounds=np.asarray(h.upper_bounds, dtype=np.float64), + frequencies=np.asarray(h.frequencies, dtype=np.int64), + probabilities=np.asarray(h.probabilities, dtype=np.float64), + densities=np.asarray(h.densities, dtype=np.float64), is_best=(i == best_idx), granularity=histogram_series.granularities[i], level=histogram_series.levels[i], - information_rate=histogram_series.informationRates[i], - peak_interval_number=histogram_series.peakIntervalNumbers[i], - spike_interval_number=histogram_series.spikeIntervalNumbers[i], - empty_interval_number=histogram_series.emptyIntervalNumbers[i], + information_rate=histogram_series.information_rates[i], + peak_interval_number=histogram_series.peak_interval_numbers[i], + spike_interval_number=histogram_series.spike_interval_numbers[i], + empty_interval_number=histogram_series.empty_interval_numbers[i], ) for i, h in enumerate(histogram_series.histograms) ] @@ -223,54 +262,65 @@ def compute_histograms(x: np.ndarray) -> list[HistogramResult]: if len(x) == 0: raise ValueError("Input array is empty after filtering") - with tempfile.NamedTemporaryFile(mode="wb", suffix=".bin") as temp_input_file: - x.tofile(temp_input_file) - with tempfile.NamedTemporaryFile(mode="r", suffix=".json") as temp_output_file: - cmd = [ - str(KHISTO_BIN_DIR), - "-b", - "-e", - "-j", - temp_input_file.name, - temp_output_file.name, - ] - try: - subprocess.run(cmd, capture_output=True, text=True, check=True) - except subprocess.CalledProcessError as e: - stdout = e.stdout.strip() - stderr = e.stderr.strip() - details = "\n".join(part for part in (stdout, stderr) if part) - message = _format_runtime_error( - f"khisto failed with exit code {e.returncode}", - cmd, - details or None, - ) - logger.error(message) - raise RuntimeError(message) from e - except OSError as e: - message = _format_runtime_error( - "khisto could not be started", - cmd, - str(e), - ) - logger.error(message) - raise RuntimeError(message) from e - - try: - return _process_histogram_file(temp_output_file.name) - except json.JSONDecodeError as e: - message = _format_runtime_error( - "khisto produced invalid JSON output", - cmd, - str(e), - ) - logger.error(message) - raise RuntimeError(message) from e - except (AttributeError, IndexError, TypeError, ValueError) as e: - message = _format_runtime_error( - "khisto produced an invalid histogram payload", - cmd, - str(e), - ) - logger.error(message) - raise RuntimeError(message) from e + # Use delete=False so the files are closed before the subprocess reads them. + # On Windows, files keep an exclusive lock while open, whence, + # for portability reasons, the NamedTemporaryFile context manager cannot be used. + temp_input_fd, temp_input_file_path = tempfile.mkstemp(suffix=".bin") + temp_output_fd, temp_output_file_path = tempfile.mkstemp(suffix=".json") + os.close(temp_input_fd) + os.close(temp_output_fd) + try: + with open(temp_input_file_path, "wb") as temp_input_file: + x.tofile(temp_input_file) + + cmd = [ + str(KHISTO_BIN_DIR), + "-b", + "-e", + "-j", + temp_input_file_path, + temp_output_file_path, + ] + try: + subprocess.run(cmd, capture_output=True, text=True, check=True) + except subprocess.CalledProcessError as e: + stdout = e.stdout.strip() + stderr = e.stderr.strip() + details = "\n".join(part for part in (stdout, stderr) if part) + message = _format_runtime_error( + f"khisto failed with exit code {e.returncode}", + cmd, + details or None, + ) + logger.error(message) + raise RuntimeError(message) from e + except OSError as e: + message = _format_runtime_error( + "khisto could not be started", + cmd, + str(e), + ) + logger.error(message) + raise RuntimeError(message) from e + + try: + return _process_histogram_file(Path(temp_output_file_path)) + except json.JSONDecodeError as e: + message = _format_runtime_error( + "khisto produced invalid JSON output", + cmd, + str(e), + ) + logger.error(message) + raise RuntimeError(message) from e + except (AttributeError, IndexError, TypeError, ValueError) as e: + message = _format_runtime_error( + "khisto produced an invalid histogram payload", + cmd, + str(e), + ) + logger.error(message) + raise RuntimeError(message) from e + finally: + os.unlink(temp_input_file_path) + os.unlink(temp_output_file_path) diff --git a/src/khisto/matplotlib/hist.py b/src/khisto/matplotlib/hist.py index 9f8fcff..89bfc0a 100644 --- a/src/khisto/matplotlib/hist.py +++ b/src/khisto/matplotlib/hist.py @@ -8,9 +8,8 @@ from typing import TYPE_CHECKING, Any, Literal, Optional -import numpy as np - import matplotlib.pyplot as plt +import numpy as np from matplotlib.axes import Axes from khisto.array import histogram as khisto_histogram @@ -36,7 +35,7 @@ def _apply_cumulative( hist_values: NDArray[np.float64], bin_edges: NDArray[np.float64], *, - density: bool, + density: bool = False, reverse: bool = False, ) -> NDArray[np.float64]: """Accumulate histogram values using matplotlib-compatible semantics.""" @@ -72,9 +71,8 @@ def hist( Parameters ---------- - x : array_like or sequence of array_like - Input data. Nested arrays are concatenated and histogrammed as a - single dataset. + x : array_like + Input data. Must be 1-dimensional. range : tuple of (float, float), optional Lower and upper range of the bins. Values outside the range are ignored. diff --git a/tests/array/test_histogram.py b/tests/array/test_histogram.py index d84f506..941877b 100644 --- a/tests/array/test_histogram.py +++ b/tests/array/test_histogram.py @@ -172,10 +172,8 @@ def test_bin_edges_length(self, normal_data): hist, bin_edges = histogram(normal_data) assert len(bin_edges) == len(hist) + 1 - def test_2d_array_flattening(self): - """Test that 2D arrays are flattened.""" + def test_2d_array_raises(self): + """Test that 2D arrays raise ValueError.""" data_2d = np.array([[1, 2, 3], [4, 5, 6]]) - hist, bin_edges = histogram(data_2d) - - # Should process all 6 values - assert np.sum(hist) == 6 + with pytest.raises(ValueError, match="Expected 1-D array"): + histogram(data_2d) diff --git a/tests/plot/test_matplotlib_histogram.py b/tests/plot/test_matplotlib_histogram.py index 241958d..5a24806 100644 --- a/tests/plot/test_matplotlib_histogram.py +++ b/tests/plot/test_matplotlib_histogram.py @@ -151,15 +151,6 @@ def test_reverse_cumulative_frequency_histogram(self, normal_data): assert np.isclose(n[0], len(normal_data)) plt.close(fig) - def test_sequence_of_arrays_is_combined(self, normal_data): - """Test that sequences of arrays are combined into one histogram.""" - fig, ax = plt.subplots() - datasets = [normal_data[:500], normal_data[500:]] - n, bins, patches = hist(datasets, ax=ax) - - assert np.sum(n) == len(normal_data) - plt.close(fig) - def test_unsupported_bins_parameter(self, normal_data): """Test that bins raises a clear error message.""" fig, ax = plt.subplots()