pystochastic 0.2.0__py3-none-any.whl

benchmarks/bench_montecarlo.py

@@ -0,0 +1,107 @@
+"""
+Benchmark for pystochastic.montecarlo (MonteCarloEstimator, MonteCarloProcess).
+"""
+
+import time
+import numpy as np
+
+from pystochastic.pyrandom import crandom
+from pystochastic.processes.vasicek import Vasicek
+from pystochastic.montecarlo.montecarlo import MonteCarloEstimator, MonteCarloProcess
+
+
+# ---------------------------------------------------------------------
+# Benchmark helper
+# ---------------------------------------------------------------------
+
+def time_call(fn, n_runs=5):
+    times = []
+    for _ in range(n_runs):
+        start = time.perf_counter()
+        fn()
+        end = time.perf_counter()
+        times.append(end - start)
+    return np.mean(times), np.min(times), np.max(times)
+
+
+# ---------------------------------------------------------------------
+# MonteCarloEstimator benchmark
+# ---------------------------------------------------------------------
+
+def run_estimator_benchmark(sample_sizes, n_runs=5):
+    print("=" * 70)
+    print("MonteCarloEstimator benchmark")
+    print("=" * 70)
+    print(f"Runs : {n_runs}")
+    print("-" * 70)
+
+    for n in sample_sizes:
+        print(f"n_simulations = {n:,}")
+        samples = crandom.gamma(3, 2, n)
+        mc = MonteCarloEstimator(samples)
+
+        for name, fn in {
+            "estimate": lambda: mc.estimate(),
+            "mean_estimator": lambda: mc.mean_estimator(),
+            "confidence_interval": lambda: mc.confidence_interval(),
+            "confidence_curve": lambda: mc.confidence_curve(),
+        }.items():
+            try:
+                mean_t, min_t, max_t = time_call(fn, n_runs=n_runs)
+                print(f"  {name:<20s} : {mean_t*1000:8.3f} ms (min={min_t*1000:.3f}, max={max_t*1000:.3f})")
+            except Exception as e:
+                print(f"  {name:<20s} : ERROR ({type(e).__name__}: {e})")
+        print("-" * 70)
+
+
+# ---------------------------------------------------------------------
+# MonteCarloProcess benchmark
+# ---------------------------------------------------------------------
+
+def run_process_benchmark(sample_sizes, n_runs=3):
+    print("=" * 70)
+    print("MonteCarloProcess benchmark (Vasicek, method='exact')")
+    print("=" * 70)
+    print(f"Runs : {n_runs}")
+    print("-" * 70)
+
+    for n in sample_sizes:
+        print(f"n_simulations = {n:,}")
+
+        def build():
+            process = Vasicek(reversion_speed=2, mu=1.5, volatility=0.3, r_0=0, n_steps=200)
+            return MonteCarloProcess(process, n_simulations=n)
+
+        try:
+            mean_t, min_t, max_t = time_call(build, n_runs=n_runs)
+            print(f"  construction (incl. simulate) : {mean_t:8.4f} s (min={min_t:.4f}, max={max_t:.4f})")
+        except Exception as e:
+            print(f"  construction (incl. simulate) : ERROR ({type(e).__name__}: {e})")
+            print("-" * 70)
+            continue
+
+        mc = build()
+
+        for name, fn in {
+            "estimate": lambda: mc.estimate(),
+            "mean_path": lambda: mc.mean_path(plot_sim=False),
+        }.items():
+            try:
+                mean_t, min_t, max_t = time_call(fn, n_runs=n_runs)
+                print(f"  {name:<28s} : {mean_t:8.4f} s (min={min_t:.4f}, max={max_t:.4f})")
+            except Exception as e:
+                print(f"  {name:<28s} : ERROR ({type(e).__name__}: {e})")
+        print("-" * 70)
+
+
+# ---------------------------------------------------------------------
+# Main benchmark
+# ---------------------------------------------------------------------
+
+def main():
+    run_estimator_benchmark(sample_sizes=[1_000, 10_000, 100_000, 1_000_000], n_runs=5)
+    run_process_benchmark(sample_sizes=[100, 1_000, 5_000], n_runs=3)
+
+
+if __name__ == "__main__":
+    main()

benchmarks/bench_processes.py

