Skip to content

LatticeTechnique#

Bases: BaseTechnique, GreekMixin, IVMixin

Abstract base class for lattice-based pricing techniques.

This class provides a caching mechanism for Greek calculations. The main pricing method, _price_and_get_nodes, is designed to return both the option price and the values of the adjacent nodes at the first and second time steps, which are then used for instantaneous delta and gamma calculations without rebuilding the tree.

Source code in src/quantfin/techniques/base/lattice_technique.py 
 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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
class LatticeTechnique(BaseTechnique, GreekMixin, IVMixin):
    """
    Abstract base class for lattice-based pricing techniques.

    This class provides a caching mechanism for Greek calculations. The main
    pricing method, `_price_and_get_nodes`, is designed to return both the
    option price and the values of the adjacent nodes at the first and second
    time steps, which are then used for instantaneous delta and gamma calculations
    without rebuilding the tree.
    """

    def __init__(
        self,
        steps: int = 200,
        is_american: bool = False,
    ):
        """
        Initializes the lattice technique.

        Parameters
        ----------
        steps : int, optional
            The number of time steps in the lattice, by default 200.
        is_american : bool, optional
            True if pricing an American option, False for European. Defaults to False.
        """
        self.steps = int(steps)
        self.is_american = bool(is_american)
        self._cached_nodes: dict[str, Any] = {}
        self._cache_key: tuple | None = None

    def _get_cache_key(
        self,
        option: Option,
        stock: Stock,
        model: BaseModel,
        rate: Rate,
    ) -> tuple:
        """Creates a unique, hashable key from the pricing inputs."""
        return (option, stock, model, rate, self.steps, self.is_american)

    def price(
        self,
        option: Option,
        stock: Stock,
        model: BaseModel,
        rate: Rate,
        **kwargs: Any,
    ) -> PricingResult:
        """Prices the option and caches the necessary nodes for Greek calculations."""
        self._cache_key = self._get_cache_key(option, stock, model, rate)
        results = self._price_and_get_nodes(option, stock, model, rate)
        self._cached_nodes = results
        return PricingResult(price=results["price"])

    def delta(
        self,
        option: Option,
        stock: Stock,
        model: BaseModel,
        rate: Rate,
        **kwargs: Any,
    ) -> float:
        """Calculates delta, using cached nodes if available and valid."""
        if self._get_cache_key(option, stock, model, rate) != self._cache_key:
            self.price(option, stock, model, rate)

        cache = self._cached_nodes
        return (cache["price_up"] - cache["price_down"]) / (
            cache["spot_up"] - cache["spot_down"]
        )

    def gamma(
        self,
        option: Option,
        stock: Stock,
        model: BaseModel,
        rate: Rate,
        **kwargs: Any,
    ) -> float:
        """Calculates gamma, using cached nodes if available and valid."""
        if self._get_cache_key(option, stock, model, rate) != self._cache_key:
            self.price(option, stock, model, rate)

        cache = self._cached_nodes
        if "price_mid" in cache:  # Trinomial Case
            h1 = cache["spot_up"] - cache["spot_mid"]
            h2 = cache["spot_mid"] - cache["spot_down"]
            term1 = (cache["price_up"] - cache["price_mid"]) / h1
            term2 = (cache["price_mid"] - cache["price_down"]) / h2
            return 2 * (term1 - term2) / (h1 + h2)
        else:  # Binomial Case
            h_up = cache["spot_uu"] - cache["spot_ud"]
            h_down = cache["spot_ud"] - cache["spot_dd"]
            delta_up = (cache["price_uu"] - cache["price_ud"]) / h_up
            delta_down = (cache["price_ud"] - cache["price_dd"]) / h_down
            avg_spot_change = 0.5 * (cache["spot_uu"] - cache["spot_dd"])
            return (delta_up - delta_down) / avg_spot_change

    @abstractmethod
    def _price_and_get_nodes(
        self,
        option: Option,
        stock: Stock,
        model: BaseModel,
        rate: Rate,
    ) -> dict[str, Any]:
        """
        Abstract method for concrete lattice implementations.

        This method should perform the actual lattice calculation and return a
        dictionary containing the option price and all necessary adjacent node
        values for calculating delta and gamma.
        """
        raise NotImplementedError

