Struct WalkParams 

pub struct WalkParams<X, Y>
where
    X: Copy + TryInto<Positive> + AddAssign + Display + Sized,
    Y: TryInto<Positive> + Display + Sized + Clone,
{
    pub size: usize,
    pub init_step: Step<X, Y>,
    pub walk_type: WalkType,
    pub walker: Box<dyn WalkTypeAble<X, Y>>,
    pub seed: Option<u64>,
}

Parameters for stochastic process simulations (random walks).

This struct defines the configuration for generating random walks or price path simulations, particularly useful in financial modeling, option pricing, and risk analysis contexts.

The generic parameters allow flexibility in the types of steps and values used in the walk, with appropriate trait bounds to ensure mathematical operations can be performed correctly.

Type Parameters

• X - The type for the x-axis steps (typically time), must support addition and conversion to positive values
• Y - The type for the y-axis values (typically price or rate), must support addition, conversion to positive values, and implement the Walktypable trait for traversal operations

Fields

• size - Number of steps or data points to generate in the simulation
• init_step - Initial step values (starting point) for the random walk
• walk_type - The specific stochastic process algorithm to use for the simulation
• walker - Implementation of the walk algorithm that satisfies the WalkTypeAble trait
• seed - Optional seed for the walk’s random stream; None draws from the thread RNG

Seeding

With seed: None every stochastic walk draws its normal samples from the thread-local RNG (rand::rng()), so two runs differ. With seed: Some(s) the built-in walk kernels draw from optionstratlib_core::utils::deterministic_rng(s) instead, one generator per generated path, so the same parameters and seed produce the same path bit for bit on every run with a given version of rand and rand_distr. That is the scope of the promise: StdRng and StandardNormal may change their streams across releases, and a dependency bump that does so is a reviewed change of the pinned fixtures, not a silent one. WalkType::Historical replays its prices and ignores the seed. A walker that overrides a walk method owns its own randomness and decides whether to honour seed.

crate::simulation::simulator::Simulator::new derives a distinct seed for each of its walks from this one, so a seeded simulator is reproducible without every walk repeating the same path.

Usage

This struct is typically instantiated at the beginning of a simulation process to configure how random walks will be generated. It provides the foundation for various financial simulations including price path forecasting, Monte Carlo simulations for options pricing, and risk analysis models.

Fields

size: usize

Number of steps or data points to generate in the simulation Determines the resolution and length of the resulting random walk

init_step: Step<X, Y>

Initial step values (starting point) for the random walk Typically represents initial time and price/rate values

walk_type: WalkType

The specific stochastic process to use for generating the random walk Determines the mathematical properties and behavior of the simulated path

walker: Box<dyn WalkTypeAble<X, Y>>

Implementation of the walk algorithm that satisfies the WalkTypeAble trait Provides the concrete logic for generating steps according to the selected walk_type

seed: Option<u64>

Seed of the walk’s random stream. None draws from the thread RNG (non-reproducible); Some(seed) makes every stochastic built-in walk reproducible bit for bit for a given rand / rand_distr version. See the struct-level “Seeding” section.

Implementations

impl<X, Y> WalkParams<X, Y>

where X: Copy + TryInto<Positive> + AddAssign + Display + Sized, Y: TryInto<Positive> + Display + Sized + Clone,

Access methods for the initial y-axis step value.

These methods provide different ways to access and utilize the initial value of the y-axis step, which is typically associated with the starting price or other relevant metric in a financial simulation. The y value is wrapped in a Ystep<Y> which keeps track of the step index and ensures the value can be converted to a positive number.

pub fn y(&self) -> &Y

Returns an immutable reference to the initial y-axis value.

This provides direct access to the underlying value without copying.

Returns

An immutable reference to the initial y-axis value of type &Y.

pub fn ystep_ref(&self) -> &Ystep<Y>

Returns an immutable reference to the Ystep<Y> object.

This allows access to the full Ystep functionality, including the step index.

Returns

An immutable reference to the initial Ystep<Y> object.

pub fn ystep(&self) -> Ystep<Y>

Returns a copy of the Ystep<Y> object.

This creates a new independent copy of the Ystep.

Returns

A copy of the initial Ystep<Y> object.

pub fn ystep_as_positive(&self) -> Result<Positive, SimulationError>

Returns the initial y-axis step value as a Positive number.

This ensures the value is positive, which is often a requirement in financial calculations.

Returns

The initial y-axis value as a Positive number.

Errors

Propagates any SimulationError returned by Ystep::positive (typically SimulationError::PositiveError when the current y value breaches the Positive invariant).

Trait Implementations

impl<X, Y> Clone for WalkParams<X, Y>

where X: Copy + TryInto<Positive> + AddAssign + Display + Sized + Clone, Y: TryInto<Positive> + Display + Sized + Clone + Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<X, Y> Debug for WalkParams<X, Y>

where X: Copy + TryInto<Positive> + AddAssign + Display + Sized + Debug, Y: TryInto<Positive> + Display + Sized + Clone + Debug,

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

Formats the value using the given formatter.

impl<X, Y> Display for WalkParams<X, Y>

where X: Copy + TryInto<Positive> + AddAssign + Display, Y: TryInto<Positive> + Display + Clone,

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

Formats the value using the given formatter.