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 - square matrix
      #    Arguments should be
      #       matvec      = left multiplication by A
      #       M_matvec    = None [not used]
      #       Minv_matvec = None [not used]
      #
      #  mode = 2:
      #    Solve the generalized eigenvalue problem:
      #      A*x = lambda*M*x
      #       A - square matrix
      #       M - symmetric, positive semi-definite
      #    Arguments should be
      #       matvec      = left multiplication by A
      #       M_matvec    = left multiplication by M
      #       Minv_matvec = left multiplication by M^-1
      #
      #  mode = 3,4:
      #    Solve the general eigenvalue problem in shift-invert mode:
      #      A*x = lambda*M*x
      #       A - square matrix
      #       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
      #    if A is real and mode==3, use the real part of Minv_matvec
      #    if A is real and mode==4, use the imag part of Minv_matvec
      #    if A is complex and mode==3,
      #       use real and imag parts of Minv_matvec
      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 in (3, 4):
          if matvec is None:
              raise ValueError(
                  "matvec must be specified " "for mode in (3,4)"
              )
          if Minv_matvec is None:
              raise ValueError(
                  "Minv_matvec must be specified " "for mode in (3,4)"
              )
  
          self.matvec = matvec
          if tp in "DF":  # complex type
              if mode == 3:
                  self.OPa = Minv_matvec
              else:
                  raise ValueError("mode=4 invalid for complex A")
          else:  # real type
              if mode == 3:
                  self.OPa = lambda x: np.real(Minv_matvec(x))
              else:
                  self.OPa = lambda x: np.imag(Minv_matvec(x))
          if M_matvec is None:
              self.B = lambda x: x
              self.bmat = "I"
              self.OP = self.OPa
          else:
              self.B = M_matvec
              self.bmat = "G"
              self.OP = lambda x: self.OPa(M_matvec(x))
      else:
          raise ValueError("mode=%i not implemented" % mode)
  
      if which not in _NEUPD_WHICH:
          raise ValueError(
              "Parameter which must be one of %s"
              % " ".join(_NEUPD_WHICH)
          )
      if k >= n - 1:
          raise ValueError("k must be less than ndim(A)-1, k=%d" % k)
  
      _ArpackParams.__init__(
          self, n, k, tp, mode, sigma, ncv, v0, maxiter, which, tol
      )
  
      if self.ncv > n or self.ncv <= k + 1:
          raise ValueError("ncv must be k+1<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(
          3 * self.ncv * (self.ncv + 2), self.tp
      )
  
      ltr = _type_conv[self.tp]
      self._arpack_solver = _arpack.__dict__[ltr + "naupd"]
      self._arpack_extract = _arpack.__dict__[ltr + "neupd"]
  
      self.iterate_infodict = _NAUPD_ERRORS[ltr]
      self.extract_infodict = _NEUPD_ERRORS[ltr]
  
      self.ipntr = np.zeros(14, "int")
  
      if self.tp in "FD":
          # Use _aligned_zeros to work around a f2py bug in Numpy 1.9.1
          self.rwork = _aligned_zeros(self.ncv, self.tp.lower())
      else:
          self.rwork = None
  
imports: from __future__ import division, print_function, absolute_import
  from .None import _arpack
  import numpy
  import warnings
  from scipy.sparse.linalg.interface import aslinearoperator, LinearOperator
  from scipy.sparse import eye, issparse, isspmatrix, isspmatrix_csr
  from scipy.linalg import eig, eigh, lu_factor, lu_solve
  from scipy.sparse.sputils import isdense
  from scipy.sparse.linalg import gmres, splu
  from scipy._lib._util import _aligned_zeros
  from scipy._lib._threadsafety import ReentrancyLock
label_desc: Use image node_id 1 to create a new _UnsymmetricArpackParams object from inherited base classes: _ArpackParams with example: obj = _UnsymmetricArpackParams(n, k, tp, matvec, mode, M_matvec, Minv_matvec, sigma, ncv, v0, maxiter, which, tol)