parameters: (X, y, n_nonzero_coefs, tol=None, copy_X=True,
                    return_path=False)
docstring: Orthogonal Matching Pursuit step using the Cholesky decomposition.
  
      Parameters
      ----------
      X : array, shape (n_samples, n_features)
          Input dictionary. Columns are assumed to have unit norm.
  
      y : array, shape (n_samples,)
          Input targets
  
      n_nonzero_coefs : int
          Targeted number of non-zero elements
  
      tol : float
          Targeted squared error, if not None overrides n_nonzero_coefs.
  
      copy_X : bool, optional
          Whether the design matrix X must be copied by the algorithm. A false
          value is only helpful if X is already Fortran-ordered, otherwise a
          copy is made anyway.
  
      return_path : bool, optional. Default: False
          Whether to return every value of the nonzero coefficients along the
          forward path. Useful for cross-validation.
  
      Returns
      -------
      gamma : array, shape (n_nonzero_coefs,)
          Non-zero elements of the solution
  
      idx : array, shape (n_nonzero_coefs,)
          Indices of the positions of the elements in gamma within the solution
          vector
  
      coef : array, shape (n_features, n_nonzero_coefs)
          The first k values of column k correspond to the coefficient value
          for the active features at that step. The lower left triangle contains
          garbage. Only returned if ``return_path=True``.
  
      n_active : int
          Number of active features at convergence.
docstring_summary: Orthogonal Matching Pursuit step using the Cholesky decomposition.
docstring_tokens: Orthogonal Matching Pursuit step using the Cholesky decomposition .
function: def _cholesky_omp(X, y, n_nonzero_coefs, tol=None, copy_X=True,
                    return_path=False):
      """Orthogonal Matching Pursuit step using the Cholesky decomposition.
  
      Parameters
      ----------
      X : array, shape (n_samples, n_features)
          Input dictionary. Columns are assumed to have unit norm.
  
      y : array, shape (n_samples,)
          Input targets
  
      n_nonzero_coefs : int
          Targeted number of non-zero elements
  
      tol : float
          Targeted squared error, if not None overrides n_nonzero_coefs.
  
      copy_X : bool, optional
          Whether the design matrix X must be copied by the algorithm. A false
          value is only helpful if X is already Fortran-ordered, otherwise a
          copy is made anyway.
  
      return_path : bool, optional. Default: False
          Whether to return every value of the nonzero coefficients along the
          forward path. Useful for cross-validation.
  
      Returns
      -------
      gamma : array, shape (n_nonzero_coefs,)
          Non-zero elements of the solution
  
      idx : array, shape (n_nonzero_coefs,)
          Indices of the positions of the elements in gamma within the solution
          vector
  
      coef : array, shape (n_features, n_nonzero_coefs)
          The first k values of column k correspond to the coefficient value
          for the active features at that step. The lower left triangle contains
          garbage. Only returned if ``return_path=True``.
  
      n_active : int
          Number of active features at convergence.
      """
      if copy_X:
          X = X.copy('F')
      else:  # even if we are allowed to overwrite, still copy it if bad order
          X = np.asfortranarray(X)
  
      min_float = np.finfo(X.dtype).eps
      nrm2, swap = linalg.get_blas_funcs(('nrm2', 'swap'), (X,))
      potrs, = get_lapack_funcs(('potrs',), (X,))
  
      alpha = np.dot(X.T, y)
      residual = y
      gamma = np.empty(0)
      n_active = 0
      indices = np.arange(X.shape[1])  # keeping track of swapping
  
      max_features = X.shape[1] if tol is not None else n_nonzero_coefs
      if solve_triangular_args:
          # new scipy, don't need to initialize because check_finite=False
          L = np.empty((max_features, max_features), dtype=X.dtype)
      else:
          # old scipy, we need the garbage upper triangle to be non-Inf
          L = np.zeros((max_features, max_features), dtype=X.dtype)
  
      L[0, 0] = 1.
      if return_path:
          coefs = np.empty_like(L)
  
      while True:
          lam = np.argmax(np.abs(np.dot(X.T, residual)))
          if lam < n_active or alpha[lam] ** 2 < min_float:
              # atom already selected or inner product too small
              warnings.warn(premature, RuntimeWarning, stacklevel=2)
              break
          if n_active > 0:
              # Updates the Cholesky decomposition of X' X
              L[n_active, :n_active] = np.dot(X[:, :n_active].T, X[:, lam])
              linalg.solve_triangular(L[:n_active, :n_active],
                                      L[n_active, :n_active],
                                      trans=0, lower=1,
                                      overwrite_b=True,
                                      **solve_triangular_args)
              v = nrm2(L[n_active, :n_active]) ** 2
              if 1 - v <= min_float:  # selected atoms are dependent
                  warnings.warn(premature, RuntimeWarning, stacklevel=2)
                  break
              L[n_active, n_active] = np.sqrt(1 - v)
          X.T[n_active], X.T[lam] = swap(X.T[n_active], X.T[lam])
          alpha[n_active], alpha[lam] = alpha[lam], alpha[n_active]
          indices[n_active], indices[lam] = indices[lam], indices[n_active]
          n_active += 1
          # solves LL'x = y as a composition of two triangular systems
          gamma, _ = potrs(L[:n_active, :n_active], alpha[:n_active], lower=True,
                           overwrite_b=False)
          if return_path:
              coefs[:n_active, n_active - 1] = gamma
          residual = y - np.dot(X[:, :n_active], gamma)
          if tol is not None and nrm2(residual) ** 2 <= tol:
              break
          elif n_active == max_features:
              break
  
      if return_path:
          return gamma, indices[:n_active], coefs[:, :n_active], n_active
      else:
          return gamma, indices[:n_active], n_active
