def __init__(self,
kernels=None,
baseline=None,
n_nodes=None,
end_time=None,
max_jumps=None,
seed=None,
verbose=True,
force_simulation=False):
SimuPointProcess.__init__(self,
end_time=end_time,
max_jumps=max_jumps,
seed=seed,
verbose=verbose)
self.force_simulation = force_simulation
# We keep a reference on this kernel to avoid copies
self._kernel_0 = HawkesKernel0()
if isinstance(kernels, list):
kernels = np.array(kernels)
if isinstance(baseline, list):
baseline = np.array(baseline)
if baseline is not None and baseline.dtype != float:
baseline = baseline.astype(float)
self.check_parameters_coherence(kernels, baseline, n_nodes)
# Init _pp so we hae access to self.n_nodes
if n_nodes is None:
if baseline is not None:
n_nodes = baseline.shape[0]
else:
n_nodes = kernels.shape[0]
if n_nodes <= 0:
raise ValueError("n_nodes must be positive but equals %i" %
n_nodes)
self._pp = _Hawkes(n_nodes, self._pp_init_seed)
if kernels is not None:
if kernels.shape != (self.n_nodes, self.n_nodes):
raise ValueError("kernels shape should be %s instead of %s" %
((self.n_nodes, self.n_nodes), kernels.shape))
self.kernels = kernels
self._init_kernels()
else:
self._init_zero_kernels()
if baseline is not None:
if baseline.shape != (self.n_nodes, ):
raise ValueError("baseline shape should be %s instead of %s" %
((self.n_nodes, ), self.baseline.shape))
self.baseline = baseline
self._init_baseline()
else:
self._init_zero_baseline()
def __init__(self, intensities_functions, end_time=None, max_jumps=None,
seed=None, verbose=True):
SimuPointProcess.__init__(self, end_time=end_time, max_jumps=max_jumps,
seed=seed, verbose=verbose)
cpp_obj_list = [intensity_function._time_function
for intensity_function in intensities_functions]
self._pp = _InhomogeneousPoisson(cpp_obj_list, self._pp_init_seed)
def _simulate(self):
"""Launch simulation of the Hawkes process by thinning
"""
if self.baseline.dtype == float and np.linalg.norm(self.baseline) == 0:
warnings.warn("Baselines have not been set, hence this hawkes "
"process won't jump")
if not self.force_simulation and self.spectral_radius() >= 1 \
and self.max_jumps is None:
raise ValueError("Simulation not launched as this Hawkes process "
"is not stable (spectral radius of %.2g). You "
"can use force_simulation parameter if you "
"really want to simulate it" %
self.spectral_radius())
SimuPointProcess._simulate(self)
def __init__(self,
intensities,
end_time=None,
max_jumps=None,
verbose=True,
seed=None):
SimuPointProcess.__init__(self,
end_time=end_time,
max_jumps=max_jumps,
seed=seed,
verbose=verbose)
if intensities.__class__ == list:
intensities = np.array(intensities, dtype=float)
if intensities.__class__ == np.ndarray and intensities.dtype != float:
intensities = intensities.astype(float)
self._pp = _Poisson(intensities, self._pp_init_seed)
def __init__(self,
kernels=None,
baseline=None,
n_nodes=None,
end_time=None,
period_length=None,
max_jumps=None,
seed=None,
verbose=True,
force_simulation=False):
SimuPointProcess.__init__(self,
end_time=end_time,
max_jumps=max_jumps,
seed=seed,
verbose=verbose)
self.force_simulation = force_simulation
# We keep a reference on this kernel to avoid copies
self._kernel_0 = HawkesKernel0()
self.period_length = period_length
if isinstance(kernels, list):
kernels = np.array(kernels)
if isinstance(baseline, list):
baseline = np.asarray(baseline)
if baseline is not None:
if baseline.dtype not in [float, object]:
baseline = baseline.astype(float)
self.check_parameters_coherence(kernels, baseline, n_nodes)
# Init _pp so we have access to self.n_nodes
if n_nodes is None:
if baseline is not None:
n_nodes = baseline.shape[0]
else:
n_nodes = kernels.shape[0]
if n_nodes <= 0:
raise ValueError("n_nodes must be positive but equals %i" %
n_nodes)
self._pp = _Hawkes(n_nodes, self._pp_init_seed)
if kernels is not None:
if kernels.shape != (self.n_nodes, self.n_nodes):
raise ValueError("kernels shape should be %s instead of %s" %
((self.n_nodes, self.n_nodes), kernels.shape))
self.kernels = kernels
self._init_kernels()
else:
self._init_zero_kernels()
if baseline is not None:
if baseline.shape[0] != self.n_nodes:
raise ValueError(
"baseline length should be {} instead of {}".format(
self.n_nodes, baseline.shape[0]))
if len(baseline.shape) > 2:
raise ValueError("baseline should have at most {} dimensions, "
"it currently has".format(
2, len(baseline.shape)))
self.baseline = baseline
self._init_baseline()
else:
self._init_zero_baseline()