Binomial Valuation of American Options with CRR

1. # Binomial Valuation
2. #
3. # Valuation of American Options
4. # with the Cox-Ross-Rubinstein Model
5. # Primal Algorithm
6. # Case 1: American Put Option (APO)
7. # Case 2: Short Condor Spread (SCS)
8. #
9. import math
10. import numpy as np
12. # General Parameters and Option Values
13. def set_parameters(otype, M):
14. ''' Sets parameters depending on valuation case.
15. Parameters
16. ==========
17. otype: int
18. option type
19. 1 = American put option
20. 2 = Short Condor Spread
21. '''
22. if otype == 1:
23. # Parameters -- American Put Option
24. S0 = 36. # initial stock level
25. T = 1.0 # time-to-maturity
26. r = 0.06 # short rate
27. sigma = 0.2 # volatility
28. elif otype == 2:
29. # Parameters -- Short Condor Spread
30. S0 = 100. # initial stock level
31. T = 1.0 # time-to-maturity
32. r = 0.05 # short rate
33. sigma = 0.5 # volatility
34. else:
35. raise ValueError('Option type not known.')
36. # Numerical Parameters
37. dt = T / M # time interval
38. df = math.exp(-r * dt) # discount factor
39. u = math.exp(sigma * math.sqrt(dt)) # up-movement
40. d = 1 / u # down-movement
41. q = (math.exp(r * dt) - d) / (u - d) # martingale probability
42. return S0, T, r, sigma, M, dt, df, u, d, q
44. def inner_value(S, otype):
45. ''' Inner value functions for American put option and short condor spread
46. option with American exercise.
47. Parameters
48. ==========
49. otype: int
50. option type
51. 1 = American put option
52. 2 = Short Condor Spread
53. '''
54. if otype == 1:
55. return np.maximum(40. - S, 0)
56. elif otype == 2:
57. return np.minimum(40., np.maximum(90. - S, 0)
58. + np.maximum(S - 110., 0))
59. else:
60. raise ValueError('Option type not known.')
62. def CRR_option_valuation(otype, M=500):
63. S0, T, r, sigma, M, dt, df, u, d, q = set_parameters(otype, M)
64. # Array Generation for Stock Prices
65. mu = np.arange(M + 1)
66. mu = np.resize(mu, (M + 1, M + 1))
67. md = np.transpose(mu)
68. mu = u ** (mu - md)
69. md = d ** md
70. S = S0 * mu * md
71. # Valuation by Backwards Induction
72. h = inner_value(S, otype) # innver value matrix
73. V = inner_value(S, otype) # value matrix
74. C = np.zeros((M + 1, M + 1), dtype=np.float) # continuation values
75. ex = np.zeros((M + 1, M + 1), dtype=np.float) # exercise matrix
76. z = 0
77. for i in range(M - 1, -1, -1):
78. C[0:M - z, i] = (q * V[0:M - z, i + 1]
79. + (1 - q) * V[1:M - z + 1, i + 1]) * df
80. V[0:M - z, i] = np.where(h[0:M - z, i] > C[0:M - z, i],
81. h[0:M - z, i], C[0:M - z, i])
82. ex[0:M - z, i] = np.where(h[0:M - z, i] > C[0:M - z, i], 1, 0)
83. z += 1
84. return V[0, 0]

# Binomial Valuation
#
# Valuation of American Options
# with the Cox-Ross-Rubinstein Model
# Primal Algorithm
# Case 1: American Put Option (APO)
# Case 2: Short Condor Spread (SCS)
#
import math
import numpy as np

# General Parameters and Option Values
def set_parameters(otype, M):
    ''' Sets parameters depending on valuation case.
    Parameters
    ==========
    otype: int
    option type
    1 = American put option
    2 = Short Condor Spread
    '''
    if otype == 1:
        # Parameters -- American Put Option
        S0 = 36. # initial stock level
        T = 1.0 # time-to-maturity
        r = 0.06 # short rate
        sigma = 0.2 # volatility
    elif otype == 2:
        # Parameters -- Short Condor Spread
        S0 = 100. # initial stock level
        T = 1.0 # time-to-maturity
        r = 0.05 # short rate
        sigma = 0.5 # volatility
    else:
        raise ValueError('Option type not known.')
    # Numerical Parameters
    dt = T / M # time interval
    df = math.exp(-r * dt) # discount factor
    u = math.exp(sigma * math.sqrt(dt)) # up-movement
    d = 1 / u # down-movement
    q = (math.exp(r * dt) - d) / (u - d) # martingale probability
    return S0, T, r, sigma, M, dt, df, u, d, q

def inner_value(S, otype):
    ''' Inner value functions for American put option and short condor spread
    option with American exercise.
    Parameters
    ==========
    otype: int
    option type
    1 = American put option
    2 = Short Condor Spread
    '''
    if otype == 1:
        return np.maximum(40. - S, 0)
    elif otype == 2:
        return np.minimum(40., np.maximum(90. - S, 0)
                          + np.maximum(S - 110., 0))
    else:
        raise ValueError('Option type not known.')
    
def CRR_option_valuation(otype, M=500):
    S0, T, r, sigma, M, dt, df, u, d, q = set_parameters(otype, M)
    # Array Generation for Stock Prices
    mu = np.arange(M + 1)
    mu = np.resize(mu, (M + 1, M + 1))
    md = np.transpose(mu)
    mu = u ** (mu - md)
    md = d ** md
    S = S0 * mu * md
    # Valuation by Backwards Induction
    h = inner_value(S, otype) # innver value matrix
    V = inner_value(S, otype) # value matrix
    C = np.zeros((M + 1, M + 1), dtype=np.float) # continuation values
    ex = np.zeros((M + 1, M + 1), dtype=np.float) # exercise matrix
    z = 0
    for i in range(M - 1, -1, -1):
        C[0:M - z, i] = (q * V[0:M - z, i + 1]
        + (1 - q) * V[1:M - z + 1, i + 1]) * df
        V[0:M - z, i] = np.where(h[0:M - z, i] > C[0:M - z, i],
        h[0:M - z, i], C[0:M - z, i])
        ex[0:M - z, i] = np.where(h[0:M - z, i] > C[0:M - z, i], 1, 0)
        z += 1
    return V[0, 0]