Struct BarrierPayoff 

pub struct BarrierPayoff {
    pub put_or_call: PutOrCall,
    pub exercise_style: ContractStyle,
    pub direction: BarrierDirection,
    pub knock: KnockType,
    pub barrier: f64,
    pub barrier2: Option<f64>,
    pub rebate: f64,
    pub rebate_at_hit: bool,
}

Fields

put_or_call: PutOrCall

exercise_style: ContractStyle

direction: BarrierDirection

knock: KnockType

barrier: f64

barrier2: Option<f64>

Second barrier level: Some makes this a double barrier (the corridor [min, max] of the two levels; direction is ignored).

rebate: f64

Rebate paid on the knock event (knock-out) or at expiry when the option never knocks in (knock-in). Zero = no rebate.

rebate_at_hit: bool

Knock-out rebate timing: at the touch (true, analytic engine only) or at expiry (false; also the Monte Carlo convention).

Trait Implementations

impl Clone for BarrierPayoff

fn clone(&self) -> BarrierPayoff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BarrierPayoff

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

Formats the value using the given formatter.

impl Payoff for BarrierPayoff

Barrier payoff: payoff is the underlying vanilla leg (used by the analytic building blocks and as the terminal leg of path pricing); path_payoff applies discretely monitored knock logic to a full path. The Monte Carlo engine additionally applies a Brownian-bridge crossing correction, so its effective monitoring is continuous.

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

Payoff for a given level of the underlying: the terminal spot for European exercise, or the exercise spot for American.

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.