---
title: Quickstart
description: A 5-minute end-to-end tour — simulate an OU path, price a Heston call, and run a Hurst estimator. Same code shown in Rust and Python side by side.
category: tutorial
since: 2.0.0
status: stable
---
# Quickstart
Three vignettes, each shown in Rust and Python. Pick whichever language
you are working in — the API surface is intentionally close.
## 1. Simulate an OU path
The Ornstein-Uhlenbeck process
$$ dX_t = \theta(\mu - X_t)\,dt + \sigma\,dW_t,\quad X_0 = x_0 $$
with $\theta = 2$, $\mu = 0$, $\sigma = 1$, $X_0 = 0$, on $t \in [0, 1]$
with 1000 steps:
### Rust
```rust
use stochastic_rs::prelude::*;
use stochastic_rs::stochastic::diffusion::ou::Ou;
fn main() {
let p = Ou::<f64>::new(2.0, 0.0, 1.0, 1_000, Some(0.0), Some(1.0));
let path = p.sample();
println!("len = {}, mean = {:.3}", path.len(), path.mean().unwrap());
}
```
### Python
```python
import stochastic_rs as srs
p = srs.Ou(theta=2.0, mu=0.0, sigma=1.0, n=1000, x0=0.0, t=1.0)
path = p.sample()
print("len =", path.shape[0], "mean =", path.mean())
```
For the API contract see the [Processes catalog](/docs/processes).
## 2. Price a Heston European call
The Heston model is the workhorse stochastic-volatility model. The
Fourier pricer uses Cui's analytic Jacobian for fast and stable
characteristic-function evaluation.
### Rust
```rust
use stochastic_rs::prelude::*;
use stochastic_rs::quant::pricing::heston::HestonPricer;
use stochastic_rs::quant::types::OptionType;
fn main() {
let pricer = HestonPricer::<f64>::new(
/* s0 */ 100.0, /* k */ 100.0, /* tau */ 1.0,
/* r */ 0.03, /* q */ 0.0,
/* v0 */ 0.04, /* kappa */ 2.0, /* theta */ 0.04,
/* sigma */ 0.3, /* rho */ -0.5,
);
let price = pricer.price(OptionType::Call);
let greeks = pricer.greeks(OptionType::Call);
println!("call = {:.4}, delta = {:.4}, vega = {:.4}",
price, greeks.delta, greeks.vega);
}
```
### Python
```python
import stochastic_rs as srs
pricer = srs.HestonPricer(
s0=100, k=100, tau=1.0, r=0.03, q=0.0,
v0=0.04, kappa=2.0, theta=0.04, sigma=0.3, rho=-0.5,
)
price = pricer.price("call")
greeks = pricer.greeks("call")
print(f"call={price:.4f}, delta={greeks.delta:.4f}, vega={greeks.vega:.4f}")
```
## 3. Estimate Hurst from a fractional-Brownian path
The Fukasawa estimator gives a strongly consistent Hurst estimate from
high-frequency increments. It is the recommended estimator for empirical
roughness studies.
### Rust
```rust
use stochastic_rs::prelude::*;
use stochastic_rs::stochastic::noise::fgn::Fgn;
use stochastic_rs::stats::fukasawa_hurst::FukasawaHurst;
fn main() {
let fgn = Fgn::<f64>::new(0.3, 1.0, 4096, Some(1.0));
let path = fgn.sample();
let est = FukasawaHurst::<f64>::new().estimate(path.view());
println!("H = {:.3} ± {:.3}", est.point, est.se);
}
```
### Python
```python
import stochastic_rs as srs
fgn = srs.Fgn(hurst=0.3, sigma=1.0, n=4096, t=1.0)
path = fgn.sample()
est = srs.fukasawa_hurst(path)
print(f"H = {est.point:.3f} ± {est.se:.3f}")
```
## Where next
- [Concepts: traits & prelude](/docs/concepts/traits) — the trait surface
is the single most important thing to internalise.
- [Quant catalog](/docs/quant) — pricing, calibration, vol surface, risk.
- [Python bindings](/docs/python) — full parity table.