@@ -0,0 +1,163 @@
+"""
+Benchmark for pystochastic.processes (Vasicek, CIR, OrnsteinUhlenbeck,
+GeometricBrownianMotion, Poisson, Brownian).
+
+Measures simulation time as a function of the number of simulations and
+time steps, for each available method ("exact", "euler-maruyama",
+"milstein" when applicable).
+"""
+
+import time
+import numpy as np
+
+from pystochastic.processes.vasicek import Vasicek
+from pystochastic.processes.CIR import CIR
+from pystochastic.processes.OrnsteinUhlenbeck import OrnsteinUhlenbeck
+from pystochastic.processes.GeometricBrownianMotion import GeometricBrownianMotion
+from pystochastic.processes.poisson import Poisson
+from pystochastic.processes.brownian import Brownian
+
+
+# ---------------------------------------------------------------------
+# Benchmark helper
+# ---------------------------------------------------------------------
+
+def benchmark_simulate(build_process, n_simulations, method=None, n_runs=3, **simulate_kwargs):
+    """
+    build_process : callable() -> a fresh process instance (rebuilt each run,
+        so that internal caches -- if any -- don't distort the timing).
+    """
+    times = []
+    for _ in range(n_runs):
+        process = build_process()
+        start = time.perf_counter()
+        if method is not None:
+            process.simulate(n_simulations=n_simulations, method=method, plot=False,**simulate_kwargs)
+        else:
+            process.simulate(n_simulations=n_simulations, plot=False,**simulate_kwargs)
+        end = time.perf_counter()
+        times.append(end - start)
+    return np.mean(times), np.min(times), np.max(times)
+
+
+def run_process_group(label, build_process, methods, simulations, time_steps, n_runs=3):
+    print("=" * 70)
+    print(f"processes benchmark -- {label}")
+    print("=" * 70)
+    print(f"Runs : {n_runs}")
+    print("-" * 70)
+
+    for n_steps in time_steps:
+        print(f"Number of time steps : {n_steps}")
+        print("-" * 70)
+
+        for n_simulations in simulations:
+            print(f"Simulations : {n_simulations:,}")
+            for method in methods:
+                try:
+                    mean_t, min_t, max_t = benchmark_simulate(
+                        lambda: build_process(n_steps),
+                        n_simulations=n_simulations,
+                        method=method,
+                        n_runs=n_runs,
+                    )
+                    print(f"  {method:<16s} : {mean_t:8.4f} s (min={min_t:.4f}, max={max_t:.4f})")
+                except Exception as e:
+                    print(f"  {method:<16s} : ERROR ({type(e).__name__}: {e})")
+        print("-" * 70)
+
+
+def run_no_method_group(label, build_process, simulations, time_steps, n_runs=3):
+    """For processes without a `method` argument (Poisson, Brownian)."""
+    print("=" * 70)
+    print(f"processes benchmark -- {label}")
+    print("=" * 70)
+    print(f"Runs : {n_runs}")
+    print("-" * 70)
+
+    for n_steps in time_steps:
+        print(f"Number of time steps : {n_steps}")
+        print("-" * 70)
+
+        for n_simulations in simulations:
+            try:
+                mean_t, min_t, max_t = benchmark_simulate(
+                    lambda: build_process(n_steps),
+                    n_simulations=n_simulations,
+                    method=None,
+                    n_runs=n_runs,
+                )
+                print(f"Simulations : {n_simulations:<8,} : {mean_t:8.4f} s (min={min_t:.4f}, max={max_t:.4f})")
+            except Exception as e:
+                print(f"Simulations : {n_simulations:<8,} : ERROR ({type(e).__name__}: {e})")
+        print("-" * 70)
+
+
+# ---------------------------------------------------------------------
+# Main benchmark
+# ---------------------------------------------------------------------
+
+def main():
+
+    simulations = [100, 1_000, 5_000, 10_000]
+    time_steps = [100, 500]
+    methods = ["exact", "euler-maruyama", "milstein"]
+    n_runs = 3
+
+    run_process_group(
+        "Vasicek",
+        build_process=lambda n_steps: Vasicek(reversion_speed=2, mu=1.5, volatility=0.3, r_0=0, n_steps=n_steps),
+        methods=methods,
+        simulations=simulations,
+        time_steps=time_steps,
+        n_runs=n_runs,
+    )
+
+    run_process_group(
+        "CIR",
+        build_process=lambda n_steps: CIR(a=2, b=0.05, sigma=0.1, r_0=0.03, n_steps=n_steps),
+        methods=methods,
+        simulations=simulations,
+        time_steps=time_steps,
+        n_runs=n_runs,
+    )
+
+    run_process_group(
+        "OrnsteinUhlenbeck",
+        build_process=lambda n_steps: OrnsteinUhlenbeck(mu=2, sigma=0.5, theta=1.5, r_0=0, n_steps=n_steps),
+        methods=methods,
+        simulations=simulations,
+        time_steps=time_steps,
+        n_runs=n_runs,
+    )
+
+    run_process_group(
+        "GeometricBrownianMotion",
+        build_process=lambda n_steps: GeometricBrownianMotion(mu=0.05, sigma=0.2, S_0=100, n_steps=n_steps),
+        methods=methods,
+        simulations=simulations,
+        time_steps=time_steps,
+        n_runs=n_runs,
+    )
+
+    # Poisson has not been vectorized yet (see conversation) -- expect this
+    # to scale much more slowly than the processes above.
+    run_no_method_group(
+        "Poisson",
+        build_process=lambda n_steps: Poisson(intensity=3, n_steps=n_steps),
+        simulations=[100, 1_000, 5_000],
+        time_steps=time_steps,
+        n_runs=n_runs,
+    )
+
+    run_no_method_group(
+        "Brownian",
+        build_process=lambda n_steps: Brownian(1, n_steps=n_steps),
+        simulations=simulations,
+        time_steps=time_steps,
+        n_runs=n_runs,
+    )
+
+
+if __name__ == "__main__":
+    main()