__init__(steps: int = 200, is_american: bool = False) #

Initializes the lattice technique.

Parameters:

Name Type Description Default
steps int

The number of time steps in the lattice, by default 200.

 200
is_american bool

True if pricing an American option, False for European. Defaults to False.

 False
Source code in src/quantfin/techniques/base/lattice_technique.py 
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
def __init__(
    self,
    steps: int = 200,
    is_american: bool = False,
):
    """
    Initializes the lattice technique.

    Parameters
    ----------
    steps : int, optional
        The number of time steps in the lattice, by default 200.
    is_american : bool, optional
        True if pricing an American option, False for European. Defaults to False.
    """
    self.steps = int(steps)
    self.is_american = bool(is_american)
    self._cached_nodes: dict[str, Any] = {}
    self._cache_key: tuple | None = None

delta(option: Option, stock: Stock, model: BaseModel, rate: Rate, **kwargs: Any) -> float #

Calculates delta, using cached nodes if available and valid.

Source code in src/quantfin/techniques/base/lattice_technique.py 
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
def delta(
    self,
    option: Option,
    stock: Stock,
    model: BaseModel,
    rate: Rate,
    **kwargs: Any,
) -> float:
    """Calculates delta, using cached nodes if available and valid."""
    if self._get_cache_key(option, stock, model, rate) != self._cache_key:
        self.price(option, stock, model, rate)

    cache = self._cached_nodes
    return (cache["price_up"] - cache["price_down"]) / (
        cache["spot_up"] - cache["spot_down"]
    )

gamma(option: Option, stock: Stock, model: BaseModel, rate: Rate, **kwargs: Any) -> float #

Calculates gamma, using cached nodes if available and valid.

Source code in src/quantfin/techniques/base/lattice_technique.py 
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
def gamma(
    self,
    option: Option,
    stock: Stock,
    model: BaseModel,
    rate: Rate,
    **kwargs: Any,
) -> float:
    """Calculates gamma, using cached nodes if available and valid."""
    if self._get_cache_key(option, stock, model, rate) != self._cache_key:
        self.price(option, stock, model, rate)

    cache = self._cached_nodes
    if "price_mid" in cache:  # Trinomial Case
        h1 = cache["spot_up"] - cache["spot_mid"]
        h2 = cache["spot_mid"] - cache["spot_down"]
        term1 = (cache["price_up"] - cache["price_mid"]) / h1
        term2 = (cache["price_mid"] - cache["price_down"]) / h2
        return 2 * (term1 - term2) / (h1 + h2)
    else:  # Binomial Case
        h_up = cache["spot_uu"] - cache["spot_ud"]
        h_down = cache["spot_ud"] - cache["spot_dd"]
        delta_up = (cache["price_uu"] - cache["price_ud"]) / h_up
        delta_down = (cache["price_ud"] - cache["price_dd"]) / h_down
        avg_spot_change = 0.5 * (cache["spot_uu"] - cache["spot_dd"])
        return (delta_up - delta_down) / avg_spot_change

price(option: Option, stock: Stock, model: BaseModel, rate: Rate, **kwargs: Any) -> PricingResult #

Prices the option and caches the necessary nodes for Greek calculations.

Source code in src/quantfin/techniques/base/lattice_technique.py 
56
57
58
59
60
61
62
63
64
65
66
67
68
def price(
    self,
    option: Option,
    stock: Stock,
    model: BaseModel,
    rate: Rate,
    **kwargs: Any,
) -> PricingResult:
    """Prices the option and caches the necessary nodes for Greek calculations."""
    self._cache_key = self._get_cache_key(option, stock, model, rate)
    results = self._price_and_get_nodes(option, stock, model, rate)
    self._cached_nodes = results
    return PricingResult(price=results["price"])