Struct black76::Inputs

pub struct Inputs {
    pub option_type: OptionType,
    pub f: f32,
    pub k: f32,
    pub p: Option<f32>,
    pub r: f32,
    pub q: f32,
    pub t: f32,
    pub sigma: Option<f32>,
}

The inputs to the Black-Scholes-Merton model.

Fields

option_type: OptionType

The type of the option (call or put)

f: f32

Futures price

k: f32

Strike price

p: Option<f32>

Option price

r: f32

Risk-free rate

q: f32

Dividend yield

t: f32

Time to maturity in years

sigma: Option<f32>

Volatility

Implementations

impl Inputs

Methods for calculating the price, greeks, and implied volatility of an option.

pub fn new( option_type: OptionType, f: f32, k: f32, p: Option<f32>, r: f32, q: f32, t: f32, sigma: Option<f32> ) -> Self

Creates instance ot the Inputs struct.

Arguments

• option_type - The type of option to be priced.
• f - The current price of the underlying asset.
• k - The strike price of the option.
• p - The dividend yield of the underlying asset.
• r - The risk-free interest rate.
• q - The dividend yield of the underlying asset.
• t - The time to maturity of the option in years.
• sigma - The volatility of the underlying asset.

Example

use blackscholes::{Inputs, OptionType};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));

Returns

An instance of the Inputs struct.

Trait Implementations

impl Clone for Inputs

fn clone(&self) -> Inputs

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Inputs

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

Formats the value using the given formatter.

impl Display for Inputs

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

Formats the value using the given formatter.

impl Greeks<f32> for Inputs

Note:

The only verified formulas are for the delta, vega, theta, rho, gamma, vanna, and vomma, sourced from here. The remaining greeks were sourced from the same page, with r swapped for q. If you find that any of these formulas are incorrect, please open an issue on the github repo.

fn calc_delta(&self) -> Result<f32, String>

Calculates the delta of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the delta of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let delta = inputs.calc_delta().unwrap();

fn calc_gamma(&self) -> Result<f32, String>

Calculates the gamma of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the gamma of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let gamma = inputs.calc_gamma().unwrap();

fn calc_theta(&self) -> Result<f32, String>

Calculates the theta of the option. Uses 365.25 days in a year for calculations.

Requires

f, k, r, t, sigma

Returns

f32 of theta per day (not per year).

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let theta = inputs.calc_theta().unwrap();

fn calc_vega(&self) -> Result<f32, String>

Calculates the vega of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the vega of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let vega = inputs.calc_vega().unwrap();

fn calc_rho(&self) -> Result<f32, String>

Calculates the rho of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the rho of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let rho = inputs.calc_rho().unwrap();

fn calc_epsilon(&self) -> Result<f32, String>

Calculates the epsilon of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the epsilon of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let epsilon = inputs.calc_epsilon().unwrap();

fn calc_lambda(&self) -> Result<f32, String>

Calculates the lambda of the option.

Requires

s, k, r, q, t, sigma

Returns

f32 of the lambda of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks, Pricing};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let lambda = inputs.calc_lambda().unwrap();

fn calc_vanna(&self) -> Result<f32, String>

Calculates the vanna of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the vanna of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let vanna = inputs.calc_vanna().unwrap();

fn calc_charm(&self) -> Result<f32, String>

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let charm = inputs.calc_charm().unwrap();

fn calc_veta(&self) -> Result<f32, String>

Calculates the veta of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the veta of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let veta = inputs.calc_veta().unwrap();

fn calc_vomma(&self) -> Result<f32, String>

Calculates the vomma of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the vomma of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let vomma = inputs.calc_vomma().unwrap();

fn calc_speed(&self) -> Result<f32, String>

Calculates the speed of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the speed of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let speed = inputs.calc_speed().unwrap();

fn calc_zomma(&self) -> Result<f32, String>

Calculates the zomma of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the zomma of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let zomma = inputs.calc_zomma().unwrap();

fn calc_color(&self) -> Result<f32, String>

Calculates the color of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the color of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let color = inputs.calc_color().unwrap();

fn calc_ultima(&self) -> Result<f32, String>

Calculates the ultima of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the ultima of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let ultima = inputs.calc_ultima().unwrap();

fn calc_dual_delta(&self) -> Result<f32, String>

Calculates the dual delta of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the dual delta of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let dual_delta = inputs.calc_dual_delta().unwrap();

fn calc_dual_gamma(&self) -> Result<f32, String>

Calculates the dual gamma of the option.

Requires

f, k, r, t, sigma

Returns

f32 of the dual gamma of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let dual_gamma = inputs.calc_dual_gamma().unwrap();

fn calc_all_greeks(&self) -> Result<HashMap<String, f32>, String>

Calculates all Greeks of the option.

Requires

f, k, r, t, sigma

Returns

HashMap of type <String, f32> of all Greeks of the option.

Example

use blackscholes::{Inputs, OptionType, Greeks};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let greeks = inputs.calc_all_greeks().unwrap();

impl ImpliedVolatility<f32> for Inputs

fn calc_iv(&self, tolerance: f32) -> Result<f32, String>

Calculates the implied volatility of the option. Tolerance is the max error allowed for the implied volatility, the lower the tolerance the more iterations will be required. Recommended to be a value between 0.001 - 0.0001 for highest efficiency/accuracy. Initializes estimation of sigma using Brenn and Subrahmanyam (1998) method of calculating initial iv estimation. Uses Newton Raphson algorithm to calculate implied volatility.

Requires

f, k, r, q, t, p

Returns

f32 of the implied volatility of the option.

Example:

use blackscholes::{Inputs, OptionType, ImpliedVolatility};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, Some(0.2), 0.05, 0.2, 20.0/365.25, None);
let iv = inputs.calc_iv(0.0001).unwrap();

impl PartialEq<Inputs> for Inputs

fn eq(&self, other: &Inputs) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Pricing<f32> for Inputs

fn calc_price(&self) -> Result<f32, String>

Calculates the price of the option.

Requires

f, k, r, q, t, sigma.

Returns

f32 of the price of the option.

Example

use blackscholes::{Inputs, OptionType, Pricing};
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20.0/365.25, Some(0.2));
let price = inputs.calc_price().unwrap();

impl Copy for Inputs

impl StructuralPartialEq for Inputs