Struct StepTrailingStop 

pub struct StepTrailingStop { /* private fields */ }

Step Trailing Stop — a stop that ratchets in fixed-size discrete steps and flips to the opposite side on a close-through.

long:   target = close − step_size
        stop_t = max(stop_{t−1}, floor(target / step_size) · step_size)
                 while close ≥ stop_{t−1}
short:  target = close + step_size
        stop_t = min(stop_{t−1}, ceil(target / step_size) · step_size)
                 while close ≤ stop_{t−1}
flip-to-long  on close > prev short-stop -> stop = floor((close − step) / step) · step
flip-to-short on close < prev long-stop  -> stop = ceil((close + step) / step) · step

Quantising the stop to a multiple of step_size keeps the level on a round-number grid, which mirrors how many discretionary traders move stops by hand (in $0.50, $1, or 10-pip increments). The first input seeds a long stop one step below the snapped close.

Example

use wickra_core::{Indicator, StepTrailingStop};

let mut indicator = StepTrailingStop::new(1.0).unwrap();
let mut last = None;
for i in 0..20 {
    last = indicator.update(100.0 + f64::from(i));
}
assert!(last.is_some());

Implementations

impl StepTrailingStop

pub fn new(step_size: f64) -> Result<Self>

Construct a Step Trailing Stop with an explicit step size.

Errors

Returns Error::NonPositiveMultiplier if step_size is not strictly positive and finite.

pub fn classic() -> Self

A common configuration: a 1.0 step size.

pub const fn step_size(&self) -> f64

Configured step size.

Trait Implementations

impl Clone for StepTrailingStop

fn clone(&self) -> StepTrailingStop

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StepTrailingStop

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

Formats the value using the given formatter.

impl Indicator for StepTrailingStop

type Input = f64

Type of one input data point (typically f64 for a price, or Candle / Tick).

type Output = f64

Type of one output value.

fn update(&mut self, close: f64) -> Option<f64>

Feed one new data point into the indicator and return the freshly computed output, or None if the indicator is still warming up.

fn reset(&mut self)

Reset all internal state, leaving the indicator equivalent to a freshly constructed instance with the same parameters.

fn warmup_period(&self) -> usize

Number of inputs required before the first non-None output can be produced.

fn is_ready(&self) -> bool

Whether the indicator has emitted at least one value since the last reset.

fn name(&self) -> &'static str

Stable, human-readable indicator name. Used by chaining and diagnostics.