Equity option

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    AnyInstrument, BarrierKind, CollateralSpec, Currency, EquityOption, FutureOptionVolSurface,
    MarketContext, OptionKind, QuoteSheet, VolConvention, YieldCurve, black76,
};

type Outcome<T> = Result<T, Box<dyn std::error::Error>>;

const SPOT: f64 = 120.0;
const STRIKE: f64 = 120.0;
const SHARES: f64 = 100.0;

fn date((year, month, day): (i32, u32, u32)) -> NaiveDate {
    NaiveDate::from_ymd_opt(year, month, day).expect("a real calendar date")
}

/// An option on `quantity` ACME shares struck at the money for a year.
fn option(usd: Currency, kind: OptionKind, quantity: f64) -> Outcome<EquityOption> {
    Ok(EquityOption::new(
        "ACME",
        usd,
        kind,
        STRIKE,
        date((2027, 10, 1)),
        quantity,
    )?)
}

fn boxed(option: EquityOption) -> AnyInstrument {
    AnyInstrument::EquityOption(Box::new(option))
}

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let expiry = date((2027, 10, 1));
    let usd: Currency = "USD".parse()?;
    let surface = FutureOptionVolSurface::new(
        close,
        vec![date((2027, 4, 1)), expiry],
        vec![100.0, 120.0, 140.0],
        &[vec![0.29, 0.26, 0.24], vec![0.28, 0.25, 0.235]],
        VolConvention::Lognormal,
    )?;
    let market = MarketContext::as_of(close)
        .with_recipe_quotes(
            &CollateralSpec::Currency(usd),
            &QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?,
        )?
        .with_equity_spot("ACME", SPOT)?
        .with_equity_vols("ACME", surface.clone());

    // A one-year at-the-money call and put on a hundred shares.
    let call = boxed(option(usd, OptionKind::Call, SHARES)?).npv(&market)?;
    let put = boxed(option(usd, OptionKind::Put, SHARES)?).npv(&market)?;
    let (curve, _) = market
        .curve(&"discount(USD)".parse()?)
        .expect("the USD discount curve");
    let df = curve.view::<f64>().discount(expiry)?;
    let parity = SHARES * (SPOT - STRIKE * df);
    println!("call        {call:.6}");
    println!("put         {put:.6}");
    println!("call - put  {:.6}", call - put);
    println!("S - K P(T)  {parity:.6}");

    // A down-and-out call at 100 dies if ACME trades down through 100; the
    // down-and-in call at 100 only comes alive if it does. Between them they are
    // the vanilla call, so the two add up to it.
    let barred = |kind: BarrierKind, level: f64| -> Outcome<AnyInstrument> {
        Ok(boxed(
            option(usd, OptionKind::Call, SHARES)?.with_barrier(kind, level, 0.0)?,
        ))
    };
    let knock_out = barred(BarrierKind::DownOut, 100.0)?.npv(&market)?;
    let knock_in = barred(BarrierKind::DownIn, 100.0)?.npv(&market)?;
    println!("down-out    {knock_out:.6}");
    println!("down-in     {knock_in:.6}");
    println!("sum         {:.6}", knock_out + knock_in);
    // A barrier the spot has already crossed is refused: a down barrier above 120.
    let refused = barred(BarrierKind::DownOut, 130.0)?.npv(&market).is_err();
    println!(
        "spot through the barrier refused  {}",
        if refused { "yes" } else { "no" }
    );

    // A negative quantity is the short side: the same premium with the sign turned.
    let short = boxed(option(usd, OptionKind::Call, -SHARES)?).npv(&market)?;
    println!("short call  {short:.6}");

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

SPOT = 120.0
EXPIRY = dt.date(2027, 10, 1)
STRIKE = 120.0
SHARES = 100.0
surface = hlx.vols.FutureOptionVolSurface(
    SOFR_CLOSE_DATE,
    [dt.date(2027, 4, 1), EXPIRY],
    [100.0, 120.0, 140.0],
    [[0.29, 0.26, 0.24], [0.28, 0.25, 0.235]],
    "lognormal",
)
market = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_recipe_quotes("USD", USD_SOFR_CLOSE)
    .with_equity_spot("ACME", SPOT)
    .with_equity_vols("ACME", surface)
)

def option(kind, **kw):
    """An option on `SHARES` ACME shares struck at the money for a year."""
    return hlx.products.equity_option("ACME", "USD", strike=STRIKE, expiry=EXPIRY, kind=kind, quantity=SHARES, **kw)

# A one-year at-the-money call and put on a hundred shares.
call, put = option("call").npv(market), option("put").npv(market)
df = market.discount_factor("USD", EXPIRY)
parity = SHARES * (SPOT - STRIKE * df)
print(f"call        {call:.6f}")
print(f"put         {put:.6f}")
print(f"call - put  {call - put:.6f}")
print(f"S - K P(T)  {parity:.6f}")

# A down-and-out call at 100 dies if ACME trades down through 100; the
# down-and-in call at 100 only comes alive if it does. Between them they are
# the vanilla call, so the two add up to it.
knock_out = option("call", barrier=100.0, barrier_kind="down_out").npv(market)
knock_in = option("call", barrier=100.0, barrier_kind="down_in").npv(market)
print(f"down-out    {knock_out:.6f}")
print(f"down-in     {knock_in:.6f}")
print(f"sum         {knock_out + knock_in:.6f}")
# A barrier the spot has already crossed is refused: a down barrier above 120.
try:
    option("call", barrier=130.0, barrier_kind="down_out").npv(market)
    refused = False
except Exception:
    refused = True
print(f"spot through the barrier refused  {'yes' if refused else 'no'}")

# A negative quantity is the short side: the same premium with the sign turned.
short = hlx.products.equity_option("ACME", "USD", strike=STRIKE, expiry=EXPIRY, kind="call", quantity=-SHARES)
print(f"short call  {short.npv(market):.6f}")