benchmarks/bench_pyrandom.py

@@ -0,0 +1,95 @@
+"""
+Benchmark for pystochastic.pyrandom (crandom + drandom).
+
+Measures generation time for each distribution as a function of the
+number of samples requested. Errors on individual distributions are
+reported but do not stop the benchmark.
+"""
+
+import time
+import numpy as np
+
+from pystochastic.pyrandom import crandom
+from pystochastic.pyrandom import drandom
+
+
+# ---------------------------------------------------------------------
+# Benchmark helper
+# ---------------------------------------------------------------------
+
+def benchmark_call(fn, n_runs=5):
+    """Times a zero-argument callable n_runs times."""
+    times = []
+    for _ in range(n_runs):
+        start = time.perf_counter()
+        fn()
+        end = time.perf_counter()
+        times.append(end - start)
+    return np.mean(times), np.min(times), np.max(times)
+
+
+def run_group(label, functions, sample_sizes, n_runs=5):
+    """
+    functions : dict {name: callable(n) -> samples}
+    """
+    print("=" * 70)
+    print(f"pyrandom benchmark -- {label}")
+    print("=" * 70)
+    print(f"Runs : {n_runs}")
+    print("-" * 70)
+
+    for n in sample_sizes:
+        print(f"n = {n:,}")
+        for name, fn in functions.items():
+            try:
+                mean_t, min_t, max_t = benchmark_call(lambda: fn(n), n_runs=n_runs)
+                print(f"  {name:<18s} : {mean_t*1000:8.3f} ms (min={min_t*1000:.3f}, max={max_t*1000:.3f})")
+            except Exception as e:
+                print(f"  {name:<18s} : ERROR ({type(e).__name__}: {e})")
+        print("-" * 70)
+
+
+# ---------------------------------------------------------------------
+# Main benchmark
+# ---------------------------------------------------------------------
+
+def main():
+
+    sample_sizes = [1_000, 10_000, 100_000, 1_000_000]
+    n_runs = 5
+
+    continuous_laws = {
+        "uniform": lambda n: crandom.uniform(0, 1, n),
+        "exponential": lambda n: crandom.exponential(1, n),
+        "normal": lambda n: crandom.normal(0, 1, n),
+        "gamma (int shape)": lambda n: crandom.gamma(3, 1, n),
+        "gamma (frac shape)": lambda n: crandom.gamma(2.5, 1, n),
+        "beta": lambda n: crandom.beta(2, 3, n),
+        "weibull": lambda n: crandom.weibull(1.5, 1, n),
+        "frechet": lambda n: crandom.frechet(2, 1, 0, n),
+        "cauchy": lambda n: crandom.cauchy(0, 1, n),
+        "gumbel": lambda n: crandom.gumbel(0, 1, n),
+        "kumaraswamy": lambda n: crandom.kumaraswamy(2, 3, n),
+        "fisher": lambda n: crandom.fisher(4, 10, n),
+        "pareto": lambda n: crandom.pareto(1, 3, n),
+        "rayleigh": lambda n: crandom.rayleigh(1, n),
+    }
+
+    discrete_laws = {
+        "duniform": lambda n: drandom.duniform(10, n),
+        "bernoulli": lambda n: drandom.bernoulli(0.3, n),
+        "rademacher": lambda n: drandom.rademacher(0.5, n),
+        "binomial": lambda n: drandom.binomial(0.3, 20, n),
+        "poisson": lambda n: drandom.poisson(3, n),
+        "hypergeometric": lambda n: drandom.hypergeometric(50, 20, 10, n),
+        "geometric": lambda n: drandom.geometric(0.3, n),
+        "negative_binomial": lambda n: drandom.negative_binomial(0.3, 5, n),
+        "yule_simon": lambda n: drandom.yule_simon(2, n),
+    }
+
+    run_group("continuous laws (crandom)", continuous_laws, sample_sizes, n_runs=n_runs)
+    run_group("discrete laws (drandom)", discrete_laws, sample_sizes, n_runs=n_runs)
+
+
+if __name__ == "__main__":
+    main()

