Struct blackscholes_python::Inputs

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

The inputs to the Black-Scholes-Merton model.

Fields

option_type: OptionType

The type of the option (call or put)

s: f64

Stock price

k: f64

Strike price

p: Option<f64>

Option price

r: f64

Risk-free rate

q: f64

Dividend yield

t: f64

Time to maturity in years

sigma: Option<f64>

Volatility

Implementations

impl Inputs

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

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

Creates instance ot the Inputs struct.

Arguments

• option_type - The type of option to be priced.
• s - 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;
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, None, 0.05, 0.2, 20/365.25, Some(0.2));

Returns

An instance of the Inputs struct.

pub fn __str__(&self) -> String

Returns

string representation of the Inputs struct.

pub fn calc_price(&self) -> PyResult<f64>

Calculates the price of the option.

Requires

s, k, r, q, t, sigma.

Returns

f64 of the price of the option.

Example

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

pub fn calc_delta(&self) -> PyResult<f64>

Calculates the delta of the option.

Requires

s, k, r, q, t, sigma

Returns

f64 of the delta of the option.

Example

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

pub fn calc_gamma(&self) -> PyResult<f64>

Calculates the gamma of the option.

Requires

s, k, r, q, t, sigma

Returns

f64 of the gamma of the option.

Example

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

pub fn calc_theta(&self) -> PyResult<f64>

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

Requires

s, k, r, q, t, sigma

Returns

f64 of theta per day (not per year).

Example

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

pub fn calc_vega(&self) -> PyResult<f64>

Calculates the vega of the option.

Requires

s, k, r, q, t, sigma

Returns

f64 of the vega of the option.

Example

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

pub fn calc_rho(&self) -> PyResult<f64>

Calculates the rho of the option.

Requires

s, k, r, q, t, sigma

Returns

f64 of the rho of the option.

Example

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

pub fn calc_iv(&self, tolerance: f64) -> PyResult<f64>

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

s, k, r, q, t, p

Returns

f64 of the implied volatility of the option.

Example:

use blackscholes::Inputs;
let inputs = Inputs::new(OptionType::Call, 100.0, 100.0, Some(10), 0.05, 0.02, 20.0 / 365.25, None);
let iv = inputs.calc_iv(0.0001);

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<'_>) -> Result

Formats the value using the given formatter.

impl IntoPy<Py<PyAny>> for Inputs

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl PyClass for Inputs

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for Inputs

const DOC: &'static str = _

Class doc string

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type Layout = PyCell<Inputs>

Layout

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerStub<Inputs>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a Inputs

type Holder = Option<PyRef<'py, Inputs>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut Inputs

type Holder = Option<PyRefMut<'py, Inputs>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl PyMethods<Inputs> for PyClassImplCollector<Inputs>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for Inputs

type AsRefTarget = PyCell<Inputs>

Utility type to make Py::as_ref work.

const NAME: &'static str = _

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> &PyType

Returns the safe abstraction over the type object.

fn is_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.