code: def onenormest(A, t=2, itmax=5, compute_v=False, compute_w=False):
      """
      Compute a lower bound of the 1-norm of a sparse matrix.
  
      Parameters
      ----------
      A : ndarray or other linear operator
          A linear operator that can be transposed and that can
          produce matrix products.
      t : int, optional
          A positive parameter controlling the tradeoff between
          accuracy versus time and memory usage.
          Larger values take longer and use more memory
          but give more accurate output.
      itmax : int, optional
          Use at most this many iterations.
      compute_v : bool, optional
          Request a norm-maximizing linear operator input vector if True.
      compute_w : bool, optional
          Request a norm-maximizing linear operator output vector if True.
  
      Returns
      -------
      est : float
          An underestimate of the 1-norm of the sparse matrix.
      v : ndarray, optional
          The vector such that ||Av||_1 == est*||v||_1.
          It can be thought of as an input to the linear operator
          that gives an output with particularly large norm.
      w : ndarray, optional
          The vector Av which has relatively large 1-norm.
          It can be thought of as an output of the linear operator
          that is relatively large in norm compared to the input.
  
      Notes
      -----
      This is algorithm 2.4 of [1].
  
      In [2] it is described as follows.
      "This algorithm typically requires the evaluation of
      about 4t matrix-vector products and almost invariably
      produces a norm estimate (which is, in fact, a lower
      bound on the norm) correct to within a factor 3."
  
      .. versionadded:: 0.13.0
  
      References
      ----------
      .. [1] Nicholas J. Higham and Francoise Tisseur (2000),
             "A Block Algorithm for Matrix 1-Norm Estimation,
             with an Application to 1-Norm Pseudospectra."
             SIAM J. Matrix Anal. Appl. Vol. 21, No. 4, pp. 1185-1201.
  
      .. [2] Awad H. Al-Mohy and Nicholas J. Higham (2009),
             "A new scaling and squaring algorithm for the matrix exponential."
             SIAM J. Matrix Anal. Appl. Vol. 31, No. 3, pp. 970-989.
  
      Examples
      --------
      >>> import numpy as np
      >>> from scipy.sparse import csc_matrix
      >>> from scipy.sparse.linalg import onenormest
      >>> A = csc_matrix([[1., 0., 0.], [5., 8., 2.], [0., -1., 0.]], dtype=float)
      >>> A.toarray()
      array([[ 1.,  0.,  0.],
             [ 5.,  8.,  2.],
             [ 0., -1.,  0.]])
      >>> onenormest(A)
      9.0
      >>> np.linalg.norm(A.toarray(), ord=1)
      9.0
      """
  
      # Check the input.
      A = aslinearoperator(A)
      if A.shape[0] != A.shape[1]:
          raise ValueError(
              "expected the operator to act like a square matrix"
          )
  
      # If the operator size is small compared to t,
      # then it is easier to compute the exact norm.
      # Otherwise estimate the norm.
      n = A.shape[1]
      if t >= n:
          A_explicit = np.asarray(
              aslinearoperator(A).matmat(np.identity(n))
          )
          if A_explicit.shape != (n, n):
              raise Exception(
                  "internal error: ",
                  "unexpected shape " + str(A_explicit.shape),
              )
          col_abs_sums = abs(A_explicit).sum(axis=0)
          if col_abs_sums.shape != (n,):
              raise Exception(
                  "internal error: ",
                  "unexpected shape " + str(col_abs_sums.shape),
              )
          argmax_j = np.argmax(col_abs_sums)
          v = elementary_vector(n, argmax_j)
          w = A_explicit[:, argmax_j]
          est = col_abs_sums[argmax_j]
      else:
          est, v, w, nmults, nresamples = _onenormest_core(
              A, A.H, t, itmax
          )
  
      # Report the norm estimate along with some certificates of the estimate.
      if compute_v or compute_w:
          result = (est,)
          if compute_v:
              result += (v,)
          if compute_w:
              result += (w,)
          return result
      else:
          return est
  
file_path: scipy/scipy/sparse/linalg/_onenormest.py
imports: import numpy
  from scipy.sparse.linalg import aslinearoperator
label_desc: Use image node_id 1 for calling a global function with example usage: onenormest(A, t, itmax, compute_v, compute_w) and returns: result, est