Struct AmericanPut 

pub struct AmericanPut {
    pub risk_free_rate: f64,
    pub volatility: f64,
    pub strike: f64,
    pub dx: f64,
}

American Put Option

Models the optimal exercise strategy for an American Put option. This is formulated as an optimal stopping problem, but can be solved via HJB by treating the exercise decision as a control.

Dynamics follow Geometric Brownian Motion for the underlying asset.

Fields

risk_free_rate: f64

Risk-free interest rate (r).

volatility: f64

Volatility of the underlying asset ($\sigma$).

strike: f64

Strike price (K).

dx: f64

Spatial discretization step size (dx) used for finite difference coefficients.

Implementations

impl AmericanPut

pub fn new(risk_free_rate: f64, volatility: f64, strike: f64, dx: f64) -> Self

Creates an American put model.

Examples

use solver::models::american_put::AmericanPut;
let put = AmericanPut::new(0.05, 0.2, 100.0, 1.0);
assert_eq!(put.strike, 100.0);

pub fn set_dx(&mut self, dx: f64)

Updates the spatial step size used by the finite-difference transport coefficients.

Examples

use solver::models::american_put::AmericanPut;
let mut put = AmericanPut::new(0.05, 0.2, 100.0, 1.0);
put.set_dx(0.5);
assert_eq!(put.dx, 0.5);

Trait Implementations

impl ControlProblem<1> for AmericanPut

type Control = ()

The action type. For Merton this is a scalar portfolio fraction; for market making it is a pair of bid/ask intensities.

fn optimize(&self, _t: f64, _state: &[f64; 1], _derivs: &StateDerivatives<1>)

Returns the control that maximizes the driver at (t, state).

fn running_reward(&self, _t: f64, _state: &[f64; 1], _control: &()) -> f64

Returns the running reward f(t,x,u).

fn generator( &self, _t: f64, state: &[f64; 1], _control: &(), derivs: &StateDerivatives<1>, ) -> f64

Returns the infinitesimal generator L^u V for the given control and derivative bundle.

fn terminal(&self, state: &[f64; 1]) -> f64

Terminal value g(x) at the horizon.

fn discount_rate(&self, _state: &[f64; 1]) -> f64

Discount rate r(t,x). Defaults to zero.

fn constant_discount_rate(&self) -> Option<f64>

Constant discount rate hint. Defaults to None (state dependent).

fn apply_constraint(&self, state: &[f64; 1], value: f64) -> f64

Optional pointwise constraint on the value, e.g. the early-exercise obstacle V >= payoff for an American option.

fn next_step( &self, _t: f64, state: &[f64; 1], dt: f64, noise: &[f64; 1], ) -> [f64; 1]

Advances the state one step under the optimal control at forward time t.

fn is_diffusion_dimension(&self, _dim: usize) -> bool

Whether a dimension is driven by Brownian diffusion.

fn driver( &self, t: f64, state: &[f64; N], control: &Self::Control, derivs: &StateDerivatives<N>, ) -> f64

Returns the full HJB driver f(t,x,u) + L^u V.

fn bsde_driver( &self, t: f64, state: &[f64; N], control: &Self::Control, _derivs: &StateDerivatives<N>, _dt: f64, ) -> f64

Returns the backward driver consumed by the BSDE regression solver.

fn next_step_controlled( &self, t: f64, state: &[f64; N], _control: &Self::Control, dt: f64, noise: &[f64; N], ) -> [f64; N]

Advances the state one step under an explicitly supplied control.

fn is_reduced_value(&self) -> bool

Whether the value this problem solves is a reduced value.

fn gradient_step(&self, _dim: usize) -> f64

Physical finite-difference step for a dimension, used by mesh-free gradient stencils.

impl PdeProblem<1> for AmericanPut

fn dimension_kind(&self, _dim: usize) -> DimensionKind

Discretization kind for dim.

fn transport( &self, _t: f64, state: &[f64; 1], _control: &(), _derivs: &StateDerivatives<1>, ) -> Transport<1>

Transport and local source for the given control and derivatives.

fn jump_kernel( &self, _t: f64, _state: &[f64; N], _control: &Self::Control, _derivs: &StateDerivatives<N>, transport: &Transport<N>, ) -> JumpKernel<N>

Jump kernel for arbitrary-amplitude jump dimensions.