code: def __init__(
      self,
      n,
      k,
      tp,
      matvec,
      mode=1,
      M_matvec=None,
      Minv_matvec=None,
      sigma=None,
      ncv=None,
      v0=None,
      maxiter=None,
      which="LM",
      tol=0,
  ):
      # The following modes are supported:
      #  mode = 1:
      #    Solve the standard eigenvalue problem:
      #      A*x = lambda*x :
      #       A - symmetric
      #    Arguments should be
      #       matvec      = left multiplication by A
      #       M_matvec    = None [not used]
      #       Minv_matvec = None [not used]
      #
      #  mode = 2:
      #    Solve the general eigenvalue problem:
      #      A*x = lambda*M*x
      #       A - symmetric
      #       M - symmetric positive definite
      #    Arguments should be
      #       matvec      = left multiplication by A
      #       M_matvec    = left multiplication by M
      #       Minv_matvec = left multiplication by M^-1
      #
      #  mode = 3:
      #    Solve the general eigenvalue problem in shift-invert mode:
      #      A*x = lambda*M*x
      #       A - symmetric
      #       M - symmetric positive semi-definite
      #    Arguments should be
      #       matvec      = None [not used]
      #       M_matvec    = left multiplication by M
      #                     or None, if M is the identity
      #       Minv_matvec = left multiplication by [A-sigma*M]^-1
      #
      #  mode = 4:
      #    Solve the general eigenvalue problem in Buckling mode:
      #      A*x = lambda*AG*x
      #       A  - symmetric positive semi-definite
      #       AG - symmetric indefinite
      #    Arguments should be
      #       matvec      = left multiplication by A
      #       M_matvec    = None [not used]
      #       Minv_matvec = left multiplication by [A-sigma*AG]^-1
      #
      #  mode = 5:
      #    Solve the general eigenvalue problem in Cayley-transformed mode:
      #      A*x = lambda*M*x
      #       A - symmetric
      #       M - symmetric positive semi-definite
      #    Arguments should be
      #       matvec      = left multiplication by A
      #       M_matvec    = left multiplication by M
      #                     or None, if M is the identity
      #       Minv_matvec = left multiplication by [A-sigma*M]^-1
      if mode == 1:
          if matvec is None:
              raise ValueError("matvec must be specified for mode=1")
          if M_matvec is not None:
              raise ValueError(
                  "M_matvec cannot be specified for mode=1"
              )
          if Minv_matvec is not None:
              raise ValueError(
                  "Minv_matvec cannot be specified for mode=1"
              )
  
          self.OP = matvec
          self.B = lambda x: x
          self.bmat = "I"
      elif mode == 2:
          if matvec is None:
              raise ValueError("matvec must be specified for mode=2")
          if M_matvec is None:
              raise ValueError("M_matvec must be specified for mode=2")
          if Minv_matvec is None:
              raise ValueError(
                  "Minv_matvec must be specified for mode=2"
              )
  
          self.OP = lambda x: Minv_matvec(matvec(x))
          self.OPa = Minv_matvec
          self.OPb = matvec
          self.B = M_matvec
          self.bmat = "G"
      elif mode == 3:
          if matvec is not None:
              raise ValueError(
                  "matvec must not be specified for mode=3"
              )
          if Minv_matvec is None:
              raise ValueError(
                  "Minv_matvec must be specified for mode=3"
              )
  
          if M_matvec is None:
              self.OP = Minv_matvec
              self.OPa = Minv_matvec
              self.B = lambda x: x
              self.bmat = "I"
          else:
              self.OP = lambda x: Minv_matvec(M_matvec(x))
              self.OPa = Minv_matvec
              self.B = M_matvec
              self.bmat = "G"
      elif mode == 4:
          if matvec is None:
              raise ValueError("matvec must be specified for mode=4")
          if M_matvec is not None:
              raise ValueError(
                  "M_matvec must not be specified for mode=4"
              )
          if Minv_matvec is None:
              raise ValueError(
                  "Minv_matvec must be specified for mode=4"
              )
          self.OPa = Minv_matvec
          self.OP = lambda x: self.OPa(matvec(x))
          self.B = matvec
          self.bmat = "G"
      elif mode == 5:
          if matvec is None:
              raise ValueError("matvec must be specified for mode=5")
          if Minv_matvec is None:
              raise ValueError(
                  "Minv_matvec must be specified for mode=5"
              )
  
          self.OPa = Minv_matvec
          self.A_matvec = matvec
  
          if M_matvec is None:
              self.OP = lambda x: Minv_matvec(matvec(x) + sigma * x)
              self.B = lambda x: x
              self.bmat = "I"
          else:
              self.OP = lambda x: Minv_matvec(
                  matvec(x) + sigma * M_matvec(x)
              )
              self.B = M_matvec
              self.bmat = "G"
      else:
          raise ValueError("mode=%i not implemented" % mode)
  
      if which not in _SEUPD_WHICH:
          raise ValueError(
              "which must be one of %s" % " ".join(_SEUPD_WHICH)
          )
      if k >= n:
          raise ValueError("k must be less than ndim(A), k=%d" % k)
  
      _ArpackParams.__init__(
          self, n, k, tp, mode, sigma, ncv, v0, maxiter, which, tol
      )
  
      if self.ncv > n or self.ncv <= k:
          raise ValueError("ncv must be k<ncv<=n, ncv=%s" % self.ncv)
  
      # Use _aligned_zeros to work around a f2py bug in Numpy 1.9.1
      self.workd = _aligned_zeros(3 * n, self.tp)
      self.workl = _aligned_zeros(self.ncv * (self.ncv + 8), self.tp)
  
      ltr = _type_conv[self.tp]
      if ltr not in ["s", "d"]:
          raise ValueError("Input matrix is not real-valued.")
  
      self._arpack_solver = _arpack.__dict__[ltr + "saupd"]
      self._arpack_extract = _arpack.__dict__[ltr + "seupd"]
  
      self.iterate_infodict = _SAUPD_ERRORS[ltr]
      self.extract_infodict = _SEUPD_ERRORS[ltr]
  
      self.ipntr = np.zeros(11, "int")
  
imports: from scipy.sparse.linalg.eigen.arpack import _arpack
  import numpy
  from scipy.sparse.linalg.interface import aslinearoperator, LinearOperator
  from scipy.sparse import identity, isspmatrix, isspmatrix_csr
  from scipy.linalg import lu_factor, lu_solve
  from scipy.sparse.sputils import isdense
  from scipy.sparse.linalg import gmres, splu
  import scipy
  import functools
  import operator
  from distutils.version import LooseVersion
label_desc: Use image node_id 1 to create a new _SymmetricArpackParams object from inherited base classes: _ArpackParams with example: obj = _SymmetricArpackParams(n, k, tp, matvec, mode, M_matvec, Minv_matvec, sigma, ncv, v0, maxiter, which, tol)