Struct FxForward 

pub struct FxForward {
    pub base: Currency,
    pub quote: Currency,
    pub base_amount: f64,
    pub quote_amount: f64,
    pub value_date: NaiveDate,
    pub settlement: Settlement,
    pub base_collateral: CollateralSpec,
    pub quote_collateral: CollateralSpec,
}

An outright FX forward.

Fields

base: Currency

The base currency — the one unit being priced.

quote: Currency

The quote currency — what one unit of base costs.

base_amount: f64

Signed base-currency amount; positive receives (buys) base.

quote_amount: f64

Signed quote-currency amount, opposite in sign to base_amount.

value_date: NaiveDate

The exchange (settlement) date.

settlement: Settlement

Physical or cash settlement.

base_collateral: CollateralSpec

The collateral key the base-currency leg discounts under.

quote_collateral: CollateralSpec

The collateral key the quote-currency leg discounts under.

Implementations

impl FxForward

pub fn new( base: Currency, quote: Currency, base_amount: f64, contract_rate: f64, value_date: NaiveDate, ) -> Self

A physically settled forward buying base_amount of base (selling when negative) against base_amount·contract_rate of quote on value_date, each leg discounting on its own currency’s cash collateral.

pub fn contract_rate(&self) -> f64

The contract rate, quote per one base.

pub fn cash_settled( self, index: impl Into<FixingSource>, fixing_date: NaiveDate, settle: Currency, ) -> Result<Self, FxError>

This forward cash-settled at index’s fixing on fixing_date, paid in settle. index is one FX key or a FixingSource cross.

The leg that is never paid discounts on its offshore curve, {CCY}-CSA-USD — the dollar-collateralised curve NDF outrights mark — and the settlement leg on its own; a later with_collateral still overrides.

Errors

FxError::SettlementOutsidePair if settle is neither currency; FxError::SourceOutsidePair for a cross that does not fix this pair’s quote per base in its base.

pub fn with_collateral( self, base: CollateralSpec, quote: CollateralSpec, ) -> Self

This forward with both legs discounting under the given collateral keys.

pub fn reoriented(&self) -> Self

The same forward quoted the other way round: the quote currency as base, each amount and collateral key kept with its currency, the settlement unchanged — a cash settlement’s key or cross is read inverted for it (FixingsView::observe_for_pair).

pub fn reversed(&self) -> Self

The forward with both amounts negated — the other side of the trade.

Trait Implementations

impl Clone for FxForward

fn clone(&self) -> FxForward

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FxForward

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

Formats the value using the given formatter.

impl PartialEq for FxForward

fn eq(&self, other: &FxForward) -> 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: Scalar> Priceable<R> for FxForward

fn npv(&self, view: &PricingView<'_, R>) -> Result<R, PricingError>

Value in currency: for a physical forward, the base leg converted at spot plus the quote leg, each discounted on its own curve, in the quote currency; for a cash-settled forward, the net at the fixing — published if its date has passed or has printed today, else the parity forward — paid and valued in the settlement currency.

fn par_rate(&self, _view: &PricingView<'_, R>) -> Result<R, PricingError>

The par rate — the fixed rate at which the product is worth nothing.

fn par_spread(&self, _view: &PricingView<'_, R>) -> Result<R, PricingError>

The par (breakeven) floating-leg spread. Zero for a product with no floating leg.

impl PricingRiskFactors for FxForward

fn risk_factors(&self) -> Result<RiskFactors<'_>, PricingError>

The market data this product is priced against.

impl Product for FxForward

fn currency(&self) -> Currency

The currency the product pays in. An FX product values in its quote currency; a book converts.

fn contract_dates(&self) -> Vec<(&'static str, NaiveDate)>

The contract dates the product resolved to, as (name, date) pairs — exactly the dates its stated constructor takes, so a product built through a derived form can be read back and rebuilt through the stated one. Empty for a product with no stated form. No default: every product states which it is — see AnyInstrument::contract_dates.

fn legs(&self) -> Option<Vec<&Leg>>

The legs the product itself holds, in a declared order, or None for a product that holds none — see AnyInstrument::legs. No default: every product states which it is.

fn final_payment_date(&self) -> Option<NaiveDate>

The date of the product’s final payment, where a calibration rung can be built on it; None for a product no ladder is built from.

fn restruck_at_rate(&self, _rate: f64) -> Option<AnyInstrument>

This product re-struck at the par rate rate — the scalar a par calibration rung on it is quoted in — or None for a product that carries no such scalar. What a quote scenario moves a rung to.

fn restruck_at_spread(&self, _spread: f64) -> Option<AnyInstrument>

This product re-struck at the basis spread spread on its spread leg, or None for a product that quotes none.

impl StructuralPartialEq for FxForward