Struct Ystep 

pub struct Ystep<T>
where
    T: TryInto<Positive> + Display + Clone,
{ /* private fields */ }

A step entity in a Y-axis progression with an associated numeric value.

Ystep represents a discrete point in a sequence, maintaining both an integer index and an associated positive numeric value. This structure is designed to be used in financial calculations, visualizations, or any context where tracking incremental steps with corresponding values is needed.

The generic parameter T allows flexibility in the type of value stored, as long as it can be converted into a Positive type, ensuring all values are valid non-negative numbers.

Type Parameters

• T - A type that can be converted into a Positive value. This ensures that all values stored in Ystep are non-negative.

Fields

• index - An integer representing the step’s position in a sequence.

• value - A positive numeric value associated with this step.

Implementations

impl<T> Ystep<T>

where T: TryInto<Positive> + Display + Clone,

A step value holder for simulation values that must be positive.

Ystep<T> maintains an index counter and a value of type T, where T must be TryInto<Positive> + Display and convertible to a Positive value.

This struct is typically used in financial simulations where values need to be tracked across simulation steps while ensuring they remain positive.

Type Parameters

• T - The value type that must be convertible to Positive

Examples

use rust_decimal_macros::dec;
use optionstratlib_simulation::simulation::steps::Ystep;

// Create a new step with initial value
let step = Ystep::new(1, dec!(10.5));

// Access the current value
assert_eq!(*step.value(), dec!(10.5));

pub fn new(index: i32, value: T) -> Self

Creates a new Ystep instance with the specified value.

The index is initialized to 0 and the provided value is stored.

Parameters

• value - The initial value to store

Returns

A new Ystep<T> instance

pub fn next(&self, value: T) -> Result<Self, SimulationError>

Creates a new step with an incremented index and the provided value.

This method produces a new step instance that represents the next step in a sequence, with an index one higher than the current step and storing the provided value.

Parameters

• value - The value to store in the new step

Returns

A new Ystep<T> instance with incremented index

Errors

Returns SimulationError::StepError when the index is already i32::MAX. The raw + 1 used here aborted in debug builds and wrapped to i32::MIN in release builds (#788).

pub fn value(&self) -> &T

Returns an immutable reference to the stored value.

Returns

A reference to the stored value of type T

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

Returns an immutable reference to the stored value.

Returns

A reference to the stored value of type T

Errors

Returns SimulationError::PositiveError when the stored y value cannot be converted to a Positive (NaN, negative, or otherwise invalid for the Positive invariant).

pub fn index(&self) -> &i32

Returns an immutable reference to the index of this step.

The index represents the step’s position in a sequence, typically indicating how many steps have occurred since initialization.

Returns

A reference to the index as an i32 value

pub fn value_mut(&mut self) -> &mut T

Returns a mutable reference to the stored value.

This allows modifying the value while maintaining the Ystep structure.

Returns

A mutable reference to the stored value of type T

Trait Implementations

impl<T> Clone for Ystep<T>

where T: TryInto<Positive> + Display + 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<T> Debug for Ystep<T>

where T: TryInto<Positive> + Display + Clone + Debug,

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

Formats the value using the given formatter.

impl<T> Display for Ystep<T>

where T: TryInto<Positive> + Display + Clone,

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

Formats the value using the given formatter.

impl<T> Serialize for Ystep<T>

where T: TryInto<Positive> + Display + Serialize + Clone,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> TryFrom<Ystep<T>> for Positive

where T: TryInto<Positive> + Display + Clone,

type Error = SimulationError

The type returned in the event of a conversion error.

fn try_from(step: Ystep<T>) -> Result<Self, Self::Error>

Performs the conversion.