def setUp(self):
self.today = _today
self.grid = _grid
self.termday = self.grid[-1]
self.flat_zero_curve = ZeroRateCurve([self.today], [0.05])
self.term_zero_curve = ZeroRateCurve(self.grid, _term)
self.zero_curve = self.flat_zero_curve
self.fx_curve = FxCurve([self.today], [1.],
domestic_curve=self.zero_curve,
foreign_curve=self.zero_curve)
self.fx_rate = FxRate(1., self.today)
self.fx_volatility = .3
self.gbm_fx_curve = GeometricBrownianMotionFxRateFactorModel(
self.fx_rate, volatility=self.fx_volatility)
self.mean_reversion = .1
self.volatility = .005
self.hull_white_curve = HullWhiteCurveFactorModel(
self.zero_curve, self.mean_reversion, self.volatility)
z = ZeroRateCurve([self.today], [0.03])
self.hull_white_curve_2 = HullWhiteCurveFactorModel(
z, self.mean_reversion * 2, self.volatility * 0.5)
self.df_func = (
lambda x: self.hull_white_curve.get_discount_factor(
x, self.termday) * self.hull_white_curve.inner_factor.
get_discount_factor(self.today, self.termday) / self.
hull_white_curve.inner_factor.get_discount_factor(x, self.termday))
self.fw_func = (
lambda x: self.hull_white_curve.get_cash_rate(self.termday - '1y'))
self.num_of_paths = 100
self.plot = dict()
def __init__(self, inner_factor, drift=0.0, volatility=0.0):
GaussRiskFactorModel.__init__(self,
inner_factor,
drift,
volatility,
start=0.0)
ZeroRateCurve.__init__(self, inner_factor.domain,
inner_factor(inner_factor.domain),
inner_factor.interpolation, inner_factor.origin,
inner_factor.day_count,
inner_factor.forward_tenor)
def setUp(self):
self.today = _today
self.grid = BusinessRange(_today, _today + '10y', step='3m')
domestic = ZeroRateCurve([self.today], [0.05])
foreign = ZeroRateCurve(_grid, _term)
self.model = GeometricBrownianMotionFxRate(1.34,
self.today,
domestic_curve=domestic,
foreign_curve=foreign,
volatility=0.2 / 250)
self.num_of_paths = 100
self.plot = dict()
def test_raise(self):
d = HullWhiteCurveFactorModel(ZeroRateCurve())
f = HullWhiteCurveFactorModel(ZeroRateCurve())
x = HullWhiteFxRateFactorModel(FxRate(), d, f)
HullWhiteCurveFactorModel(ZeroRateCurve())
self.assertRaises(TypeError, HullWhiteCurveFactorModel, FxRate())
HullWhiteFxRateFactorModel(FxRate(), d, f)
self.assertRaises(TypeError, HullWhiteFxRateFactorModel,
ZeroRateCurve(), d, f)
self.assertRaises(TypeError, HullWhiteFxRateFactorModel, FxRate(),
ZeroRateCurve(), f)
self.assertRaises(TypeError, HullWhiteFxRateFactorModel, FxRate(), d,
ZeroRateCurve())
HullWhiteMultiCurrencyCurveFactorModel(f, d, x)
self.assertRaises(TypeError, HullWhiteMultiCurrencyCurveFactorModel, d,
f, FxRate())
self.assertRaises(TypeError, HullWhiteMultiCurrencyCurveFactorModel, d,
ZeroRateCurve(), x)
self.assertRaises(TypeError, HullWhiteMultiCurrencyCurveFactorModel,
ZeroRateCurve(), f, x)
HullWhiteCurve()
HullWhiteFxRate()
HullWhiteMultiCurrencyCurve()
def setUp(self):
self.today = _today
self.grid = _grid
self.termday = self.grid[-1]
self.flat_zero_curve = ZeroRateCurve([self.today], [0.05])
self.term_zero_curve = ZeroRateCurve(self.grid, _term)
self.zero_curve = self.flat_zero_curve
self.mean_reversion = .1
self.volatility = .005
self.hull_white_curve = HullWhiteCurveFactorModel(
self.zero_curve,
mean_reversion=self.mean_reversion,
volatility=self.volatility)
self.plot = dict()
def _rebuild_object(self):
if self._is_modified_property(
'_calendar_') and not self._is_modified_property('_spot_'):
self._spot_ = BusinessPeriod(businessdays=self._spot_.businessdays,
holiday=self._calendar_)
x_list = list()
# carefully cast x_list/curve dates
for x in self._curve_.row_keys():
if BusinessDate.is_businessdate(x):
x = BusinessDate(x)
elif BusinessPeriod.is_businessperiod(x):
x = BusinessPeriod(x).to_businessdate(self.origin)
else:
s = repr(x), type(
x), BusinessDate.__name__, self.__class__.__name__
raise ValueError(
'Cannot cast value %s of type %s to %s in %s construction.'
% s)
x_list.append(x)
y_list = list(map(float, self._curve_.col('Rate')))
y_inter = Constant(), self._interpolation_, self._extrapolation_
if self._rate_type_ == "Zero":
self._inner_curve = ZeroRateCurve(x_list,
y_list,
y_inter,
self.origin,
day_count=self._day_count_)
else:
msg = "_curve_ " + self.object_name + ": RateType " + self._rate_type_ + " not implemented, yet."
raise NotImplementedError(msg)
self._curve_df_dict = dict()
return self
def yield_to_maturity(self, valuation_date):
# todo bracketing on yield
last = None
ytm = None
for ytm in _frange(-0.1, 0.1, 0.001):
value = self.get_value(ZeroRateCurve([ytm], [valuation_date]))
if last is None or abs(last) >= abs(value):
last = value
return ytm
def setUp(self):
self.today = _today
self.grid = BusinessRange(_today, _today + '10b', step='1b')
self.term_zero_curve = ZeroRateCurve(_grid, _term)
self.model = GaussFlatSpreadZeroRateCurve(_grid,
_term,
volatility=0.2 / 250)
self.num_of_paths = 10
self.plot = dict()
def __init__(self,
inner_factor,
domestic_curve=None,
foreign_curve=None,
volatility=0.0):
domestic_curve = ZeroRateCurve(
[inner_factor.origin],
[0.]) if domestic_curve is None else domestic_curve
foreign_curve = domestic_curve if foreign_curve is None else foreign_curve
diff_curve = foreign_curve.cast(ZeroRateCurve) - domestic_curve.cast(
ZeroRateCurve)
domain = diff_curve.domain
data = list(diff_curve.derivative(d) for d in domain)
drift = DateCurve(domain,
data,
origin=inner_factor.origin,
day_count=domestic_curve.day_count).to_curve()
FxRate.__init__(self, inner_factor.value, inner_factor.origin)
GeometricBrownianMotionRiskFactorModel.__init__(
self, inner_factor, drift, volatility, start=inner_factor.value)
def __init__(self,
domain=None,
data=None,
interpolation=None,
origin=None,
day_count=None,
forward_tenor=None,
drift=0.0,
volatility=0.0):
inner_factor = ZeroRateCurve(domain, data, interpolation, origin,
day_count, forward_tenor)
super(GaussFlatSpreadZeroRateCurve,
self).__init__(inner_factor, drift, volatility)
def __init__(self,
domain=(),
data=(),
interpolation=None,
origin=None,
day_count=None,
forward_tenor=None,
mean_reversion=0.0,
volatility=0.0,
terminal_date=None):
inner_factor = ZeroRateCurve(domain, data, interpolation, origin,
day_count, forward_tenor)
super(HullWhiteCurve, self).__init__(inner_factor, mean_reversion,
volatility, terminal_date)
def setUp(self):
self.today = _today
self.grid = _grid
self.termday = self.grid[-1]
self.flat_zero_curve = ZeroRateCurve([self.today], [0.05])
self.term_zero_curve = ZeroRateCurve(self.grid, _term)
self.zero_curve = self.flat_zero_curve
self.mean_reversion = .1
self.volatility = .005
self.hull_white_curve = HullWhiteCurveFactorModel(
self.zero_curve,
mean_reversion=self.mean_reversion,
volatility=self.volatility)
self.df_func = (
lambda x: self.hull_white_curve.get_discount_factor(
x, self.termday) * self.hull_white_curve.inner_factor.
get_discount_factor(self.today, self.termday) / self.
hull_white_curve.inner_factor.get_discount_factor(x, self.termday))
self.fw_func = (
lambda x: self.hull_white_curve.get_cash_rate(self.termday - '1y'))
self.num_of_paths = 100
self.plot = dict()
def test_zero_rate_curve(self):
rate = 0.02
curve = ZeroRateCurve(self.domain, [rate] * self.len)
for d in self.domain:
for p in self.periods:
self.assertAlmostEqual(curve.get_discount_factor(d + p, d + p),
1.)
self.assertAlmostEqual(curve.get_zero_rate(self.today, d + p),
rate)
self.assertAlmostEqual(curve.get_short_rate(d + p), rate)
yf = curve.day_count(d + p, (d + p) + curve.forward_tenor)
cr = simple_compounding(curve.get_cash_rate(d + p), yf)
self.assertAlmostEqual(continuous_rate(cr, yf), rate)
def __init__(self,
domain=(),
data=(),
interpolation=None,
origin=None,
day_count=None,
forward_tenor=None,
mean_reversion=0.0001,
volatility=0.0,
domestic_hw_curve=None,
hw_fx_curve=None):
"""
:param list(BusinesDate) domain:
:param list(float) data:
:param (dcf.interpolation, dcf.interpolation, dcf.interpolation) interpolation:
:param BusinessDate origin:
:param function day_count:
:param BusinessPeriod forward_tenor:
:param float mean_reversion:
:param TimeDependentParameter or float volatility:
:param HullWhiteCurveFactorModel domestic_hw_curve:
:param HullWhiteFxRateFactorModel hw_fx_curve:
:param float foreign_correlation:
:param float rate_correlation:
"""
terminal_date = domain[-1] if domain else None
terminal_date = terminal_date if domestic_hw_curve is None else domestic_hw_curve.terminal_date
domestic_hw_curve = HullWhiteCurve(
) if domestic_hw_curve is None else domestic_hw_curve
hw_fx_curve = HullWhiteFxRate() if hw_fx_curve is None else hw_fx_curve
inner_factor = ZeroRateCurve(domain, data, interpolation, origin,
day_count, forward_tenor)
inner_factor = HullWhiteCurveFactorModel(inner_factor, mean_reversion,
volatility, terminal_date)
super(HullWhiteMultiCurrencyCurve,
self).__init__(inner_factor=inner_factor,
domestic_hw_curve=domestic_hw_curve,
hw_fx_curve=hw_fx_curve)
def test_discount_factor_curve(self):
zr_curve = ZeroRateCurve([self.today, self.today + '1d'], [.02, .02])
df_curve = DiscountFactorCurve(
zr_curve.domain,
[1., zr_curve.get_discount_factor(self.today + '1d')])
for p in self.periods:
x = self.today + p
self.assertAlmostEqual(df_curve.get_discount_factor(x, x), 1.)
z = zr_curve.get_zero_rate(x)
d = df_curve.get_zero_rate(x)
self.assertAlmostEqual(z, d)
z = zr_curve.get_discount_factor(x)
d = df_curve.get_discount_factor(x)
self.assertAlmostEqual(z, d)
z = zr_curve.get_short_rate(x)
d = df_curve.get_short_rate(x)
self.assertAlmostEqual(z, d)
z = zr_curve.get_cash_rate(x)
d = df_curve.get_cash_rate(x)
self.assertAlmostEqual(z, d)
def __init__(self,
inner_factor,
mean_reversion=0.0,
volatility=0.0,
terminal_date=None):
"""
:param list(float) domain:
:param list(float) data:
:param list(interpolation) interpolation:
:param BusinessDate origin:
:param DayCount day_count:
:param BusinessPeriod forward_tenor: standard forward
:param mean_reversion: mean reversion speed of short rate process
:type mean_reversion: float or function
:param volatility: short rate volatility
:type volatility: float or function
:param BusinessDate terminal_date: date of terminal measure
:param RateCurve inner_factor:
initializes Hull White drift
"""
if not isinstance(inner_factor, InterestRateCurve):
names = self.__class__.__name__, InterestRateCurve.__name__, inner_factor.__class__.__name__
raise TypeError('%s requires inner_factor of type %s. %s given.' %
names)
RiskFactorModel.__init__(self, inner_factor, 0.0)
data = list(
ZeroRateCurve.get_storage_type(inner_factor, x)
for x in inner_factor.domain)
super(HullWhiteCurveFactorModel,
self).__init__(inner_factor.domain, data,
inner_factor.interpolation, inner_factor.origin,
inner_factor.day_count,
inner_factor.forward_tenor)
if not isinstance(mean_reversion, float):
raise NotImplementedError(
'Mean reversion function or term structure not yet supported.')
# init volatility
self.volatility = TimeDependentParameter(volatility)
# init mean reversion
self.mean_reversion = float(mean_reversion)
# init terminal_date
self.terminal_date = self.domain[
-1] if terminal_date is None and self.domain else terminal_date
# init integration caches
self._pre_calc_diffusion = dict()
self._pre_calc_drift = dict()
self._integral_vol_squared_I1 = dict()
# init factor state variables
self._factor_date = self.origin
self._factor_yf = 0.0
self._factor_value = 0.0
self._integral = 0.0
# init diffusion driver
if isinstance(self.inner_factor, RiskFactorModel):
self._diffusion_driver = self.inner_factor,
else:
self._diffusion_driver = self,
def setUp(self):
self.today = BusinessDate(20161231)
self.schedule = BusinessSchedule(self.today, self.today + '5y', '1m')
self.rate = 0.01
self.df = DiscountFactorCurve(ZeroRateCurve([self.today], [self.rate]))
self.curve = CashRateCurve([self.today], [self.rate])
def test_zero_cast(self):
for p in self.periods:
curve = self.curve(p)
cast = self.cast_type(ZeroRateCurve(curve))
for d in curve.domain[1:]:
self.assertAlmostEqual(cast(d), curve(d), self.precision)