Struct AccumulatorPayoff 

pub struct AccumulatorPayoff {
    pub exercise_style: ContractStyle,
    pub side: AccumulatorSide,
    pub barrier: f64,
    pub observations: usize,
    pub shares_per_day: f64,
    pub gearing: f64,
}

The accumulator as a mainline [Payoff], pricing inside EquityOption on the shared Monte Carlo engine (GBM, local vol and Heston via QE-M) — which gives it the market context for free: snapshot_market/npv_in rebinding, portfolio membership and the stress runner. The strike is the contract’s strike_price; spot, curve and surface come from the bound market. The standalone Accumulator remains the closed-form (continuously monitored) validation reference.

Cash flows land on their own observation dates, so like AutocallablePayoff it is valued per path through path_value with per-date discount factors, not through path_payoff.

Fields

exercise_style: ContractStyle

side: AccumulatorSide

barrier: f64

Knock-out level (above spot for accumulators, below for decumulators; enforced at build).

observations: usize

Equally spaced observation days over the life (last = maturity).

shares_per_day: f64

gearing: f64

Quantity multiplier on the adverse side (2 = classic double-up).

Implementations

impl AccumulatorPayoff

pub fn path_value( &self, path: &[f64], obs_idx: &[usize], dfs: &[f64], strike: f64, ) -> f64

Value of one simulated path: daily accrual q [ (S_i - K)+ - gearing (K - S_i)+ ] (mirrored for decumulators), each day discounted on its own date, stopping — without accruing — on the first observation at or through the knock-out. obs_idx maps observation m to its path step; dfs[m] discounts its date.

Trait Implementations

impl Clone for AccumulatorPayoff

fn clone(&self) -> AccumulatorPayoff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AccumulatorPayoff

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

Formats the value using the given formatter.

impl Payoff for AccumulatorPayoff

fn payoff(&self, _spot: f64, _strike: f64) -> f64

Degenerate single-point value: zero (all value is schedule- and path-dependent).

fn path_payoff(&self, _path: &[f64], _strike: f64) -> f64

Payoff for a full simulated path (used by Monte Carlo). Terminal payoffs default to the last point; Asian/Barrier override this. The path excludes the initial spot (it starts at the first step).

fn is_path_dependent(&self) -> bool

True when the payoff depends on the whole path (Asian, Barrier), so engines must simulate paths rather than terminal values.

fn payoff_kind(&self) -> PayoffType

fn put_or_call(&self) -> &PutOrCall

fn exercise_style(&self) -> &ContractStyle

fn as_any(&self) -> &dyn Any

Downcast hook so pricers that need payoff-specific details (e.g. the analytic pricer distinguishing cash- from asset-or-nothing binaries) can recover the concrete payoff type.

fn clone_box(&self) -> Box<dyn Payoff>

Clone through the trait object, so instruments holding a Box<dyn Payoff> are cloneable (repricing a contract under another market clones the instrument). Implementors write Box::new(self.clone()).

fn payoff_amount(&self, spot: f64, strike: f64) -> f64

Intrinsic value at the given spot (the option’s current market spot at its contract strike).

fn path_payoff_var<'t>( &self, _path: &[Var<'t>], _strike: f64, ) -> Option<Var<'t>>

Path payoff in AAD arithmetic — the mirror of path_payoff over tape variables, used by the adjoint Monte Carlo Greeks (montecarlo::aad_greeks). None (the default) opts a payoff out: discontinuous payoffs (barrier, binary, autocallable) must stay out, because the almost-everywhere derivative of an indicator is zero — their Greeks come from the bump stencils instead.