SurgicalOntologist fucked around with this message at 09:08 on Feb 4, 2020

Rocko Bonaparte fucked around with this message at 23:24 on Feb 4, 2020

import math
import numpy as np

class StockOption(object):
 def __init__(self, S0, K, r, T, N, params):
  self.S0 = S0
  self.K = K
  self.r = r
  self.T = T
  self.N = max(1, N) # Ensure N have at least 1 time step
  self.STs = None # Declare the stock prices tree

   """ Optional parameters used by derived classes """
   self.pu = params.get("pu", 0) # Probability of up state
   self.pd = params.get("pd", 0) # Probability of down state
   self.div = params.get("div", 0) # Dividend yield
   self.sigma = params.get("sigma", 0) # Volatility
   self.is_call = params.get("is_call", True) # Call or put
   self.is_european = params.get("is_eu", True) # Eu or Am
    """ Computed values """
   self.dt = T/float(N) # Single time step, in years
   self.df = math.exp(
   -(r-self.div) * self.dt) # Discount factor

class BinomialEuropeanOption(StockOption):
 def __setup_parameters__(self):
  """ Required calculations for the model """
  self.M = self.N + 1 # Number of terminal nodes of tree
  self.u = 1 + self.pu # Expected value in the up state
  self.d = 1 - self.pd # Expected value in the down state
  self.qu = (math.exp((self.r-self.div)*self.dt) -
  self.d) / (self.u-self.d)
  self.qd = 1-self.qu

 def _initialize_stock_price_tree_(self):
    # Initialize terminal price nodes to zeros
    self.STs = np.zeros(self.M)
    # Calculate expected stock prices for each node
    for i in range(self.M):
    self.STs[i] = self.S0*(self.u**(self.N-i))*(self.d**i)

 def _initialize_payoffs_tree_(self):
  # Get payoffs when the option expires at terminal nodes
  payoffs = np.maximum(0, (self.STs-self.K) 
  if self.is_call
  else(self.K-self.STs))
  return payoffs

 def _traverse_tree_(self, payoffs):
  #  Starting from the time the option expires, traverse
  # backwards and calculate discounted payoffs at each node
  for i in range(self.N):
  payoffs = (payoffs[:-1] * self.qu +  payoffs[1:] * self.qd) * self.df
  return payoffs

 def __begin_tree_traversal__(self):
  payoffs = self._initialize_payoffs_tree_()
  return self._traverse_tree_(payoffs)

Let's take the values from the two-step binomial tree example discussed earlier to
price the European put option:

>>> from StockOption import StockOption
>>> from BinomialEuropeanOption import BinomialEuropeanOption
>>> eu_option = BinomialEuropeanOption
... 50, 50, 0.05, 0.5, 2,
... {"pu": 0.2, "pd": 0.2, "is_call": False})
>>> print option.price()
4.82565175126

Using the binomial option pricing model gives us a present value of $4.826 for the
European put option.

import math
import numpy as np
from dataclasses import dataclass

@dataclass
class StockOption:
    """s0 is stock price, k is strike price, r is risk-free rate, t is time to maturity
    n is """
    s0:      float
    k:       float
    r:       float
    t:       float
    n:       int = field(default=1)
    STs:     float = field(default=0)
    pu:      float = field(default=0)
    pd:      float = field(default=0)
    div:     float = field(default=0)
    sigma:   float = field(default=0)
    is_call: bool = field(default=True)
    
    dt: float = self.t / float(self.n)
    df: float = math.exp( -(r-self.div) * self.t / float(self.n) )

@dataclass
class BinomialEuropeanOption(StockOption):
    nodes:      int = self.n - 1
    upstate:    float = 1 + self.pu
    downstate:  float = 1 - self.pd
    qu:         float = math.exp((self.r-self.div)*self.dt - self.downstate / (self.upstate-self.downstate))
    qd:         float = 1 - self.qu
    
    def stock_tree(self):
       intree = np.zeros(self.nodes)
       numbertree = [newtree+self.s0*(self.upstate**(self.n-1)) for newtree in range(self.nodes)]
       return numbertree
    
    def payoff_tree(self):
        if is_call: # Check if call, if not, reverse for put
          payoffs = np.maximum(0, self.STs-self.k)
        else:
          payoffs = np.maximum(0, self.k-self.STs)
        
    def traverse_tree(self, payoffs): # __init__payoffs_tree
        for i in range(self.n):
            payoffs = (payoffs[:-1] * self.qu + payoffs[1:] * self.qd)
        yield payoffs 
    
    
    def calc_price(self):
        freshtree = stock_tree()
        optionvalue = traverse_tree(freshtree)
        
        print(optionvalue[0])
  

stockdata = StockOption(50, 50, 0.05, 0.5, 2, {"pu": 0.2, "pd": 0.2, "is_call":False})
eu_option = BinomialEuropeanOption()
   
eu_option.calc_price()

LuckySevens fucked around with this message at 15:49 on Feb 6, 2020

Dominoes fucked around with this message at 19:31 on Feb 6, 2020

class StockOption:
   ......
    is_call: bool = field(default=True)

LuckySevens fucked around with this message at 00:17 on Feb 7, 2020