function_tokens: def _cholesky_omp ( X , y , n_nonzero_coefs , tol = None , copy_X = True , return_path = False ) : if copy_X : X = X . copy ( 'F' ) else : # even if we are allowed to overwrite, still copy it if bad order X = np . asfortranarray ( X ) min_float = np . finfo ( X . dtype ) . eps nrm2 , swap = linalg . get_blas_funcs ( ( 'nrm2' , 'swap' ) , ( X , ) ) potrs , = get_lapack_funcs ( ( 'potrs' , ) , ( X , ) ) alpha = np . dot ( X . T , y ) residual = y gamma = np . empty ( 0 ) n_active = 0 indices = np . arange ( X . shape [ 1 ] ) # keeping track of swapping max_features = X . shape [ 1 ] if tol is not None else n_nonzero_coefs if solve_triangular_args : # new scipy, don't need to initialize because check_finite=False L = np . empty ( ( max_features , max_features ) , dtype = X . dtype ) else : # old scipy, we need the garbage upper triangle to be non-Inf L = np . zeros ( ( max_features , max_features ) , dtype = X . dtype ) L [ 0 , 0 ] = 1. if return_path : coefs = np . empty_like ( L ) while True : lam = np . argmax ( np . abs ( np . dot ( X . T , residual ) ) ) if lam < n_active or alpha [ lam ] ** 2 < min_float : # atom already selected or inner product too small warnings . warn ( premature , RuntimeWarning , stacklevel = 2 ) break if n_active > 0 : # Updates the Cholesky decomposition of X' X L [ n_active , : n_active ] = np . dot ( X [ : , : n_active ] . T , X [ : , lam ] ) linalg . solve_triangular ( L [ : n_active , : n_active ] , L [ n_active , : n_active ] , trans = 0 , lower = 1 , overwrite_b = True , * * solve_triangular_args ) v = nrm2 ( L [ n_active , : n_active ] ) ** 2 if 1 - v <= min_float : # selected atoms are dependent warnings . warn ( premature , RuntimeWarning , stacklevel = 2 ) break L [ n_active , n_active ] = np . sqrt ( 1 - v ) X . T [ n_active ] , X . T [ lam ] = swap ( X . T [ n_active ] , X . T [ lam ] ) alpha [ n_active ] , alpha [ lam ] = alpha [ lam ] , alpha [ n_active ] indices [ n_active ] , indices [ lam ] = indices [ lam ] , indices [ n_active ] n_active += 1 # solves LL'x = y as a composition of two triangular systems gamma , _ = potrs ( L [ : n_active , : n_active ] , alpha [ : n_active ] , lower = True , overwrite_b = False ) if return_path : coefs [ : n_active , n_active - 1 ] = gamma residual = y - np . dot ( X [ : , : n_active ] , gamma ) if tol is not None and nrm2 ( residual ) ** 2 <= tol : break elif n_active == max_features : break if return_path : return gamma , indices [ : n_active ] , coefs [ : , : n_active ] , n_active else : return gamma , indices [ : n_active ] , n_active