fix: docs

Author: dancixx

website/content/docs/benchmarks.mdx

@@ -166,7 +166,7 @@ Drivers (sub-crate paths):
 
 ```toml
 [dependencies]
-stochastic-rs = { version = "2.1", features = ["dual-stream-rng"] }
+stochastic-rs = { version = "2.2", features = ["dual-stream-rng"] }
 ```
 
 Unlocks `stochastic_rs_core::simd_rng_dual::SimdRngDual` (two parallel

website/content/docs/concepts/feature-flags.mdx

@@ -51,7 +51,7 @@ If you depend on a sub-crate directly (recommended for lean builds),
 you enable the feature on that sub-crate:
 
 ```toml
-stochastic-rs-stats = { version = "2.1.0", features = ["openblas"] }
+stochastic-rs-stats = { version = "2.2.0", features = ["openblas"] }
 ```
 
 ## Common gotchas

website/content/docs/concepts/process-ext.mdx

@@ -61,13 +61,21 @@ ship for FGN / fBM only — see the [add-gpu-sampler SKILL](https://github.com/d
 
 ## Construction patterns
 
-Every process exposes:
+Every process follows the same canonical `new(args, seed)` constructor
+(see the [seeding concept page](/docs/concepts/seeding) for the full
+design):
 
 ```rust
-let p = Foo::<T>::new(/* params */, n, x0, t);            // thread-local seed
-let p = Foo::<T>::with_seed(/* params */, n, x0, t, 42);  // explicit seed
-let p = Foo::<T>::from_seed_source(/* params */, n, x0, t, src);  // chain seeds
+use stochastic_rs::simd_rng::{Deterministic, Unseeded};
+
+let p = Foo::<T, _>::new(/* params */, n, x0, t, Unseeded);                  // auto-seeded
+let p = Foo::<T, _>::new(/* params */, n, x0, t, Deterministic::new(42));    // reproducible
+let p = Foo::<T, _>::new(/* params */, n, x0, t, shared_seed_source);        // chain seeds
 ```
 
-Use `with_seed` in tests (so they are deterministic) and `from_seed_source`
-when chaining processes (e.g. correlated Brownian factors).
+Use `Deterministic` in tests so they replay bit-exactly. Pass a shared
+seed source when chaining correlated processes — each `seed.rng()` /
+`seed.rng_ext()` call atomically advances the internal counter, so the
+streams diverge despite the shared root. `SeedExt::reseed(u64)` swaps a
+`Deterministic` source in place to sweep seeds without rebuilding the
+process.

website/content/docs/copulas.mdx

@@ -49,56 +49,49 @@ crashes in equity returns.
 use stochastic_rs::copulas::bivariate::clayton::Clayton;
 use stochastic_rs::traits::BivariateExt;
 
-let cop = Clayton::<f64>::with_seed(/* theta */ 2.0, 42);
-let n = 10_000;
-let (u, v) = cop.sample(n);                  // both Array1<f64> in [0, 1]
+let mut cop = Clayton::new();
+cop.set_tau(0.5);                            // τ ⇒ θ via Kendall inversion
+let _ = cop.compute_theta();
+let uv = cop.sample_with_seed(10_000, 42)?;  // Array2<f64>, shape (10_000, 2)
+let (u, v) = (uv.column(0), uv.column(1));   // both in [0, 1]
 
-// Empirical Kendall's τ should be ≈ θ / (θ + 2) = 0.5
-let tau_hat = stochastic_rs::stats::tail_index::kendall_tau(u.view(), v.view());
+let tau_hat = stochastic_rs::stats::tail_index::kendall_tau(u, v);
 println!("τ̂ = {:.3}", tau_hat);
 ```
 </Tab>
 <Tab value="Python">
 ```python
 import stochastic_rs as srs
 
-cop = srs.Clayton(theta=2.0, seed=42)
-u, v = cop.sample(10_000)
+cop = srs.Clayton(theta=2.0)
+uv = cop.sample(10_000, seed=42)             # shape (10_000, 2)
+u, v = uv[:, 0], uv[:, 1]
 print("Kendall's tau ≈", srs.kendall_tau(u, v))   # ≈ 0.5
 ```
 </Tab>
 </Tabs>
 
 ### Gaussian copula — multivariate sampling
 
-<Tabs items={['Rust', 'Python']}>
+<Tabs items={['Rust']}>
 <Tab value="Rust">
 ```rust
-use stochastic_rs::copulas::multivariate::gaussian::GaussianCopula;
+use stochastic_rs::copulas::multivariate::gaussian::GaussianMultivariate;
+use stochastic_rs::traits::MultivariateExt;
 use ndarray::array;
 
 let corr = array![
     [1.0, 0.7, 0.3],
     [0.7, 1.0, 0.5],
     [0.3, 0.5, 1.0],
 ];
-let cop = GaussianCopula::<f64>::with_seed(corr, 42);
-let samples = cop.sample(10_000);            // Array2<f64>, shape (10_000, 3)
+let cop = GaussianMultivariate::new_with_corr(corr)?;
+let samples = cop.sample(10_000)?;           // Array2<f64>, shape (10_000, 3)
 ```
-</Tab>
-<Tab value="Python">
-```python
-import stochastic_rs as srs
-import numpy as np
 
-corr = np.array([
-    [1.0, 0.7, 0.3],
-    [0.7, 1.0, 0.5],
-    [0.3, 0.5, 1.0],
-])
-cop = srs.GaussianCopula(corr=corr, seed=42)
-samples = cop.sample(10_000)                 # shape (10_000, 3)
-```
+> The multivariate Gaussian copula depends on `ndarray-linalg` (the
+> `openblas` feature) for the Cholesky factorisation, so it is **not**
+> wrapped for Python — use the Rust API directly.
 </Tab>
 </Tabs>
 

website/content/docs/distributions.mdx

@@ -58,10 +58,11 @@ distributions**, every one of them with:
 <Tab value="Rust">
 ```rust
 use stochastic_rs::distributions::normal::SimdNormal;
+use stochastic_rs::simd_rng::Deterministic;
 use stochastic_rs::traits::DistributionExt;
 use rand_distr::Distribution;
 
-let d = SimdNormal::<f64>::with_seed(/* mean */ 0.0, /* std */ 1.0, 42);
+let d = SimdNormal::<f64>::new(/* mean */ 0.0, /* std */ 1.0, &Deterministic::new(42));
 
 // Single sample
 let mut rng = rand::thread_rng();
@@ -100,9 +101,10 @@ print(d.pdf(0.0), d.cdf(1.96))               # 0.3989, 0.975
 <Tab value="Rust">
 ```rust
 use stochastic_rs::distributions::beta::SimdBeta;
+use stochastic_rs::simd_rng::Deterministic;
 use stochastic_rs::traits::DistributionExt;
 
-let d = SimdBeta::<f64>::with_seed(/* alpha */ 2.0, /* beta */ 5.0, 42);
+let d = SimdBeta::<f64>::new(/* alpha */ 2.0, /* beta */ 5.0, &Deterministic::new(42));
 let mut buf = vec![0.0; 1_000];
 d.fill_slice_fast(&mut buf);
 assert!(buf.iter().all(|&x| x >= 0.0 && x <= 1.0));
@@ -130,8 +132,9 @@ print(d.mean(), d.variance())                # 0.2857, 0.0255
 <Tab value="Rust">
 ```rust
 use stochastic_rs::distributions::poisson::SimdPoisson;
+use stochastic_rs::simd_rng::Deterministic;
 
-let d = SimdPoisson::<f64>::with_seed(/* lambda */ 4.0, 42);
+let d = SimdPoisson::<u32>::new(/* lambda */ 4.0, &Deterministic::new(42));
 let mut buf = vec![0_u32; 10_000];
 d.fill_slice_fast(&mut buf);
 
@@ -154,10 +157,20 @@ print(counts.mean(), counts.var())           # both ≈ 4.0
 
 ### Construction
 
+Every distribution follows the same `new(args, &seed)` constructor pattern — pass
+[`Unseeded`](/docs/concepts/seeding) for an auto-seeded RNG or
+[`Deterministic::new(u64)`](/docs/concepts/seeding) for a reproducible
+stream. See the [seeding concept page](/docs/concepts/seeding) for the
+full design (including `SeedExt::reseed`, the generic `R: SimdRngExt`
+backing RNG, and the experimental `dual-stream-rng` feature).
+
 ```rust
-let d = Foo::<T>::new(/* params */);                          // thread-local seed
-let d = Foo::<T>::with_seed(/* params */, /* seed */ 42);     // explicit seed
-let d = Foo::<T>::from_seed_source(/* params */, source);     // chain seeds
+use stochastic_rs::simd_rng::{Deterministic, Unseeded};
+
+let d = Foo::<T>::new(/* params */, &Unseeded);                       // auto-seeded
+let d = Foo::<T>::new(/* params */, &Deterministic::new(42));         // reproducible
+let d = Foo::<T>::new(/* params */, &shared_seed_source);             // share a seed source
+                                                                       // across sub-components
 ```
 
 ### Sampling

website/content/docs/getting-started/installation-rust.mdx

@@ -12,7 +12,7 @@ status: stable
 
 ```toml
 [dependencies]
-stochastic-rs = "2.1.0"
+stochastic-rs = "2.2.0"
 ```
 
 Then:
@@ -33,13 +33,13 @@ sub-crates you need:
 
 ```toml
 [dependencies]
-stochastic-rs-distributions = "2.1.0"   # SIMD distribution sampling
-stochastic-rs-stochastic    = "2.1.0"   # 120+ process types
-stochastic-rs-copulas       = "2.1.0"   # bivariate / multivariate copulas
-stochastic-rs-stats         = "2.1.0"   # estimators
-stochastic-rs-quant         = "2.1.0"   # pricing / calibration / vol surface
-stochastic-rs-ai            = "2.1.0"   # neural surrogates (candle)
-stochastic-rs-viz           = "2.1.0"   # plotly grid plotter
+stochastic-rs-distributions = "2.2.0"   # SIMD distribution sampling
+stochastic-rs-stochastic = "2.2.0"   # 120+ process types
+stochastic-rs-copulas = "2.2.0"   # bivariate / multivariate copulas
+stochastic-rs-stats = "2.2.0"   # estimators
+stochastic-rs-quant = "2.2.0"   # pricing / calibration / vol surface
+stochastic-rs-ai = "2.2.0"   # neural surrogates (candle)
+stochastic-rs-viz = "2.2.0"   # plotly grid plotter
 ```
 
 Topology:

website/content/docs/processes.mdx

@@ -93,11 +93,12 @@ $H > 0.5$ is persistent.
 <Tabs items={['Rust', 'Python']}>
 <Tab value="Rust">
 ```rust
+use stochastic_rs::simd_rng::Deterministic;
 use stochastic_rs::stochastic::noise::fgn::Fgn;
 
-let fgn = Fgn::<f64>::with_seed(/* hurst */ 0.3, /* sigma */ 1.0,
-                                /* n */ 4096, /* t */ Some(1.0),
-                                /* seed */ 42);
+let fgn = Fgn::<f64, _>::new(/* hurst */ 0.3, /* sigma */ 1.0,
+                             /* n */ 4096, /* t */ Some(1.0),
+                             Deterministic::new(42));
 let increments = fgn.sample();
 ```
 </Tab>
@@ -117,17 +118,24 @@ fbm = np.cumsum(increments)         # fBM = cumsum(fGN)
 
 ### Construction
 
-Every process exposes three constructors:
+Every process follows the same `new(args, seed)` pattern (mirrors the
+distribution constructors — see the [seeding concept
+page](/docs/concepts/seeding)). The seed argument is a value implementing
+[`SeedExt`](/docs/concepts/seeding):
 
 ```rust
-let p = Foo::<T>::new(/* params */, n, x0, t);                      // thread-local seed
-let p = Foo::<T>::with_seed(/* params */, n, x0, t, /* seed */ 42); // explicit seed
-let p = Foo::<T>::from_seed_source(/* params */, n, x0, t, source); // chain seeds
+use stochastic_rs::simd_rng::{Deterministic, Unseeded};
+
+let p = Foo::<T, _>::new(/* params */, n, x0, t, Unseeded);                  // auto-seeded
+let p = Foo::<T, _>::new(/* params */, n, x0, t, Deterministic::new(42));    // reproducible
 ```
 
-Use `with_seed` in tests (so they are deterministic) and
-`from_seed_source` when chaining processes (e.g. correlated Brownian
-factors).
+Use `Deterministic` in tests so they replay bit-exactly; pass a shared
+`Deterministic` to several processes when chaining correlated factors —
+each call to `seed.rng()` / `seed.rng_ext()` atomically advances the
+internal counter, so the streams diverge despite the shared root seed.
+`SeedExt::reseed(u64)` swaps a `Deterministic` source in place to sweep
+seeds without rebuilding the process.
 
 ### Sampling
 

website/content/docs/stats.mdx

@@ -102,12 +102,13 @@ Recommended for empirical roughness studies.
 <Tabs items={['Rust', 'Python']}>
 <Tab value="Rust">
 ```rust
+use stochastic_rs::simd_rng::Deterministic;
 use stochastic_rs::stochastic::noise::fgn::Fgn;
 use stochastic_rs::stats::fukasawa_hurst::FukasawaHurst;
 use stochastic_rs::traits::ProcessExt;
 
 let true_h = 0.3;
-let path = Fgn::<f64>::with_seed(true_h, 1.0, 4096, Some(1.0), 42).sample();
+let path = Fgn::<f64, _>::new(true_h, 1.0, 4096, Some(1.0), Deterministic::new(42)).sample();
 let res = FukasawaHurst::<f64>::new().estimate(path.view());
 
 println!("H̃ = {:.3} (true = {:.3})", res.point, true_h);

website/content/docs/viz.mdx

@@ -18,9 +18,9 @@ build does not pull Plotly's transitive deps.
 
 ```toml
 [dependencies]
-stochastic-rs-viz = "2.1.0"
+stochastic-rs-viz = "2.2.0"
 # or via the umbrella:
-stochastic-rs = { version = "2.1.0", features = ["viz"] }
+stochastic-rs = { version = "2.2.0", features = ["viz"] }
 ```
 
 ## Examples