Struct StationaryLqRegulator 

pub struct StationaryLqRegulator {
    pub a: f64,
    pub b: f64,
    pub q: f64,
    pub r: f64,
    pub c: f64,
    pub rho: f64,
    pub h: f64,
    pub p: f64,
    pub d: f64,
    pub boundary_conditions: BoundaryConditions<1>,
}

Infinite-horizon scalar linear-quadratic regulator with constant coefficients.

See the module-level documentation for the formulation and exact solution.

Fields

a: f64

State-drift coefficient a.

b: f64

Control-input coefficient b.

q: f64

Running state cost q.

r: f64

Running control cost r.

c: f64

Diffusion coefficient c.

rho: f64

Discount rate rho.

h: f64

Grid spacing h used by the finite-difference transport stencil.

p: f64

Positive algebraic Riccati solution P.

d: f64

Noise-induced additive correction d = c^2 P / rho.

boundary_conditions: BoundaryConditions<1>

Boundary conditions for the stationary solve.

Implementations

impl StationaryLqRegulator

pub fn new(a: f64, b: f64, q: f64, r: f64, c: f64, rho: f64, h: f64) -> Self

Creates a stationary LQ regulator.

Panics

Panics if r, q, rho, or h is not positive, or if the scalar algebraic Riccati equation has no positive real root.

Examples

use solver::models::stationary_lq::StationaryLqRegulator;
let lq = StationaryLqRegulator::new(-1.0, 1.0, 1.0, 1.0, 0.0, 0.1, 0.1);
assert!(lq.p > 0.0);

pub fn with_h(self, h: f64) -> Self

Sets the grid spacing used by the transport stencil.

Examples

use solver::models::stationary_lq::StationaryLqRegulator;
let lq = StationaryLqRegulator::new(-1.0, 1.0, 1.0, 1.0, 0.0, 0.1, 0.1).with_h(0.05);
assert_eq!(lq.h, 0.05);

pub fn with_boundary_conditions( self, boundary_conditions: BoundaryConditions<1>, ) -> Self

Sets the boundary conditions used by the stationary solve.

Examples

use solver::models::stationary_lq::StationaryLqRegulator;
use solver::numeric::finite_difference::discretization::{
    BoundaryCondition, BoundaryConditions,
};
let lq = StationaryLqRegulator::new(-1.0, 1.0, 1.0, 1.0, 0.0, 0.1, 0.1)
    .with_boundary_conditions(BoundaryConditions::new(
        [BoundaryCondition::Dirichlet(0.0)],
        [BoundaryCondition::Dirichlet(0.0)],
    ));
assert!(matches!(lq.boundary_conditions.lower[0], BoundaryCondition::Dirichlet(_)));

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

Exact stationary value V(x) = -P x^2 - d.

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

Exact stationary control u*(x) = -(b / r) P x.

pub fn exact_boundary_conditions(&self, grid: &Grid<1>) -> BoundaryConditions<1>

Dirichlet boundary conditions matching the exact value at the grid endpoints.

Trait Implementations

impl Clone for StationaryLqRegulator

fn clone(&self) -> StationaryLqRegulator

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ControlProblem<1> for StationaryLqRegulator

type Control = f64

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>, ) -> Self::Control

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

fn running_reward( &self, _t: f64, state: &[f64; 1], control: &Self::Control, ) -> f64

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

fn generator( &self, _t: f64, state: &[f64; 1], control: &Self::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 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 gradient_step(&self, _dim: usize) -> f64

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

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 apply_constraint(&self, _state: &[f64; N], value: f64) -> f64

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

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

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

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.

impl Debug for StationaryLqRegulator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl EllipticControlProblem<1> for StationaryLqRegulator

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

Discretization kind for dim.

fn transport( &self, state: &[f64; 1], control: &Self::Control, derivs: &StateDerivatives<1>, ) -> Transport<1>

Transport coefficients and residual source for the given control and derivatives.

fn boundary_conditions(&self) -> BoundaryConditions<1>

Boundary conditions for each dimension.