code: def get_matrix(self, x1=None, x2=None, include_diagonal=None,
                     include_general=None):
          
          if x1 is None and x2 is None:
              if self._t is None or not self.computed:
                  raise RuntimeError("you must call 'compute' first")
              K = self.kernel.get_value(self._t[:, None] - self._t[None, :])
              if include_diagonal is None or include_diagonal:
                  K[np.diag_indices_from(K)] += (
                      self._yerr**2 + self.kernel.jitter
                  )
              if (include_general is None or include_general) and len(self._A):
                  K[np.diag_indices_from(K)] += self._A
                  K += np.tril(np.dot(self._U.T, self._V), -1)
                  K += np.triu(np.dot(self._V.T, self._U), 1)
              return K
  
          incl = False
          x1 = np.ascontiguousarray(x1, dtype=float)
          if x2 is None:
              x2 = x1
              incl = include_diagonal is not None and include_diagonal
          K = self.kernel.get_value(x1[:, None] - x2[None, :])
          if incl:
              K[np.diag_indices_from(K)] += self.kernel.jitter
          return K
docs: Get the covariance matrix at given independent coordinates
  
          Args:
              x1 (Optional[array[n1]]): The first set of independent coordinates.
                  If this is omitted, ``x1`` will be assumed to be equal to ``x``
                  from a previous call to :func:`GP.compute`.
              x2 (Optional[array[n2]]): The second set of independent
                  coordinates. If this is omitted, ``x2`` will be assumed to be
                  ``x1``.
              include_diagonal (Optional[bool]): Should the white noise and
                  ``yerr`` terms be included on the diagonal?
                  (default: ``False``)