libitofin 0.32.0

A ground-up Rust port of QuantLib: quantitative-finance primitives for pricing, risk, and numerical methods.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//! Shared validated market inputs for European Heston engines.

use super::analytichestonengine::HestonChf;
use crate::errors::QlResult;
use crate::exercise::ExerciseType;
use crate::instruments::{OptionArguments, PlainVanillaPayoff, StrikedTypePayoff, TypePayoff};
use crate::models::HestonModel;
use crate::option::OptionType;
use crate::processes::HestonProcess;
use crate::stochasticprocess::StochasticProcess;
use crate::time::date::Date;
use crate::types::Real;
use crate::{fail, require};
use std::any::Any;

pub(super) struct HestonMarket {
    pub chf: HestonChf,
    pub time: Real,
    pub discount: Real,
    pub forward: Real,
    pub strike: Real,
    pub option_type: OptionType,
}

impl HestonMarket {
    pub fn new(arguments: &OptionArguments, model: &HestonModel) -> QlResult<Self> {
        Self::from_process(arguments, &model.process())
    }

    pub fn from_process(arguments: &OptionArguments, process: &HestonProcess) -> QlResult<Self> {
        let Some(exercise) = &arguments.exercise else {
            fail!("no exercise given");
        };
        require!(
            exercise.exercise_type() == ExerciseType::European,
            "not an European option"
        );
        let Some(payoff) = &arguments.payoff else {
            fail!("no payoff given");
        };
        let payoff: &dyn StrikedTypePayoff = &**payoff;
        let Some(payoff) = (payoff as &dyn Any).downcast_ref::<PlainVanillaPayoff>() else {
            fail!("non plain vanilla payoff given");
        };
        let date = exercise.last_date();
        require!(date != Date::null(), "non-null exercise date required");
        require!(
            process.risk_free_rate().current_link()?.reference_date()? != Date::null()
                && process.dividend_yield().current_link()?.reference_date()? != Date::null(),
            "non-null curve reference dates required"
        );
        let time = process.time(&date)?;
        let spot = process.s0().current_link()?.value()?;
        let discount = process
            .risk_free_rate()
            .current_link()?
            .discount_date(date, false)?;
        let dividend = process
            .dividend_yield()
            .current_link()?
            .discount_date(date, false)?;
        let strike = payoff.strike();
        require!(
            spot.is_finite() && spot > 0.0,
            "positive finite underlying required"
        );
        require!(
            strike.is_finite() && strike > 0.0,
            "positive finite strike required"
        );
        require!(
            time.is_finite() && time > 0.0,
            "positive finite maturity required"
        );
        require!(
            discount.is_finite() && discount > 0.0 && dividend.is_finite() && dividend > 0.0,
            "positive finite discounts required"
        );
        let forward = spot * dividend / discount;
        require!(
            forward.is_finite() && forward > 0.0,
            "positive finite forward required"
        );
        Ok(Self {
            chf: HestonChf::new(
                process.kappa(),
                process.theta(),
                process.sigma(),
                process.rho(),
                process.v0(),
            ),
            time,
            discount,
            forward,
            strike,
            option_type: payoff.option_type(),
        })
    }
}