def test_gaussian_noise_sample_at(t, times): instance = GaussianNoise(t) s = instance.sample_at(times) if times[0] == 0: assert len(s) == len(times) - 1 else: assert len(s) == len(times)
class VarianceGammaProcess(Continuous): r"""Variance Gamma process. .. image:: _static/variance_gamma_process.png :scale: 50% A variance gamma process has independent increments which follow the variance-gamma distribution. It can be represented as a Brownian motion with drift subordinated by a Gamma process: .. math:: \theta \Gamma(t; 1, \nu) + \sigma W(\Gamma(t; 1, \nu)) :param float t: the right hand endpoint of the time interval :math:`[0,t]` for the process :param float drift: the drift parameter of the Brownian motion, or :math:`\theta` above :param float variance: the variance parameter of the Gamma subordinator, or :math:`\nu` above :param float scale: the scale parameter of the Brownian motion, or :math:`\sigma` above """ def __init__(self, t=1, drift=0, variance=1, scale=1): super(VarianceGammaProcess, self).__init__(t) self.drift = drift self.variance = variance self.scale = scale self.gn = GaussianNoise(t) @property def drift(self): """Drift parameter.""" return self._drift @drift.setter def drift(self, value): self._check_number(value, "Drift") self._drift = value @property def variance(self): """Variance parameter.""" return self._variance @variance.setter def variance(self, value): self._check_positive_number(value, "Variance") self._variance = value @property def scale(self): """Scale parameter.""" return self._scale @scale.setter def scale(self, value): self._check_positive_number(value, "Scale") self._scale = value def _sample_variance_gamma_process(self, n, zero=True): """Generate a realization of a variance gamma process.""" self._check_increments(n) self._check_zero(zero) delta_t = 1.0 * self.t / n shape = delta_t / self.variance scale = self.variance gammas = np.random.gamma(shape=shape, scale=scale, size=n) gn = self.gn.sample(n) increments = self.drift * gammas + self.scale * np.sqrt(gammas) * gn samples = np.cumsum(increments) if zero: return np.concatenate(([0], samples)) else: return samples def _sample_variance_gamma_process_at(self, times): """Generate a realization of a variance gamma process.""" if times[0] != 0: zero = False times = np.array([0] + list(times)) else: zero = True shapes = np.diff(times) / self.variance scale = self.variance gammas = np.array([ np.random.gamma(shape=shape, scale=scale, size=1)[0] for shape in shapes ]) gn = self.gn.sample_at(times) increments = self.drift * gammas + self.scale * np.sqrt(gammas) * gn samples = np.cumsum(increments) if zero: samples = np.insert(samples, 0, [0]) return samples def sample(self, n, zero=True): """Generate a realization. :param int n: the number of increments to generate :param bool zero: if True, include :math:`t=0` """ return self._sample_variance_gamma_process(n, zero) def sample_at(self, times): """Generate a realization using specified times. :param times: a vector of increasing time values at which to generate the realization """ return self._sample_variance_gamma_process_at(times)