Finance Functions Bonds & Options
July 7, 2019
[1]: def duration(per_chg_price, chg_yld):
'''
Summary: Calculate the duration of a bond.
PARA per_chg_price: The percentage change in bond price.
PARA type: float
PARA chg_yld: The yield change in percent.
PARA type: float
'''
return -(per_chg_price / chg_yld)
#EXAMPLE
price_change = -.05
yield_change = .01
duration(price_change, yield_change)
[1]: 5.0
[2]: def absolute_yield_spread(yield_higher, yield_lower):
'''
Summary: Calculate the absolute yield spread given two bonds.
PARA yield_higher: The yield on the higher-yield bond.
PARA type: float
PARA yield_lower: The yield on the lower-yield bond.
PARA type: float
'''
return (yield_higher - yield_lower)
#EXAMPLE
y_h = .0675
1
y_l = .0650
absolute_yield_spread(y_h, y_l)
[2]: 0.0025000000000000022
[3]: def relative_yield_spread(absolute_yield, yield_benchmark):
'''
Summary: Calculate the relative yield spread of a given bond.
PARA absolute_yield: The the absolute yield spread for two given bonds.
PARA type: float
PARA yield_benchmark: The yield of the bond that we are defining as the␣
,→ benchmark, the one we want to compare.
PARA type: float
'''
return absolute_yield / yield_benchmark
#EXAMPLE
y_h = .0675
y_l = .0650
y_a = absolute_yield_spread(y_h, y_l)
relative_yield_spread(y_a, y_l)
[3]: 0.03846153846153849
[4]: def yield_ratio(subject_yield, benchmark_yield):
'''
Summary: Calculate the yield ratio, given two bonds.
PARA subject_yield: The yield of the subject bond.
PARA type: float
PARA benchmark_yield: The yield of the bond that we are defining as the␣
,→ benchmark, the one we want to compare.
PARA type: float
'''
return subject_yield / benchmark_yield
#EXAMPLE
y_h = .0675
y_l = .0650
yield_ratio(y_h, y_l)
[4]: 1.0384615384615385
2
[5]: def after_tax_yield(taxable_yield, marginal_tax_rate):
'''
Summary: Calculate the after-tax yield on a taxable security.
PARA taxable_yield: The taxable yield of a bond.
PARA type: float
PARA marginal_tax_rate: The investor's marginal tax rate.
PARA type: float
'''
return taxable_yield * (1 - marginal_tax_rate)
#EXAMPLE
yld_tax = .10
mrg_tax = .40
after_tax_yield(yld_tax, mrg_tax)
[5]: 0.06
[7]: def taxable_equivalent_yield(tax_free_yield, marginal_tax_rate):
'''
Summary: Calculate the taxable-equivalent yield for a given bond.
PARA tax_free_yield: The tax-free yield of a bond.
PARA type: float
PARA marginal_tax_rate: The investor's marginal tax rate.
PARA type: float
'''
return tax_free_yield / (1 - marginal_tax_rate)
#EXAMPLE
yld_tax = .045
mrg_tax = .350
taxable_equivalent_yield(yld_tax, mrg_tax)
[7]: 0.06923076923076922
[8]: def effective_duration(bond_dec, bond_inc, bond_int, yld_delta):
'''
Summary: Calculate the effective duration of a bond, given a change in␣
,→yield.
PARA bond_dec: The value of a bond is the yield decreases by the␣
,→ yield_delta.
3
PARA type: float
PARA bond_inc: The value of a bond is the yield increases by the␣
,→yield_delta.
PARA type: float
PARA bond_int: The inital bond price.
PARA type: float
PARA yld_delta: The change in yield to get bond_dec & bond_inc
PARA type: float
'''
return (bond_inc - bond_dec) / (2 * bond_int * yld_delta)
#EXAMPLE
bond_inc = 952.30
bond_dec = 866.80
bond_int = 908.00
delt_yld = .005
effective_duration(bond_dec, bond_inc, bond_int, delt_yld)
[8]: 9.416299559471366
[9]: def pct_change_bond(effective_duration, yld_chg):
'''
Summary: Calculate the percentage change in bond price.
PARA effective_duration: The effective duration of the bond.
PARA type: float
PARA yld_chg: The percentage change in yield.
PARA type: float
'''
return -effective_duration * yld_chg
#EXAMPLE
bond_inc = 952.30
bond_dec = 866.80
bond_int = 908.00
delt_yld = .005
ed = effective_duration(bond_dec, bond_inc, bond_int, delt_yld)
pct_yld = .003
pct_change_bond(ed, pct_yld)
4
[9]: -0.028248898678414097
[12]: import numpy as np
def portfolio_duration(bonds, durations):
'''
Summary: Calculate the duration of a portfolio given a list of bond prices,␣
,→and a list of durations for each bonds.
PARA bonds: A list of bonds at their market value prices
PARA type: float
PARA durations: A list of durations for each bond in the bonds list
PARA type: float
'''
# calculate the weights
np_bonds = np.array(bonds)
np_weights = np_bonds / np_bonds.sum()
np_durations = np.array(durations)
return np.dot(np_weights, np_durations)
#EXAMPLE
bond = [6000, 4000]
dura = [8.5, 4.0]
portfolio_duration(bond, dura)
[12]: 6.699999999999999
[15]: def return_impact(mod_duration, spread, spread_type, convexity):
'''
Summary: Calculate the return impact for a bond, using either a large or␣
,→small spread.
PARA mod_duration: The modified duration of the bond.
PARA type: float
PARA spread: The change in spread
PARA type: float
PARA spread_type: Defines the spread as either a small spread change or␣
,→large spread change. Options are 'large' or 'small'
PARA type: string
PARA convexity: The spread convexity
5
PARA type: float
'''
if spread_type == 'small':
return -mod_duration * spread
else:
return (-mod_duration * spread) + (.5 * convexity * (spread ** 2))
#EXAMPLE
duration = 6.4
convexity = 50
spread = -.0075
# small example
spread_type = 'small'
display(return_impact(duration, spread, spread_type, convexity))
# large example
spread_type = 'large'
display(return_impact(duration, spread, spread_type, convexity))
0.048
0.04940625
[20]: def option_moneyness(option_type, strike_price, selling_price):
'''
Summary: Returns whether a put option or call option is in the money, at␣
,→the money, or out the money.
PARA option_type: Defines whether the option is a 'call' or 'put' option.
PARA type: string
PARA strike_price: The strike price of the option.
PARA type: float
PARA selling_price: The current selling price of the option
PARA type: float
'''
6
# describe the conditions for a call option
if option_type == 'call':
if (selling_price - strike_price) > 0:
return ('in-the-money', selling_price - strike_price)
elif (selling_price - strike_price) < 0:
return ('out-of-the-money', selling_price - strike_price)
elif(selling_price == strike_price):
return ('at-the-money', 0)
# describe the condtions for a put option
else:
if (strike_price - selling_price) > 0:
return ('in-the-money', strike_price - selling_price)
elif (strike_price - selling_price) < 0:
return ('out-of-the-money', strike_price - selling_price)
elif(selling_price == strike_price):
return ('at-the-money', 0)
# EXAMPLE
selling_price = 37.00
strike_price = 40.00
# call example
opt_type = 'call'
display(option_moneyness(opt_type, strike_price, selling_price))
# put example
opt_type = 'put'
display(option_moneyness(opt_type, strike_price, selling_price))
('out-of-the-money', -3.0)
('in-the-money', 3.0)
[21]: def exp_date_payoff(exercise_price, index_price, contracts):
'''
Summary: Returns the expiration date payoff for a option.
PARA exercise_price: The exercise price of the option.
PARA type: float
7
PARA index_price: The index price at expiration.
PARA type: float
PARA contracts: The contract multiplier
PARA type: int
'''
return (index_price - exercise_price) * contracts
# EXAMPLE
i_price = 962.00
e_price = 950.00
cont = 250
exp_date_payoff(e_price, i_price, cont)
[21]: 3000.0
[22]: def option_intrinsic_value(option_type, strike_price, selling_price):
'''
Summary: Returns the intrinsic value of either a put or call option.
PARA option_type: Defines whether the option is a 'call' or 'put' option.
PARA type: string
PARA strike_price: The strike price of the option.
PARA type: float
PARA selling_price: The current selling price of the option
PARA type: float
'''
# calculate the intrinsic value of a call option
if option_type == 'call':
return max([0, (selling_price - strike_price)])
# calculate the intrinsic value of a put option
else:
return max([0, (strike_price - selling_price)])
# EXAMPLE
selling_price = 55.00
strike_price = 50.00
8
# call example
opt_type = 'call'
display(option_intrinsic_value(opt_type, strike_price, selling_price))
# put example
opt_type = 'put'
display(option_intrinsic_value(opt_type, strike_price, selling_price))
5.0
[29]: def min_max_option(option_type, option_style, risk_free_rate, strike_price,␣
,→selling_price, time_frame):
'''
Summary: Returns the maximum and minimum value for a european or american␣
,→call/put.
PARA option_type: Defines whether the option is a 'call' or 'put' option.
PARA type: string
PARA option_style: Defines whether the option is an 'american' or␣
,→'european' option.
PARA type: string
PARA risk_free_rate: The current risk-free rate.
PARA type: float
PARA selling_price: The current selling price of the option.
PARA type: float
PARA strike_price: The strike price of the option.
PARA type: float
PARA time_frame: The time frame of the option, for example a 4 month option␣
,→ would be 4.
PARA type: float
'''
if option_type == 'call':
if option_style == 'american' or option_style == 'european':
max_opt_1 = 0
9
max_opt_2 = (selling_price - strike_price / (1 + risk_free_rate)␣
,→ **(time_frame / 12))
minimum_value = max([max_opt_1, max_opt_2])
maximum_value = selling_price
return (minimum_value, maximum_value)
else:
if option_style == 'american':
max_opt_1 = 0
max_opt_2 = strike_price - selling_price
minimum_value = max([max_opt_1, max_opt_2])
maximum_value = strike_price
return (minimum_value, maximum_value)
else:
max_opt_1 = 0
max_opt_2 = (strike_price / (1 + risk_free_rate) **(time_frame /␣
,→12)) - selling_price
minimum_value = max([max_opt_1, max_opt_2])
maximum_value = (strike_price / (1 + risk_free_rate) **(time_frame /
,→ 12))
return (minimum_value, maximum_value)
# EXAMPLE - PUTS
selling_price = 63.00
strike_price = 65.00
time_frame = 4
rfr = .05
# put example
opt_type = 'put'
opt_styl = 'american'
display(min_max_option(opt_type, opt_styl, rfr, strike_price, selling_price,␣
,→time_frame))
# put example
opt_type = 'put'
opt_styl = 'european'
10
display(min_max_option(opt_type, opt_styl, rfr, strike_price, selling_price,␣
,→time_frame))
# EXAMPLE - CALLS
selling_price = 68.00
strike_price = 65.00
time_frame = 3
rfr = .05
# call example
opt_type = 'call'
opt_styl = 'american'
display(min_max_option(opt_type, opt_styl, rfr, strike_price, selling_price,␣
,→time_frame))
# call example
opt_type = 'call'
opt_styl = 'european'
display(min_max_option(opt_type, opt_styl, rfr, strike_price, selling_price,␣
,→time_frame))
(2.0, 65.0)
(0.9514295424027992, 63.9514295424028)
(3.788024417500182, 68.0)
(3.788024417500182, 68.0)
[36]: def put_call_parity(calc = 'none', put = 0, call = 0, strike_price = 0,␣
,→stock_price = 0, risk_free_rate = 0, time_frame = 0):
'''
Summary: Define the put-call parity formula, which returns the price of a␣
,→call given a put and vice verse.
PARA calc: Calculate either the value of a 'call' given a put or calculate␣
,→a 'put' given a call.
PARA type: string
PARA put: The price of the put.
PARA type: float
PARA call: The price of the call
PARA type: float
11
PARA exercise_price: The current selling price of the option.
PARA type: float
PARA stock_price: The current price of the stock
PARA type: float
PARA risk_free_rate: The current risk-free rate.
PARA type: float
PARA time_frame: The time frame of the option, for example a 4 month option␣
,→would be 4.
PARA type: int
'''
if calc == 'put':
put = call - stock_price + (strike_price / ((1 + risk_free_rate) **␣
,→(time_frame / 12)))
return put
else:
call = stock_price + put - (strike_price / ((1 + risk_free_rate) **␣
,→ (time_frame / 12)))
return call
#EXAMPLE
stock = 52.00
rfr = .05
time = 3
exercise = 50.00
put = 1.50
calc_type = 'call'
put_call_parity(calc = calc_type,
put = put,
strike_price = exercise,
stock_price = stock,
risk_free_rate = rfr,
time_frame =time)
[36]: 4.106172628846302
[37]: def fixed_rate_pay(swap_fixed_rate, libor, principal, num_days):
'''
Summary: Define the put-call parity formula, which returns the price of a␣
,→call given a put and vice verse.
12
PARA calc: Calculate either the value of a 'call' given a put or calculate␣
,→ a 'put' given a call.
PARA type: string
PARA swap_fixed_rate: The swap's fixed rate.
PARA type: float
PARA libor: The libor rate
PARA type: float
PARA principal: The principal of the swap
PARA type: float
PARA num_days: The number of days until payment
PARA type: int
'''
return (swap_fixed_rate - libor) * (num_days / 360) * (principal)
#EXAMPLE
swap = .06
libor = .04
principal = 1000000
days = 90
fixed_rate_pay(swap, libor, principal, days)
[37]: 4999.999999999999
13
