Struct LiftedMarket 

pub struct LiftedMarket<R: Scalar> {
    values: Vec<R>,
    spans: Arc<[Span]>,
}

A market’s parameters lifted into one mode, with the layout that labels them.

Owned by the caller and borrowed by the view, which is what makes the lift free of shared mutable state: registering handles writes here, not into the market, so two threads lifting the same market never meet.

Fields

values: Vec<R>

spans: Arc<[Span]>

The layout, shared with the market it was lifted from.

Implementations

impl<R: Scalar> LiftedMarket<R>

pub fn parameters(&self) -> &[R]

The lifted parameters, end to end.

pub fn parameters_mut(&mut self) -> &mut [R]

The lifted parameters, mutably.

Substituting a caller’s own numbers is what the lift is for, so moving one here and repricing is a scenario, a bump, or a finite difference — and it still leaves the stored market alone. Do not use it on a vector that has already been registered: a registered handle’s value and its tape slot travel together, and writing through one without the other would price at a number the recording never saw.

pub fn len(&self) -> usize

How many parameters were lifted.

pub fn is_empty(&self) -> bool

Whether the market held no free parameters at all.

impl LiftedMarket<AReal<f64>>

pub fn register(&mut self, tape: &mut Tape<f64>)

Register every lifted parameter as a tape input.

The one place arming survives, and it arms the caller’s own vector rather than the market. Call it inside an open recording, before building the view.

Trait Implementations

impl<R: Clone + Scalar> Clone for LiftedMarket<R>

fn clone(&self) -> LiftedMarket<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug + Scalar> Debug for LiftedMarket<R>

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

Formats the value using the given formatter.

impl<R: PartialEq + Scalar> PartialEq for LiftedMarket<R>

fn eq(&self, other: &LiftedMarket<R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: PartialEq + Scalar> StructuralPartialEq for LiftedMarket<R>