class_docstr: This class is used for performing non parametric estimation of
  multi-dimensional Hawkes processes based on expectation maximization
  algorithm and the hypothesis that kernels are linear
  combinations of some basis kernels.
  
  Hawkes processes are point processes defined by the intensity:
  
  .. math::
      \forall i \in [1 \dots D], \quad
      \lambda_i = \mu_i + \sum_{j=1}^D \int \phi_{ij} dN_j
  
  where
  
  * :math:`D` is the number of nodes
  * :math:`\mu_i` are the baseline intensities
  * :math:`\phi_{ij}` are the kernels
  
  The basis kernel hypothesis translates to:
  
  .. math::
      \phi_{ij}(t) = \sum_{u}^U a_{ij}^u g^u(t)
  
  where
  
  * :math:`U` is the number of basis kernels.
  * :math:`g^u` is a basis kernel
  * :math:`a_{ij}^u` is the amplitude of basis kernel :math:`u` in kernel
    :math:`\phi_{ij}`
  
  Finally we also suppose that basis kernels :math:`g^u` are piecewise
  constant on a given support and number of intervals.
  
  Parameters
  ----------
  kernel_support : `float`
      The support size common to all the kernels.
  
  n_basis : `int`, default=`None`
      Number of non parametric basis kernels to be used.
      If `None` or 0, it will be set to `n_nodes`
  
  kernel_size : `int`, default=10
      Number of discretizations of the kernel
  
  C : `float`, default=1e-1
      The penalization parameter. It penalizes both the amplitudes
      squared values and the basis kernels smoothness through the
      integral of their squared derivative.
  
  tol : `float`, default=1e-5
      The tolerance of the solver (iterations stop when the stopping
      criterion is below it). If not reached the solver does ``max_iter``
      iterations
  
  max_iter : `int`, default=100
      Maximum number of iterations of the solver
  
  verbose : `bool`, default=False
      If `True`, we verbose things, otherwise the solver does not
      print anything (but records information in history anyway)
  
  print_every : `int`, default=10
      Print history information when ``n_iter`` (iteration number) is
      a multiple of ``print_every``
  
  record_every : `int`, default=10
      Record history information when ``n_iter`` (iteration number) is
      a multiple of ``record_every``
  
  n_threads : `int`, default=1
      Number of threads used for parallel computation.
  
      * if `int <= 0`: the number of physical cores available on the CPU
      * otherwise the desired number of threads
  
  Other Parameters
  ----------------
  ode_max_iter : `int`, default=100
      Maximum number of loop for inner ODE (ordinary differential equation)
      algorithm.
  
  ode_tol : `float`, default=1e-5
      Tolerance of loop for inner inner ODE (ordinary differential equation)
      algorithm.
  
  Attributes
  ----------
  n_nodes : `int`
      Number of nodes of the estimated Hawkes process
  
  n_realizations : `int`
      Number of given realizations`
  
  baseline : `np.array` shape=(n_nodes)
      The estimated baseline
  
  amplitudes : `np.array` shape=(n_nodes, n_nodes, n_basis)
      Amplitudes of all basis kernels for all kernels.
  
  basis_kernels : `np.array` shape=(n_basis, kernel_size)
      Estimated basis kernels
  
  kernel_dt : `float`
      Kernel discretization step. It is equal to
      `kernel_support` / `kernel_size`
  
  kernel_discretization : `np.ndarray`, shape=(kernel_size + 1, )
      Kernel discretizations points, denotes the interval on which basis
      kernels are piecewise constant.
  
  References
  ----------
  Zhou, K., Zha, H. and Song, L., 2013, June. Learning Triggering Kernels for
  Multi-dimensional Hawkes Processes. In `ICML (3) (pp. 1301-1309)`_.
  
  Some rewriting notes for implementing the algorithm can be found in the
  doc/tex directory.
  
  .. _ICML (3) (pp. 1301-1309): http://jmlr.org/proceedings/papers/v28/zhou13.html
docstr: Computes value of the specified kernel on given time values. This
  makes our learner compliant with `tick.plot.plot_hawkes_kernels` API
  
  Parameters
  ----------
  i : `int`
      First index of the kernel
  
  j : `int`
      Second index of the kernel
  
  abscissa_array : `np.ndarray`, shape=(n_points, )
      1d array containing all the times at which this kernel will
      computes it value
  
  Returns
  -------
  output : `np.ndarray`, shape=(n_points, )
      1d array containing the values of the specified kernels at the
      given times.
docstr_tok: ["Computes","value","of","the","specified","kernel","on","given","time","values",".","This","makes","our","learner","compliant","with","`","tick.plot.plot_hawkes_kernels","`","API","Parameters","--","--","--","--","--","i",":","`","int","`","First","index","of","the","kernel","j",":","`","int","`","Second","index","of","the","kernel","abscissa_array",":","`","np.ndarray","`",",","shape=","(","n_points",",",")","1d","array","containing","all","the","times","at","which","this","kernel","will","computes","it","value","Returns","--","--","--","-","output",":","`","np.ndarray","`",",","shape=","(","n_points",",",")","1d","array","containing","the","values","of","the","specified","kernels","at","the","given","times","."]
code: def get_kernel_values(self, i, j, abscissa_array):
      """Computes value of the specified kernel on given time values. This
      makes our learner compliant with `tick.plot.plot_hawkes_kernels` API
  
      Parameters
      ----------
      i : `int`
          First index of the kernel
  
      j : `int`
          Second index of the kernel
  
      abscissa_array : `np.ndarray`, shape=(n_points, )
          1d array containing all the times at which this kernel will
          computes it value
  
      Returns
      -------
      output : `np.ndarray`, shape=(n_points, )
          1d array containing the values of the specified kernels at the
          given times.
      """
      indices_in_support = (abscissa_array > 0) & (
          abscissa_array < self.kernel_support
      )
      index = (
          np.searchsorted(
              self.kernel_discretization,
              abscissa_array[indices_in_support],
          )
          - 1
      )
  
      kernel_values = np.empty_like(abscissa_array)
      kernel_values[np.invert(indices_in_support)] = 0
  
      kernels_ij_sum = np.zeros(self.kernel_size)
      for d in range(self.n_basis):
          kernels_ij_sum += (
              self.amplitudes[i, j, d] * self.basis_kernels[d]
          )
  
      kernel_values[indices_in_support] = kernels_ij_sum[index]
      return kernel_values
  
imports: import numpy
  from tick.hawkes.inference.base import LearnerHawkesNoParam
  from tick.hawkes.inference.build.hawkes_inference import HawkesBasisKernels
  from tick.solver.base.utils import relative_distance
label_desc: Use image node_id 5 for calling the HawkesBasisKernels obj's underlying member method code with example usage: obj.get_kernel_values(i, j, abscissa_array) and returns: kernel_values