The hardware and bandwidth for this mirror is donated by dogado GmbH, the Webhosting and Full Service-Cloud Provider. Check out our Wordpress Tutorial.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]dogado.de.

European options and Greeks

library(greeks)

European options can be exercised only at maturity. In the Black-Scholes model, the package computes their prices and sensitivities with closed formulas through BS_European_Greeks(). The generic Greeks() wrapper dispatches to the same implementation when option_type = "European" and model = "Black_Scholes".

The examples below are compact versions of the checks used in the test suite: they compute a few Greeks directly, check one Greek with a finite difference, and compare exact Black-Scholes values with the Malliavin Monte Carlo estimator.

Exact Black-Scholes values

The greek argument can contain more than one quantity. The result is a named numeric vector.

european_put <- BS_European_Greeks(
  initial_price = 120,
  exercise_price = 100,
  r = 0.02,
  time_to_maturity = 4.5,
  dividend_yield = 0.015,
  volatility = 0.22,
  payoff = "put",
  greek = c("fair_value", "delta", "gamma", "vega", "theta", "rho")
)

round(european_put, 4)
#> fair_value      delta      gamma       vega      theta        rho 
#>    10.1325    -0.2344     0.0053    75.7280    -1.5079  -172.1477

The same calculation can be written with the wrapper:

round(
  Greeks(
    initial_price = 120,
    exercise_price = 100,
    r = 0.02,
    time_to_maturity = 4.5,
    dividend_yield = 0.015,
    volatility = 0.22,
    payoff = "put",
    greek = c("fair_value", "delta", "gamma")
  ),
  4
)
#> fair_value      delta      gamma 
#>    10.1325    -0.2344     0.0053

Digital payoffs are supported by the European Black-Scholes implementation. A cash-or-nothing call pays one unit of cash at maturity if the option finishes in the money.

digital_call <- BS_European_Greeks(
  initial_price = 100,
  exercise_price = 105,
  r = 0.03,
  time_to_maturity = 1,
  volatility = 0.25,
  payoff = "cash_or_nothing_call",
  greek = c("fair_value", "delta", "vega")
)

round(digital_call, 4)
#> fair_value      delta       vega 
#>     0.4082     0.0152    -0.0757

A finite-difference check

Delta is the derivative of the option value with respect to the initial price of the underlying asset. The tests verify this over many random inputs. For a single option, the same idea can be seen with a central finite difference.

base_args <- list(
  exercise_price = 100,
  r = 0.02,
  time_to_maturity = 1.5,
  dividend_yield = 0,
  volatility = 0.3,
  payoff = "call"
)

fair_value_at <- function(initial_price) {
  do.call(
    BS_European_Greeks,
    c(base_args, list(initial_price = initial_price, greek = "fair_value"))
  )
}

step_size <- 1e-4
finite_difference_delta <-
  (fair_value_at(100 + step_size) - fair_value_at(100 - step_size)) /
  (2 * step_size)

exact_delta <- do.call(
  BS_European_Greeks,
  c(base_args, list(initial_price = 100, greek = "delta"))
)

round(
  c(
    exact_delta = exact_delta,
    finite_difference_delta = finite_difference_delta,
    absolute_error = abs(exact_delta - finite_difference_delta)
  ),
  8
)
#>                  exact_delta.delta finite_difference_delta.fair_value 
#>                          0.6046345                          0.6046345 
#>               absolute_error.delta 
#>                          0.0000000

Malliavin Monte Carlo comparison

Malliavin_European_Greeks() estimates the same Greeks by simulation. This is less efficient than closed formulas for plain European options, but it is useful as a bridge to the Malliavin methods used for path-dependent options.

greeks_to_compare <- c("fair_value", "delta", "vega", "theta", "rho", "gamma")

exact <- BS_European_Greeks(
  initial_price = 110,
  exercise_price = 100,
  r = 0.02,
  time_to_maturity = 1,
  volatility = 0.25,
  payoff = "call",
  greek = greeks_to_compare
)

monte_carlo <- Malliavin_European_Greeks(
  initial_price = 110,
  exercise_price = 100,
  r = 0.02,
  time_to_maturity = 1,
  volatility = 0.25,
  payoff = "call",
  greek = greeks_to_compare,
  paths = 50000,
  seed = 42,
  antithetic = TRUE
)

round(rbind(exact = exact, malliavin_monte_carlo = monte_carlo), 4)
#>                       fair_value  delta    vega   theta     rho  gamma
#> exact                    17.4110 0.7211 36.9551 -5.8577 61.9148 0.0122
#> malliavin_monte_carlo    17.4359 0.7247 38.0153 -5.9976 62.2852 0.0126

References

The closed-form European formulas are standard Black-Scholes results; see Hull (2022). The Malliavin estimators are described in Hudde and Rueschendorf (2023).

These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.
Health stats visible at Monitor.