def _solve_simplex(T, n, basis, maxiter=<NUM_LIT:1000>, phase=<NUM_LIT:2>, callback=None,<EOL>tol=<NUM_LIT>, nit0=<NUM_LIT:0>, bland=False):
nit = nit0<EOL>complete = False<EOL>solution = np.zeros(T.shape[<NUM_LIT:1>]-<NUM_LIT:1>, dtype=np.float64)<EOL>if phase == <NUM_LIT:1>:<EOL><INDENT>m = T.shape[<NUM_LIT:0>]-<NUM_LIT:2><EOL><DEDENT>elif phase == <NUM_LIT:2>:<EOL><INDENT>m = T.shape[<NUM_LIT:0>]-<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>while not complete:<EOL><INDENT>pivcol_found, pivcol = _pivot_col(T, tol, bland)<EOL>if not pivcol_found:<EOL><INDENT>pivcol = np.nan<EOL>pivrow = np.nan<EOL>status = <NUM_LIT:0><EOL>complete = True<EOL><DEDENT>else:<EOL><INDENT>pivrow_found, pivrow = _pivot_row(T, pivcol, phase, tol)<EOL>if not pivrow_found:<EOL><INDENT>status = <NUM_LIT:3><EOL>complete = True<EOL><DEDENT><DEDENT>if callback is not None:<EOL><INDENT>solution[:] = <NUM_LIT:0><EOL>solution[basis[:m]] = T[:m, -<NUM_LIT:1>]<EOL>callback(solution[:n], **{"<STR_LIT>": T,<EOL>"<STR_LIT>":phase,<EOL>"<STR_LIT>":nit,<EOL>"<STR_LIT>":(pivrow, pivcol),<EOL>"<STR_LIT>":basis,<EOL>"<STR_LIT>": complete and phase == <NUM_LIT:2>})<EOL><DEDENT>if not complete:<EOL><INDENT>if nit >= maxiter:<EOL><INDENT>status = <NUM_LIT:1><EOL>complete = True<EOL><DEDENT>else:<EOL><INDENT>basis[pivrow] = pivcol<EOL>pivval = T[pivrow][pivcol]<EOL>T[pivrow, :] = T[pivrow, :] / pivval<EOL>for irow in range(T.shape[<NUM_LIT:0>]):<EOL><INDENT>if irow != pivrow:<EOL><INDENT>T[irow, :] = T[irow, :] - T[pivrow, :]*T[irow, pivcol]<EOL><DEDENT><DEDENT>nit += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return nit, status<EOL>
Solve a linear programming problem in "standard maximization form" using
the Simplex Method.

Minimize :math:`f = c^T x`

subject to

.. math::

    Ax = b
    x_i >= 0
    b_j >= 0

Parameters
----------
T : array_like
    A 2-D array representing the simplex T corresponding to the
    maximization problem.  It should have the form:

    [[A[0, 0], A[0, 1], ..., A[0, n_total], b[0]],
     [A[1, 0], A[1, 1], ..., A[1, n_total], b[1]],
     .
     .
     .
     [A[m, 0], A[m, 1], ..., A[m, n_total], b[m]],
     [c[0],   c[1], ...,   c[n_total],    0]]

    for a Phase 2 problem, or the form:

    [[A[0, 0], A[0, 1], ..., A[0, n_total], b[0]],
     [A[1, 0], A[1, 1], ..., A[1, n_total], b[1]],
     .
     .
     .
     [A[m, 0], A[m, 1], ..., A[m, n_total], b[m]],
     [c[0],   c[1], ...,   c[n_total],   0],
     [c'[0],  c'[1], ...,  c'[n_total],  0]]

     for a Phase 1 problem (a Problem in which a basic feasible solution is
     sought prior to maximizing the actual objective.  T is modified in
     place by _solve_simplex.
n : int
    The number of true variables in the problem.
basis : array
    An array of the indices of the basic variables, such that basis[i]
    contains the column corresponding to the basic variable for row i.
    Basis is modified in place by _solve_simplex
maxiter : int
    The maximum number of iterations to perform before aborting the
    optimization.
phase : int
    The phase of the optimization being executed.  In phase 1 a basic
    feasible solution is sought and the T has an additional row representing
    an alternate objective function.
callback : callable
    If a callback function is provided, it will be called within each
    iteration of the simplex algorithm. The callback must have the
    signature `callback(xk, **kwargs)` where xk is the current solution
    vector and kwargs is a dictionary containing the following::
    "T" : The current Simplex algorithm T
    "nit" : The current iteration.
    "pivot" : The pivot (row, column) used for the next iteration.
    "phase" : Whether the algorithm is in Phase 1 or Phase 2.
    "basis" : The indices of the columns of the basic variables.
tol : float
    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 to serve as an optimal solution.
nit0 : int
    The initial iteration number used to keep an accurate iteration total
    in a two-phase problem.
bland : bool
    If True, choose pivots using Bland's rule [3].  In problems which
    fail to converge due to cycling, using Bland's rule can provide
    convergence at the expense of a less optimal path about the simplex.

Returns
-------
res : OptimizeResult
    The optimization result represented as a ``OptimizeResult`` object.
    Important attributes are: ``x`` the solution array, ``success`` a
    Boolean flag indicating if the optimizer exited successfully and
    ``message`` which describes the cause of the termination. Possible
    values for the ``status`` attribute are:
     0 : Optimization terminated successfully
     1 : Iteration limit reached
     2 : Problem appears to be infeasible
     3 : Problem appears to be unbounded

    See `OptimizeResult` for a description of other attributes.