elworthy 0.1.0

A Rust JIT compiler that specialises Bismut-Elworthy-Li formulas into SIMD kernels for unbiased Monte Carlo Greeks on non-stationary SDEs.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! elworthy CLI entry point.

use clap::{Parser, Subcommand};
use elworthy_expr::Expr;
use elworthy_rt::{euler_scalar_interp, euler_scalar_jit, euler_scalar_jit_delta_bel};

#[derive(Parser)]
#[command(name = "elworthy", about = "Bismut-Elworthy-Li JIT Monte Carlo")]
struct Cli {
    #[command(subcommand)]
    command: Cmd,
}

#[derive(Subcommand)]
enum Cmd {
    /// Scalar Euler-Maruyama check on geometric Brownian motion.
    Gbm {
        #[arg(long, default_value_t = 0.05)]
        r: f64,
        #[arg(long, default_value_t = 0.2)]
        sigma: f64,
        #[arg(long, default_value_t = 100.0)]
        x0: f64,
        #[arg(long, default_value_t = 1.0)]
        t: f64,
        #[arg(long, default_value_t = 256)]
        steps: usize,
        #[arg(long, default_value_t = 10_000)]
        paths: usize,
        #[arg(long, default_value_t = 42)]
        seed: u64,
        /// Execution backend: "jit" or "interp".
        #[arg(long, default_value = "jit")]
        backend: String,
    },
    /// Price and Bismut-Elworthy-Li delta on geometric Brownian motion.
    GbmDelta {
        #[arg(long, default_value_t = 0.05)]
        r: f64,
        #[arg(long, default_value_t = 0.2)]
        sigma: f64,
        #[arg(long, default_value_t = 100.0)]
        x0: f64,
        #[arg(long, default_value_t = 1.0)]
        t: f64,
        #[arg(long, default_value_t = 256)]
        steps: usize,
        #[arg(long, default_value_t = 40_000)]
        paths: usize,
        #[arg(long, default_value_t = 1234)]
        seed: u64,
    },
}

fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt::init();
    let cli = Cli::parse();

    match cli.command {
        Cmd::Gbm {
            r,
            sigma,
            x0,
            t,
            steps,
            paths,
            seed,
            backend,
        } => {
            let mu = Expr::param(0) * Expr::state(0);
            let sig = Expr::param(1) * Expr::state(0);
            let payoff = Expr::state(0);
            let est = match backend.as_str() {
                "interp" => {
                    euler_scalar_interp(&mu, &sig, &payoff, &[r, sigma], x0, t, steps, paths, seed)
                }
                "jit" => {
                    euler_scalar_jit(&mu, &sig, &payoff, &[r, sigma], x0, t, steps, paths, seed)?
                }
                other => anyhow::bail!("unknown backend '{other}' (use 'jit' or 'interp')"),
            };
            println!(
                "[{backend}] E[X_T] ~ {:.4} (stderr {:.4}) | closed form {:.4}",
                est.mean,
                est.stderr,
                x0 * (r * t).exp(),
            );
        }
        Cmd::GbmDelta {
            r,
            sigma,
            x0,
            t,
            steps,
            paths,
            seed,
        } => {
            let mu = Expr::param(0) * Expr::state(0);
            let sig = Expr::param(1) * Expr::state(0);
            let payoff = Expr::state(0);
            // sigma(X_0) for GBM is sigma * x0.
            let sigma_at_x0 = sigma * x0;
            let out = euler_scalar_jit_delta_bel(
                &mu,
                &sig,
                &payoff,
                &[r, sigma],
                x0,
                t,
                sigma_at_x0,
                steps,
                paths,
                seed,
            )?;
            let analytic_price = x0 * (r * t).exp();
            let analytic_delta = (r * t).exp();
            println!(
                "price   ~ {:.4} (stderr {:.4}) | closed form {:.4}",
                out.price.mean, out.price.stderr, analytic_price
            );
            println!(
                "delta   ~ {:.4} (stderr {:.4}) | closed form {:.4}   [Bismut-Elworthy-Li]",
                out.delta.mean, out.delta.stderr, analytic_delta
            );
        }
    }
    Ok(())
}