code: def compute(self, x, yerr=0.0, **kwargs):
          
          # Parse the input coordinates and ensure the right memory layout.
          self._x = self.parse_samples(x)
          self._x = np.ascontiguousarray(self._x, dtype=np.float64)
          try:
              self._yerr2 = float(yerr)**2 * np.ones(len(x))
          except TypeError:
              self._yerr2 = self._check_dimensions(yerr) ** 2
          self._yerr2 = np.ascontiguousarray(self._yerr2, dtype=np.float64)
  
          # Set up and pre-compute the solver.
          self.solver = self.solver_type(self.kernel, **(self.solver_kwargs))
  
          # Include the white noise term.
          yerr = np.sqrt(self._yerr2 + np.exp(self._call_white_noise(self._x)))
          self.solver.compute(self._x, yerr, **kwargs)
  
          self._const = -0.5 * (len(self._x) * np.log(2 * np.pi) +
                                self.solver.log_determinant)
          self.computed = True
          self._alpha = None
docs: Pre-compute the covariance matrix and factorize it for a set of times
          and uncertainties.
  
          :param x: ``(nsamples,)`` or ``(nsamples, ndim)``
              The independent coordinates of the data points.
  
          :param yerr: (optional) ``(nsamples,)`` or scalar
              The Gaussian uncertainties on the data points at coordinates
              ``x``. These values will be added in quadrature to the diagonal of
              the covariance matrix.