code: def _linprog_simplex_doc(
      c,
      A_ub=None,
      b_ub=None,
      A_eq=None,
      b_eq=None,
      bounds=None,
      method="interior-point",
      callback=None,
      maxiter=5000,
      disp=False,
      presolve=True,
      tol=1e-12,
      autoscale=False,
      rr=True,
      bland=False,
      **unknown_options,
  ):
      r"""
      Linear programming: minimize a linear objective function subject to linear
      equality and inequality constraints using the tableau-based simplex method.
  
      .. deprecated:: 1.9.0
          `method='simplex'` will be removed in SciPy 1.11.0.
          It is replaced by `method='highs'` because the latter is
          faster and more robust.
  
      Linear programming solves problems of the following form:
  
      .. math::
  
          \min_x \ & c^T x \\
          \mbox{such that} \ & A_{ub} x \leq b_{ub},\\
          & A_{eq} x = b_{eq},\\
          & l \leq x \leq u ,
  
      where :math:`x` is a vector of decision variables; :math:`c`,
      :math:`b_{ub}`, :math:`b_{eq}`, :math:`l`, and :math:`u` are vectors; and
      :math:`A_{ub}` and :math:`A_{eq}` are matrices.
  
      Alternatively, that's:
  
      minimize::
  
          c @ x
  
      such that::
  
          A_ub @ x <= b_ub
          A_eq @ x == b_eq
          lb <= x <= ub
  
      Note that by default ``lb = 0`` and ``ub = None`` unless specified with
      ``bounds``.
  
      Parameters
      ----------
      c : 1-D array
          The coefficients of the linear objective function to be minimized.
      A_ub : 2-D array, optional
          The inequality constraint matrix. Each row of ``A_ub`` specifies the
          coefficients of a linear inequality constraint on ``x``.
      b_ub : 1-D array, optional
          The inequality constraint vector. Each element represents an
          upper bound on the corresponding value of ``A_ub @ x``.
      A_eq : 2-D array, optional
          The equality constraint matrix. Each row of ``A_eq`` specifies the
          coefficients of a linear equality constraint on ``x``.
      b_eq : 1-D array, optional
          The equality constraint vector. Each element of ``A_eq @ x`` must equal
          the corresponding element of ``b_eq``.
      bounds : sequence, optional
          A sequence of ``(min, max)`` pairs for each element in ``x``, defining
          the minimum and maximum values of that decision variable. Use ``None``
          to indicate that there is no bound. By default, bounds are
          ``(0, None)`` (all decision variables are non-negative).
          If a single tuple ``(min, max)`` is provided, then ``min`` and
          ``max`` will serve as bounds for all decision variables.
      method : str
          This is the method-specific documentation for 'simplex'.
          :ref:`'highs' <optimize.linprog-highs>`,
          :ref:`'highs-ds' <optimize.linprog-highs-ds>`,
          :ref:`'highs-ipm' <optimize.linprog-highs-ipm>`,
          :ref:`'interior-point' <optimize.linprog-interior-point>` (default),
          and :ref:`'revised simplex' <optimize.linprog-revised_simplex>`
          are also available.
      callback : callable, optional
          Callback function to be executed once per iteration.
  
      Options
      -------
      maxiter : int (default: 5000)
         The maximum number of iterations to perform in either phase.
      disp : bool (default: False)
          Set to ``True`` if indicators of optimization status are to be printed
          to the console each iteration.
      presolve : bool (default: True)
          Presolve attempts to identify trivial infeasibilities,
          identify trivial unboundedness, and simplify the problem before
          sending it to the main solver. It is generally recommended
          to keep the default setting ``True``; set to ``False`` if
          presolve is to be disabled.
      tol : float (default: 1e-12)
          The tolerance which determines when a solution is "close enough" to
          zero in Phase 1 to be considered a basic feasible solution or close
          enough to positive to serve as an optimal solution.
      autoscale : bool (default: False)
          Set to ``True`` to automatically perform equilibration.
          Consider using this option if the numerical values in the
          constraints are separated by several orders of magnitude.
      rr : bool (default: True)
          Set to ``False`` to disable automatic redundancy removal.
      bland : bool
          If True, use Bland's anti-cycling rule [3]_ to choose pivots to
          prevent cycling. If False, choose pivots which should lead to a
          converged solution more quickly. The latter method is subject to
          cycling (non-convergence) in rare instances.
      unknown_options : dict
          Optional arguments not used by this particular solver. If
          `unknown_options` is non-empty a warning is issued listing all
          unused options.
  
      Returns
      -------
      res : OptimizeResult
          A :class:`scipy.optimize.OptimizeResult` consisting of the fields:
  
          x : 1-D array
              The values of the decision variables that minimizes the
              objective function while satisfying the constraints.
          fun : float
              The optimal value of the objective function ``c @ x``.
          slack : 1-D array
              The (nominally positive) values of the slack variables,
              ``b_ub - A_ub @ x``.
          con : 1-D array
              The (nominally zero) residuals of the equality constraints,
              ``b_eq - A_eq @ x``.
          success : bool
              ``True`` when the algorithm succeeds in finding an optimal
              solution.
          status : int
              An integer representing the exit status of the algorithm.
  
              ``0`` : Optimization terminated successfully.
  
              ``1`` : Iteration limit reached.
  
              ``2`` : Problem appears to be infeasible.
  
              ``3`` : Problem appears to be unbounded.
  
              ``4`` : Numerical difficulties encountered.
  
          message : str
              A string descriptor of the exit status of the algorithm.
          nit : int
              The total number of iterations performed in all phases.
  
      References
      ----------
      .. [1] Dantzig, George B., Linear programming and extensions. Rand
             Corporation Research Study Princeton Univ. Press, Princeton, NJ,
             1963
      .. [2] Hillier, S.H. and Lieberman, G.J. (1995), "Introduction to
             Mathematical Programming", McGraw-Hill, Chapter 4.
      .. [3] Bland, Robert G. New finite pivoting rules for the simplex method.
             Mathematics of Operations Research (2), 1977: pp. 103-107.
      """
      pass
  
label_desc: Use image node_id 6 for calling a global function with example usage: _linprog_simplex_doc(c, A_ub, b_ub, A_eq, b_eq, bounds, method, callback, maxiter, disp, presolve, tol, autoscale, rr, bland) without return types