seraplot 2.4.0__tar.gz → 2.4.1__tar.gz

{seraplot-2.4.0 → seraplot-2.4.1}/Cargo.lock

@@ -3471,7 +3471,7 @@ checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
 
 [[package]]
 name = "seraplot"
-version = "2.4.0"
+version = "2.4.1"
 dependencies = [
  "base64 0.22.1",
  "criterion",

{seraplot-2.4.0 → seraplot-2.4.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "seraplot"
-version = "2.4.0"
+version = "2.4.1"
 edition = "2021"
 authors = ["feur25"]
 description = "Rust data visualization framework - The modern Plotly alternative"
@@ -44,6 +44,14 @@ ffi = ["dep:egui"]
 all = ["python"]
 pyo3 = ["dep:pyo3"]
 
+[[example]]
+name = "csv_test"
+path = "examples/csv_test.rs"
+
+[[example]]
+name = "csv_viewer"
+path = "examples/csv_viewer.rs"
+
 [profile.release]
 lto = "thin"
 codegen-units = 1

{seraplot-2.4.0 → seraplot-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seraplot
-Version: 2.4.0
+Version: 2.4.1
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Intended Audience :: Developers
@@ -30,42 +30,47 @@ License: MIT
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
-SeraPlot - Rust-Powered Data Visualization Framework
+SeraPlot — High-Performance Data Visualization & ML Framework
 
-SeraPlot is a framework developed in Rust, meticulously crafted with care. It is a modern 
-alternative to Plotly, designed specifically for data visualization. This library is distributed 
-across multiple programming languages (Python, C#, C++, JavaScript), regularly maintained and 
-updated, offering superior speed and significantly lower memory consumption compared to competitors.
+**SeraPlot v2.4.0+** is a production-grade framework written in **Rust**, delivering blazing-fast interactive charts and built-in machine learning pipelines. Designed as a modern alternative to Plotly + scikit-learn, it combines visualization and ML preprocessing in a single Rust binary — no dependencies, no bloat.
 
-documentation : https://feur25.github.io/seraplot/introduction.html
+📖 **Documentation:** https://feur25.github.io/seraplot/introduction.html
 
 ---
 
-### Why Choose SeraPlot
+## Why Choose SeraPlot?
 
-• More fast than plotly; generation across all dataset sizes  
-• Minimal memory footprint - ideal for resource-constrained environments  
-• Production-ready with enterprise-grade stability  
-• Multi-language support (Python, C#, C++, JavaScript, and more if necessary send me a message)  
-• Regularly updated with new plots - new features and improvements  
-• Perfect for real-time dashboards and batch processing  
+**100–8000× faster** than Plotly & Matplotlib on chart generation  
+**Minimal memory footprint** — runs on edge devices, embedded systems, low-power servers  
+**Production-ready** — enterprise-grade stability, zero fluff, maximum efficiency  
+**Multi-language** — Python, JavaScript/WebAssembly, C/C++, C#  
+**60+ chart types** — 2D, 3D, maps, statistical plots, all GPU-accelerated  
+**ML preprocessing & metrics** — StandardScaler with Welford `partial_fit` (online learning), Pipeline with `score`/`predict_proba`/`decision_function`, OneHotEncoder/OrdinalEncoder with incremental category union  
+**WebAssembly** — npm package `@seraplot/wasm` for browser visualization & ML inference  
+**Streaming data** — online scalers and encoders for incremental model training  
 
 ---
-### Install Command
-Seraplot may be installed using pip
+
+## Installation
+
+**Python** (PyPI — wheel for CPython 3.11+)
 
 ```bash
 pip install seraplot
 ```
 
-or you can also install in conda or uv
-
+Alternative package managers:
 ```bash
 conda install -c conda-forge seraplot
+uv pip install seraplot
 ```
+
+**JavaScript/WebAssembly** (npm)
+
 ```bash
-uv pip install seraplot
+npm install seraplot
 ```
+
 ---
 
 ### Gallery — Chart Types
@@ -91,20 +96,4 @@ uv pip install seraplot
 | ![Bench-1](https://raw.githubusercontent.com/feur25/seraplot-documentation/main/benchmark/1.png) | ![Bench-2](https://raw.githubusercontent.com/feur25/seraplot-documentation/main/benchmark/2.png) | ![Bench-3](https://raw.githubusercontent.com/feur25/seraplot-documentation/main/benchmark/3.png) |
 
 **SeraPlot outperforms Plotly and Matplotlib by 100–8000× on chart generation speed.**
-
----
-
-### Quick Start
-
-```python
-from seraplot import build_bar_chart
-
-# Create a simple bar chart
-build_bar_chart(
-    'Sales by Region',
-    ['North', 'South', 'East', 'West'],
-    [120, 95, 150, 110],
-    width=900, height=500
-)
-```
 

{seraplot-2.4.0 → seraplot-2.4.1}/README.md

@@ -1,39 +1,44 @@
-SeraPlot - Rust-Powered Data Visualization Framework
+SeraPlot — High-Performance Data Visualization & ML Framework
 
-SeraPlot is a framework developed in Rust, meticulously crafted with care. It is a modern 
-alternative to Plotly, designed specifically for data visualization. This library is distributed 
-across multiple programming languages (Python, C#, C++, JavaScript), regularly maintained and 
-updated, offering superior speed and significantly lower memory consumption compared to competitors.
+**SeraPlot v2.4.0+** is a production-grade framework written in **Rust**, delivering blazing-fast interactive charts and built-in machine learning pipelines. Designed as a modern alternative to Plotly + scikit-learn, it combines visualization and ML preprocessing in a single Rust binary — no dependencies, no bloat.
 
-documentation : https://feur25.github.io/seraplot/introduction.html
+📖 **Documentation:** https://feur25.github.io/seraplot/introduction.html
 
 ---
 
-### Why Choose SeraPlot
+## Why Choose SeraPlot?
 
-• More fast than plotly; generation across all dataset sizes  
-• Minimal memory footprint - ideal for resource-constrained environments  
-• Production-ready with enterprise-grade stability  
-• Multi-language support (Python, C#, C++, JavaScript, and more if necessary send me a message)  
-• Regularly updated with new plots - new features and improvements  
-• Perfect for real-time dashboards and batch processing  
+**100–8000× faster** than Plotly & Matplotlib on chart generation  
+**Minimal memory footprint** — runs on edge devices, embedded systems, low-power servers  
+**Production-ready** — enterprise-grade stability, zero fluff, maximum efficiency  
+**Multi-language** — Python, JavaScript/WebAssembly, C/C++, C#  
+**60+ chart types** — 2D, 3D, maps, statistical plots, all GPU-accelerated  
+**ML preprocessing & metrics** — StandardScaler with Welford `partial_fit` (online learning), Pipeline with `score`/`predict_proba`/`decision_function`, OneHotEncoder/OrdinalEncoder with incremental category union  
+**WebAssembly** — npm package `@seraplot/wasm` for browser visualization & ML inference  
+**Streaming data** — online scalers and encoders for incremental model training  
 
 ---
-### Install Command
-Seraplot may be installed using pip
+
+## Installation
+
+**Python** (PyPI — wheel for CPython 3.11+)
 
 ```bash
 pip install seraplot
 ```
 
-or you can also install in conda or uv
-
+Alternative package managers:
 ```bash
 conda install -c conda-forge seraplot
+uv pip install seraplot
 ```
+
+**JavaScript/WebAssembly** (npm)
+
 ```bash
-uv pip install seraplot
+npm install seraplot
 ```
+
 ---
 
 ### Gallery — Chart Types
@@ -59,19 +64,3 @@ uv pip install seraplot
 | ![Bench-1](https://raw.githubusercontent.com/feur25/seraplot-documentation/main/benchmark/1.png) | ![Bench-2](https://raw.githubusercontent.com/feur25/seraplot-documentation/main/benchmark/2.png) | ![Bench-3](https://raw.githubusercontent.com/feur25/seraplot-documentation/main/benchmark/3.png) |
 
 **SeraPlot outperforms Plotly and Matplotlib by 100–8000× on chart generation speed.**
-
----
-
-### Quick Start
-
-```python
-from seraplot import build_bar_chart
-
-# Create a simple bar chart
-build_bar_chart(
-    'Sales by Region',
-    ['North', 'South', 'East', 'West'],
-    [120, 95, 150, 110],
-    width=900, height=500
-)
-```

{seraplot-2.4.0 → seraplot-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "seraplot"
-version = "2.4.0"
+version = "2.4.1"
 description = "Rust data visualization framework - The modern Plotly alternative"
 readme = "README.md"
 readme-content-type = "text/markdown"

seraplot-2.4.1/src/docs/ml/adaboost.md

@@ -0,0 +1,203 @@
+# AdaBoost — Adaptive Boosting
+
+<div class="lang-en">
+
+## API Reference
+
+```python
+clf = sp.AdaBoostClassifier(n_estimators=50, learning_rate=1.0, max_depth=1)
+reg = sp.AdaBoostRegressor(n_estimators=50, learning_rate=1.0, max_depth=1)
+
+clf.fit(X, y)
+clf.predict(X)               -> list[int]
+clf.predict_proba(X)         -> ndarray (n, K)
+clf.score(X, y)              -> float
+clf.get_params()             -> dict
+clf.set_params(n_estimators=100, learning_rate=0.5, max_depth=3)
+
+reg.fit(X, y)
+reg.predict(X)               -> list[float]
+reg.score(X, y)              -> float
+```
+
+## Constructor Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `n_estimators` | `int` | `50` | Maximum number of weak learners |
+| `learning_rate` | `float` | `1.0` | Shrinkage parameter $\nu$ for learner contribution |
+| `max_depth` | `int` | `1` | Max tree depth; `1` = stumps, `>1` = full trees |
+
+## Attributes
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `classes_` | `list[int]` | Unique class labels (classifier only) |
+| `n_estimators_` | `int` | Number of estimators used |
+| `learning_rate_` | `float` | Shrinkage parameter |
+| `max_depth_` | `int` | Tree depth setting |
+
+## Example
+
+```python
+import seraplot as sp
+import numpy as np
+
+X = np.random.randn(500, 5)
+y = np.random.randint(0, 3, 500)
+
+clf = sp.AdaBoostClassifier(n_estimators=100, learning_rate=0.8, max_depth=3)
+clf.fit(X, y)
+
+proba = clf.predict_proba(X)
+score = clf.score(X, y)
+print(f"Accuracy: {score:.4f}, Class probs shape: {np.array(proba).shape}")
+```
+
+---
+
+## Algorithmic Functioning
+
+**AdaBoost.M1** (multi-class Adaptive Boosting) combines weak learners by iteratively re-weighting misclassified samples.
+
+**Initialization** — uniform sample weights:
+
+$$w_i^{(1)} = \frac{1}{n}, \quad i = 1, \ldots, n$$
+
+**Iteration** $m = 1, \ldots, M$:
+
+**1.** Fit weak learner $h_m$ (stump or tree) on weighted dataset.
+
+**2.** Compute weighted error:
+
+$$\varepsilon_m = \sum_{i=1}^n w_i^{(m)} \cdot \mathbb{1}\bigl[h_m(x_i) \neq y_i\bigr]$$
+
+**3.** If $\varepsilon_m \geq 1 - \frac{1}{K}$ (worse than random for $K$ classes), stop.
+
+**4.** Compute learner weight:
+
+$$\alpha_m = \nu \left[\frac{1}{2}\ln\left(\frac{1 - \varepsilon_m}{\varepsilon_m}\right) + \ln(K - 1)\right]$$
+
+where $\nu$ is `learning_rate` and $K = |\text{classes}|$.
+
+**5.** Update weights (down-weight correct predictions):
+
+$$w_i^{(m+1)} \propto w_i^{(m)} \exp\left(-\alpha_m \mathbb{1}\bigl[h_m(x_i) = y_i\bigr]\right)$$
+
+Renormalize: $\sum_i w_i^{(m+1)} = 1$.
+
+**Final classifier** — weighted majority:
+
+$$F(x) = \arg\max_c \sum_{m: h_m(x) = c} \alpha_m$$
+
+**Regressor (AdaBoost.R2)** — weak learners fit to residuals with exponential loss reweighting; final prediction is weighted median.
+
+### Weak Learners
+
+- `max_depth=1`: **Decision stumps** (1-level trees) — fast, O(n log p) per iteration
+- `max_depth>1`: **Full decision trees** — more expressive, captures non-linear splits
+
+---
+
+</div>
+
+<div class="lang-fr">
+
+## Référence API
+
+```python
+clf = sp.AdaBoostClassifier(n_estimators=50, learning_rate=1.0, max_depth=1)
+reg = sp.AdaBoostRegressor(n_estimators=50, learning_rate=1.0, max_depth=1)
+
+clf.fit(X, y)
+clf.predict(X)               -> list[int]
+clf.predict_proba(X)         -> ndarray (n, K)
+clf.score(X, y)              -> float
+clf.get_params()             -> dict
+clf.set_params(n_estimators=100, learning_rate=0.5, max_depth=3)
+
+reg.fit(X, y)
+reg.predict(X)               -> list[float]
+reg.score(X, y)              -> float
+```
+
+## Paramètres du constructeur
+
+| Paramètre | Type | Défaut | Description |
+|-----------|------|--------|-------------|
+| `n_estimators` | `int` | `50` | Nombre maximum d'apprenants faibles |
+| `learning_rate` | `float` | `1.0` | Paramètre de rétrécissement $\nu$ |
+| `max_depth` | `int` | `1` | Profondeur max; `1` = stumps, `>1` = arbres |
+
+## Attributs
+
+| Attribut | Type | Description |
+|----------|------|-------------|
+| `classes_` | `list[int]` | Labels de classes uniques |
+| `n_estimators_` | `int` | Nombre d'estimateurs utilisés |
+| `learning_rate_` | `float` | Paramètre de rétrécissement |
+| `max_depth_` | `int` | Profondeur d'arbre |
+
+## Exemple
+
+```python
+import seraplot as sp
+import numpy as np
+
+X = np.random.randn(500, 5)
+y = np.random.randint(0, 3, 500)
+
+clf = sp.AdaBoostClassifier(n_estimators=100, learning_rate=0.8, max_depth=3)
+clf.fit(X, y)
+
+proba = clf.predict_proba(X)
+score = clf.score(X, y)
+print(f"Précision: {score:.4f}, Shape proba: {np.array(proba).shape}")
+```
+
+---
+
+## Fonctionnement algorithmique
+
+**AdaBoost.M1** (Adaptive Boosting multi-classe) combine des apprenants faibles par re-pondération itérative des échantillons mal classés.
+
+**Initialisation** — poids uniformes:
+
+$$w_i^{(1)} = \frac{1}{n}, \quad i = 1, \ldots, n$$
+
+**Itération** $m = 1, \ldots, M$:
+
+**1.** Ajuster l'apprenant faible $h_m$ sur l'ensemble pondéré.
+
+**2.** Calculer l'erreur pondérée:
+
+$$\varepsilon_m = \sum_{i=1}^n w_i^{(m)} \cdot \mathbb{1}\bigl[h_m(x_i) \neq y_i\bigr]$$
+
+**3.** Si $\varepsilon_m \geq 1 - \frac{1}{K}$ (pire qu'aléatoire), arrêter.
+
+**4.** Calculer le poids de l'apprenant:
+
+$$\alpha_m = \nu \left[\frac{1}{2}\ln\left(\frac{1 - \varepsilon_m}{\varepsilon_m}\right) + \ln(K - 1)\right]$$
+
+où $\nu$ est `learning_rate` et $K = |\text{classes}|$.
+
+**5.** Mettre à jour les poids (diminuer les bonnes prédictions):
+
+$$w_i^{(m+1)} \propto w_i^{(m)} \exp\left(-\alpha_m \mathbb{1}\bigl[h_m(x_i) = y_i\bigr]\right)$$
+
+Renormaliser: $\sum_i w_i^{(m+1)} = 1$.
+
+**Classificateur final** — vote pondéré:
+
+$$F(x) = \arg\max_c \sum_{m: h_m(x) = c} \alpha_m$$
+
+**Régresseur (AdaBoost.R2)** — apprenants faibles ajustés aux résidus; prédiction finale = médiane pondérée.
+
+### Apprenants faibles
+
+- `max_depth=1`: **Decision stumps** (arbres 1-niveau) — rapide, O(n log p) par itération
+- `max_depth>1`: **Arbres complets** — plus expressif, capture les splits non-linéaires
+
+---
+
+</div>

seraplot-2.4.1/src/docs/ml/dbscan-class.md

@@ -0,0 +1,203 @@
+# DBSCAN Class
+
+<div class="lang-en">
+
+## API Reference
+
+```python
+model = sp.DBSCAN(eps=0.5, min_samples=5)
+
+model.fit(X)                 -> None
+model.fit_predict(X)         -> list[int]
+
+model.labels_                -> list[int]
+model.n_clusters_            -> int
+model.n_noise_               -> int
+```
+
+## Constructor Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `eps` | `float` | `0.5` | Neighborhood radius threshold $\epsilon$ |
+| `min_samples` | `int` | `5` | Minimum points to form a dense core |
+
+## Methods
+
+| Method | Signature | Returns | Description |
+|--------|-----------|---------|-------------|
+| `fit(X)` | `fit(X: list[list[float]])` | `None` | Fit DBSCAN on N-dimensional data, populates `labels_`, `n_clusters_`, `n_noise_` |
+| `fit_predict(X)` | `fit_predict(X: list[list[float]])` | `list[int]` | Fit and return cluster labels (convenience wrapper) |
+
+## Attributes
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `labels_` | `list[int]` | Cluster label per point (`-1` = noise) |
+| `n_clusters_` | `int` | Number of identified clusters (noise not counted) |
+| `n_noise_` | `int` | Count of noise points (label $-1$) |
+
+## Example
+
+```python
+import seraplot as sp
+import numpy as np
+
+data = np.random.randn(100, 3)
+
+model = sp.DBSCAN(eps=0.8, min_samples=5)
+labels = model.fit_predict(data.tolist())
+
+print(f"Clusters: {model.n_clusters_}, Noise: {model.n_noise_}")
+print(f"Labels shape: {len(labels)}")
+
+x, y, z = data[:, 0].tolist(), data[:, 1].tolist(), data[:, 2].tolist()
+color_groups = [str(lbl) for lbl in labels]
+
+chart = sp.build_dbscan_chart_3d(
+    f"DBSCAN ({model.n_clusters_} clusters)",
+    x, y, z,
+    eps=0.8, min_samples=5,
+    color_groups=color_groups
+)
+```
+
+---
+
+## Algorithmic Functioning
+
+DBSCAN (**Density-Based Spatial Clustering of Applications with Noise**) groups points in dense regions and marks isolated points as noise.
+
+**Core concepts** — for point $p$:
+
+- **$\epsilon$-neighborhood:** $N_\epsilon(p) = \{q \in D : \|p - q\|_2 \leq \epsilon\}$
+- **Core point:** $|N_\epsilon(p)| \geq \text{min\_samples}$
+- **Border point:** not core, but within $\epsilon$ of a core point
+- **Noise point:** not reachable from any core point → label $-1$
+
+**Algorithm:**
+
+1. For each unvisited point $p$:
+   - If $p$ is core, start a new cluster via **BFS** (expand through density-connected neighbors)
+   - Otherwise, mark as noise (or leave unvisited)
+
+2. Clusters are maximal sets of density-connected points.
+
+**Implementation:**
+
+SeraPlot uses **KD-tree** for $O(\log n)$ radius queries and **parallel BFS** with SIMD distance acceleration. `n_clusters_` counts only true clusters; noise points are excluded.
+
+**Complexity:** $O(n \log n)$ average time; $O(n^2)$ worst case.
+
+---
+
+## See also
+
+- [DBSCAN Chart (2D)](dbscan.md)
+- [DBSCAN 3D Chart](dbscan3d.md)
+
+---
+
+</div>
+
+<div class="lang-fr">
+
+## Référence API
+
+```python
+model = sp.DBSCAN(eps=0.5, min_samples=5)
+
+model.fit(X)                 -> None
+model.fit_predict(X)         -> list[int]
+
+model.labels_                -> list[int]
+model.n_clusters_            -> int
+model.n_noise_               -> int
+```
+
+## Paramètres du constructeur
+
+| Paramètre | Type | Défaut | Description |
+|-----------|------|--------|-------------|
+| `eps` | `float` | `0.5` | Rayon de voisinage $\epsilon$ |
+| `min_samples` | `int` | `5` | Points min pour former un cœur |
+
+## Méthodes
+
+| Méthode | Signature | Retourne | Description |
+|---------|-----------|----------|-------------|
+| `fit(X)` | `fit(X: list[list[float]])` | `None` | Ajuste DBSCAN, remplit `labels_`, `n_clusters_`, `n_noise_` |
+| `fit_predict(X)` | `fit_predict(X: list[list[float]])` | `list[int]` | Ajuste et retourne labels |
+
+## Attributs
+
+| Attribut | Type | Description |
+|----------|------|-------------|
+| `labels_` | `list[int]` | Label de cluster par point (`-1` = bruit) |
+| `n_clusters_` | `int` | Nombre de clusters (bruit non compté) |
+| `n_noise_` | `int` | Nombre de points bruit (label $-1$) |
+
+## Exemple
+
+```python
+import seraplot as sp
+import numpy as np
+
+data = np.random.randn(100, 3)
+
+model = sp.DBSCAN(eps=0.8, min_samples=5)
+labels = model.fit_predict(data.tolist())
+
+print(f"Clusters: {model.n_clusters_}, Bruit: {model.n_noise_}")
+
+x, y, z = data[:, 0].tolist(), data[:, 1].tolist(), data[:, 2].tolist()
+color_groups = [str(lbl) for lbl in labels]
+
+chart = sp.build_dbscan_chart_3d(
+    f"DBSCAN ({model.n_clusters_} clusters)",
+    x, y, z,
+    eps=0.8, min_samples=5,
+    color_groups=color_groups
+)
+```
+
+---
+
+## Fonctionnement algorithmique
+
+DBSCAN groupe les points dans les **régions denses** et marque les points isolés comme bruit.
+
+**Concepts clés** — pour un point $p$:
+
+- **$\epsilon$-voisinage:** $N_\epsilon(p) = \{q \in D : \|p - q\|_2 \leq \epsilon\}$
+- **Point cœur:** $|N_\epsilon(p)| \geq \text{min\_samples}$
+- **Point frontière:** non cœur, mais dans $\epsilon$ d'un point cœur
+- **Point bruit:** non accessible depuis aucun point cœur → label $-1$
+
+**Algorithme:**
+
+1. Pour chaque point $p$ non visité:
+   - Si $p$ est cœur, démarrer cluster via **BFS**
+   - Sinon, marquer comme bruit
+
+2. Les clusters sont ensembles maximaux de points densément connexes.
+
+**Implémentation:**
+
+SeraPlot utilise **KD-tree** pour $O(\log n)$ requêtes de rayon et **BFS parallèle** avec accélération SIMD. `n_clusters_` ne compte que vrais clusters; bruit exclu.
+
+**Complexité:** $O(n \log n)$ en moyenne; $O(n^2)$ pire cas.
+
+---
+
+## Voir aussi
+
+- [Graphique DBSCAN (2D)](dbscan.md)
+- [Graphique DBSCAN 3D](dbscan3d.md)
+
+---
+
+</div>
+
+
+