benchmarks/bench_sde.py

@@ -0,0 +1,185 @@
+"""
+Benchmark for pystochastic.sde (EulerMaruyama, Milstein).
+
+Compares the vectorized path (diagonal diffusion) against the sequential
+path (full matrix diffusion) for EulerMaruyama, with and without
+parallelization (multiprocess) on the sequential path, and benchmarks
+Milstein (always vectorized, restricted to autonomous 1D SDEs).
+"""
+
+import time
+import numpy as np
+
+from pystochastic.sde.eulermaruyama import EulerMaruyama
+from pystochastic.sde.milstein import Milstein
+
+
+# ---------------------------------------------------------------------
+# Test functions -- matrix form (sequential path)
+# ---------------------------------------------------------------------
+
+def cheap_drift(x, t):
+    return x
+
+
+def cheap_diffusion_matrix(x, t):
+    return 0.1 * np.eye(len(x))
+
+
+def normal_drift(x, t):
+    return np.sin(x) + 0.5 * x
+
+
+def normal_diffusion_matrix(x, t):
+    return np.diag(0.1 + 0.05 * np.abs(x))
+
+
+# ---------------------------------------------------------------------
+# Test functions -- diagonal form (vectorized path), same underlying SDE
+# ---------------------------------------------------------------------
+
+def cheap_diffusion_diag(x, t):
+    return 0.1 * np.ones_like(x)
+
+
+def normal_diffusion_diag(x, t):
+    return 0.1 + 0.05 * np.abs(x)
+
+
+# ---------------------------------------------------------------------
+# Milstein test functions (autonomous, 1D only)
+# ---------------------------------------------------------------------
+
+def milstein_drift(x):
+    return -x
+
+
+def milstein_diffusion(x):
+    return 0.3 * np.ones_like(x)
+
+
+# ---------------------------------------------------------------------
+# Benchmark helpers
+# ---------------------------------------------------------------------
+
+def benchmark_euler(n_simulations, n_steps, mu, sigma, n_runs=3, dim=1, parallel=False, n_workers=None):
+    x_0 = np.ones(dim)
+    times = []
+    for _ in range(n_runs):
+        solver = EulerMaruyama(mu=mu, sigma=sigma, x_0=x_0, t_0=0, t_n=1,
+                                n_steps=n_steps, n_simulations=n_simulations)
+        start = time.perf_counter()
+        solver.solve(plot=False, parallel=parallel, n_workers=n_workers)
+        end = time.perf_counter()
+        times.append(end - start)
+    return np.mean(times), np.min(times), np.max(times)
+
+
+def benchmark_milstein(n_simulations, n_steps, mu, sigma, n_runs=3):
+    times = []
+    for _ in range(n_runs):
+        solver = Milstein(mu=mu, sigma=sigma, x_0=1.0, t_0=0, t_n=1,
+                           n_steps=n_steps, n_simulations=n_simulations)
+        start = time.perf_counter()
+        solver.solve(plot=False)
+        end = time.perf_counter()
+        times.append(end - start)
+    return np.mean(times), np.min(times), np.max(times)
+
+
+# ---------------------------------------------------------------------
+# Comparison runner (Euler-Maruyama : matrix vs diagonal vs matrix+parallel)
+# ---------------------------------------------------------------------
+
+def run_euler_comparison(label, mu, sigma_matrix, sigma_diag, simulations, time_steps, n_runs=3, n_workers=None):
+
+    print("=" * 70)
+    print(f"EulerMaruyama benchmark -- {label}")
+    print("=" * 70)
+    print(f"Runs : {n_runs}")
+    print("-" * 70)
+
+    for n_steps in time_steps:
+        print(f"Number of time steps : {n_steps}")
+        print("-" * 70)
+
+        for n_simulations in simulations:
+
+            mat_mean, mat_min, mat_max = benchmark_euler(
+                n_simulations, n_steps, mu, sigma_matrix, n_runs=n_runs, parallel=False,
+            )
+            par_mean, par_min, par_max = benchmark_euler(
+                n_simulations, n_steps, mu, sigma_matrix, n_runs=n_runs, parallel=True, n_workers=n_workers,
+            )
+            diag_mean, diag_min, diag_max = benchmark_euler(
+                n_simulations, n_steps, mu, sigma_diag, n_runs=n_runs, parallel=False,
+            )
+
+            speedup_par = mat_mean / par_mean if par_mean > 0 else float("inf")
+            speedup_vec = mat_mean / diag_mean if diag_mean > 0 else float("inf")
+
+            print(
+                f"Simulations : {n_simulations:,}\n"
+                f"  Matrix (sequential)        : {mat_mean:.4f} s (min={mat_min:.4f}, max={mat_max:.4f})\n"
+                f"  Matrix (parallel)          : {par_mean:.4f} s (min={par_min:.4f}, max={par_max:.4f})"
+                f"   -> speedup x{speedup_par:.1f}\n"
+                f"  Diagonal (vectorized)      : {diag_mean:.4f} s (min={diag_min:.4f}, max={diag_max:.4f})"
+                f"   -> speedup x{speedup_vec:.1f}"
+            )
+
+        print("-" * 70)
+
+
+def run_milstein_benchmark(simulations, time_steps, n_runs=3):
+    print("=" * 70)
+    print("Milstein benchmark (always vectorized)")
+    print("=" * 70)
+    print(f"Runs : {n_runs}")
+    print("-" * 70)
+
+    for n_steps in time_steps:
+        print(f"Number of time steps : {n_steps}")
+        print("-" * 70)
+        for n_simulations in simulations:
+            mean_t, min_t, max_t = benchmark_milstein(
+                n_simulations, n_steps, milstein_drift, milstein_diffusion, n_runs=n_runs,
+            )
+            print(f"Simulations : {n_simulations:<8,} : {mean_t:.4f} s (min={min_t:.4f}, max={max_t:.4f})")
+        print("-" * 70)
+
+
+# ---------------------------------------------------------------------
+# Main benchmark
+# ---------------------------------------------------------------------
+
+def main():
+
+    simulations = [100, 1_000, 5_000, 10_000]
+    time_steps = [100, 500]
+    n_runs = 3
+
+    run_euler_comparison(
+        "cheap drift/diffusion",
+        mu=cheap_drift,
+        sigma_matrix=cheap_diffusion_matrix,
+        sigma_diag=cheap_diffusion_diag,
+        simulations=simulations,
+        time_steps=time_steps,
+        n_runs=n_runs,
+    )
+
+    run_euler_comparison(
+        "normal drift/diffusion",
+        mu=normal_drift,
+        sigma_matrix=normal_diffusion_matrix,
+        sigma_diag=normal_diffusion_diag,
+        simulations=simulations,
+        time_steps=time_steps,
+        n_runs=n_runs,
+    )
+
+    run_milstein_benchmark(simulations, time_steps, n_runs=n_runs)
+
+
+if __name__ == "__main__":
+    main()

pystochastic/__init__.py

@@ -0,0 +1,7 @@
+from . import pyrandom
+from . import processes
+from . import sde
+from . import dist
+from . import montecarlo
+
+__version__ = "0.1.0"

pystochastic/dist/__init__.py

@@ -0,0 +1,25 @@
+from .dist import Distribution, Uniform, Exponential, Normal, Gamma, Beta, Weibull, Frechet, Cauchy, Gumbel, Kumaraswamy, Fisher, Pareto, Rayleigh, DiscreteDistribution, DUniform, Bernoulli, Rademacher, Binomial, Poisson, Hypergeometric, Geometric, NegativeBinomial, YuleSimon
+
+__all__ = ["Distribution",
+           "Uniform",
+           "Exponential",
+           "Normal",
+           "Gamma",
+           "Beta",
+           "Weibull",
+           "Frechet",
+           "Cauchy",
+           "Gumbel",
+           "Kumaraswamy",
+           "Fisher",
+           "Pareto",
+           "Rayleigh",
+           "DiscreteDistribution",
+           "DUniform",
+           "Bernoulli",
+           "Poisson",
+           "Hypergeometric",
+           "Geometric",
+           "NegativeBinomial",
+           "YuleSimon"
+           ]