Struct Accumulator 

pub struct Accumulator {

    pub side: AccumulatorSide,
    pub s0: f64,
    pub strike: f64,
    pub barrier: f64,
    pub observations: usize,
    pub t: f64,
    pub r: f64,
    pub q: f64,
    pub sigma: f64,
    pub shares_per_day: f64,
    pub gearing: f64,
    pub pricer: AccumulatorPricer,
    pub paths: usize,
    pub seed: u64,
}

An accumulator/decumulator on equally spaced daily observations.

Fields

side: AccumulatorSide

s0: f64

strike: f64

barrier: f64

observations: usize

t: f64

Year fraction to maturity.

r: f64

q: f64

sigma: f64

shares_per_day: f64

gearing: f64

pricer: AccumulatorPricer

paths: usize

seed: u64

Implementations

impl Accumulator

pub fn analytic_npv(&self) -> f64

Strip-of-barrier-options closed form (continuous knock-out monitoring). Each observation contributes a knock-out pair maturing on its date.

pub fn mc_npv(&self) -> (f64, f64)

Monte Carlo on the observation grid: discrete knock-out at each observation (the contractual daily-close convention), accrual up to but excluding the knock-out day. Deterministic per seed.

pub fn from_json(data: &AccumulatorData) -> Box<Accumulator>

Build from contract data, panicking on any invalid field. Fallible callers should use Accumulator::try_from_json.

pub fn try_from_json( data: &AccumulatorData, ) -> Result<Box<Accumulator>, RustyQLibError>

Trait Implementations

impl Clone for Accumulator

fn clone(&self) -> Accumulator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Accumulator

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

Formats the value using the given formatter.

impl Instrument for Accumulator

fn try_npv(&self) -> Result<f64, RustyQLibError>

Present value, or a typed error when the instrument cannot be priced (invalid inputs, or an engine/product combination the library refuses to price).

fn price(&self) -> Result<PricingResult, RustyQLibError>

Price the instrument once, returning value, Greeks and (for Monte Carlo engines) the standard error together in a PricingResult.

fn npv(&self) -> f64

Present value, panicking on any pricing error. Convenience for instruments already known to be valid; fallible callers (batch pricing, services) should use Instrument::try_npv.