def __init__(self,
pct_drift=None,
pct_vol=None,
time_unit=dt.timedelta(days=1)):
if pct_drift is None and pct_vol is None:
pct_drift = 0.
pct_vol = 1.
self._pct_drift, self._pct_vol = None, None
if pct_drift is not None:
self._pct_drift = npu.to_ndim_2(pct_drift,
ndim_1_to_col=True,
copy=True)
process_dim = npu.nrow(self._pct_drift)
if pct_vol is not None:
self._pct_vol = npu.to_ndim_2(pct_vol,
ndim_1_to_col=True,
copy=True)
process_dim = npu.nrow(self._pct_vol)
if self._pct_drift is None:
self._pct_drift = npu.col_of(process_dim, 0.)
if self._pct_vol is None: self._pct_vol = np.eye(process_dim)
npc.check_col(self._pct_drift)
npc.check_nrow(self._pct_drift, process_dim)
npc.check_nrow(self._pct_vol, process_dim)
noise_dim = npu.ncol(self._pct_vol)
self._pct_cov = stats.vol_to_cov(self._pct_vol)
npu.make_immutable(self._pct_drift)
npu.make_immutable(self._pct_vol)
npu.make_immutable(self._pct_cov)
self._to_string_helper_GeometricBrownianMotion = None
self._str_GeometricBrownianMotion = None
super(GeometricBrownianMotion,
self).__init__(process_dim=process_dim,
noise_dim=noise_dim,
drift=lambda t, x: self._pct_drift * x,
diffusion=lambda t, x: x * self._pct_vol,
time_unit=time_unit)
def __init__(self, initial_value=None, final_value=None, initial_time=0., final_time=1., vol=None, time_unit=dt.timedelta(days=1)):
process_dim = 1
self.__initial_value = None
self.__final_value = None
if initial_value is not None:
self.__initial_value = npu.to_ndim_2(initial_value, ndim_1_to_col=True, copy=True)
process_dim = npu.nrow(self.__initial_value)
if final_value is not None:
self.__final_value = npu.to_ndim_2(final_value, ndim_1_to_col=True, copy=True)
process_dim = npu.nrow(self.__final_value)
if self.__initial_value is None:
self.__initial_value = npu.col_of(process_dim, 0.)
if self.__final_value is None:
self.__final_value = npu.col_of(process_dim, 0.)
self.__vol = None
if vol is not None:
self.__vol = npu.to_ndim_2(vol, ndim_1_to_col=True, copy=True)
process_dim = npu.nrow(self.__vol)
if self.__vol is None: self.__vol = np.eye(process_dim)
self.__initial_time = initial_time
self.__final_time = final_time
npc.check_col(self.__initial_value)
npc.check_col(self.__final_value)
npc.check_nrow(self.__initial_value, process_dim)
npc.check_nrow(self.__final_value, process_dim)
noise_dim = npu.ncol(self.__vol)
self.__cov = stats.vol_to_cov(self.__vol)
npu.make_immutable(self.__initial_value)
npu.make_immutable(self.__final_value)
npu.make_immutable(self.__vol)
npu.make_immutable(self.__cov)
self._to_string_helper_BrownianBridge = None
self._str_BrownianBridge = None
super(BrownianBridge, self).__init__(process_dim=process_dim, noise_dim=noise_dim,
drift=lambda t, x: (self.__final_value - x) / (self.__final_time - t),
diffusion=lambda t, x: self.__vol,
time_unit=time_unit)
def __init__(self, mean=None, vol=None, time_unit=dt.timedelta(days=1)):
if mean is None and vol is None:
mean = 0.
vol = 1.
self._mean, self._vol = None, None
if mean is not None:
self._mean = npu.to_ndim_2(mean, ndim_1_to_col=True, copy=True)
process_dim = npu.nrow(self._mean)
if vol is not None:
self._vol = npu.to_ndim_2(vol, ndim_1_to_col=True, copy=True)
process_dim = npu.nrow(self._vol)
if self._mean is None: self._mean = npu.col_of(process_dim, 0.)
if self._vol is None: self._vol = np.eye(process_dim)
npc.check_col(self._mean)
npc.check_nrow(self._mean, process_dim)
npc.check_nrow(self._vol, process_dim)
noise_dim = npu.ncol(self._vol)
self._cov = stats.vol_to_cov(self._vol)
npu.make_immutable(self._mean)
npu.make_immutable(self._vol)
npu.make_immutable(self._cov)
self._to_string_helper_WienerProcess = None
self._str_WienerProcess = None
super(WienerProcess, self).__init__(process_dim=process_dim,
noise_dim=noise_dim,
drift=lambda t, x: self._mean,
diffusion=lambda t, x: self._vol,
time_unit=time_unit)
def __init__(self,
transition=None,
mean=None,
vol=None,
time_unit=dt.timedelta(days=1)):
if transition is None and mean is None and vol is None:
transition = 1.
mean = 0.
vol = 1.
self._transition, self._mean, self._vol = None, None, None
if transition is not None:
self._transition = npu.to_ndim_2(transition,
ndim_1_to_col=True,
copy=True)
process_dim = npu.nrow(self._transition)
if mean is not None:
self._mean = npu.to_ndim_2(mean, ndim_1_to_col=True, copy=True)
process_dim = npu.nrow(self._mean)
if vol is not None:
self._vol = npu.to_ndim_2(vol, ndim_1_to_col=True, copy=True)
process_dim = npu.nrow(self._vol)
if self._transition is None: self._transition = np.eye(process_dim)
if self._mean is None: self._mean = npu.col_of(process_dim, 0.)
if self._vol is None: self._vol = np.eye(process_dim)
npc.check_square(self._transition)
npc.check_nrow(self._transition, process_dim)
npc.check_col(self._mean)
npc.check_nrow(self._mean, process_dim)
npc.check_nrow(self._vol, process_dim)
noise_dim = npu.ncol(self._vol)
self._transition_x_2 = npu.kron_sum(self._transition, self._transition)
self._transition_x_2_inverse = np.linalg.inv(self._transition_x_2)
self._cov = stats.vol_to_cov(self._vol)
self._cov_vec = npu.vec(self._cov)
self._cached_mean_reversion_factor = None
self._cached_mean_reversion_factor_time_delta = None
self._cached_mean_reversion_factor_squared = None
self._cached_mean_reversion_factor_squared_time_delta = None
npu.make_immutable(self._transition)
npu.make_immutable(self._transition_x_2)
npu.make_immutable(self._transition_x_2_inverse)
npu.make_immutable(self._mean)
npu.make_immutable(self._vol)
npu.make_immutable(self._cov)
npu.make_immutable(self._cov_vec)
self._to_string_helper_OrnsteinUhlenbeckProcess = None
self._str_OrnsteinUhlenbeckProcess = None
super(OrnsteinUhlenbeckProcess, self).__init__(
process_dim=process_dim,
noise_dim=noise_dim,
drift=lambda t, x: -np.dot(self._transition, x - self._mean),
diffusion=lambda t, x: self._vol,
time_unit=time_unit)
def checkncol(arg, ncol, message='Unexpected number of columns: actual=%(actual)d, expected=%(expected)d', level=1):
n = npu.ncol(arg)
check(n == ncol, message=lambda: message % {'actual': n, 'expected': ncol}, level=level)
return arg
def isncol(arg, ncol):
return npu.ncol(arg) == ncol
