ENH: modularize presolve in linprog #11691

.gitmodules

@@ -1,9 +1,3 @@
-[submodule "doc/scipy-sphinx-theme"]
-	path = doc/scipy-sphinx-theme
-	url = https://github.com/scipy/scipy-sphinx-theme.git
-[submodule "doc/sphinxext"]
-	path = doc/sphinxext
-	url = https://github.com/numpy/numpydoc.git
 [submodule "doc/source/_static/scipy-mathjax"]
 	path = doc/source/_static/scipy-mathjax
 	url = https://github.com/scipy/scipy-mathjax.git

scipy/optimize/_linprog.py

@@ -506,50 +506,55 @@ def linprog(c, A_ub=None, b_ub=None, A_eq=None, b_eq=None,
            x: array([10., -3.]) # may vary
 
     """
-    meth = method.lower()
 
+    meth = method.lower()
     if x0 is not None and meth != "revised simplex":
         warning_message = "x0 is used only when method is 'revised simplex'. "
         warn(warning_message, OptimizeWarning)
 
     lp = _LPProblem(c, A_ub, b_ub, A_eq, b_eq, bounds, x0)
+
     lp, solver_options = _parse_linprog(lp, options)
     tol = solver_options.get('tol', 1e-9)
 
     iteration = 0
-    complete = False  # will become True if solved in presolve
-    undo = []
+    complete = False    # will become True if solved in presolve
+    revstack = []
 
     # Keep the original arrays to calculate slack/residuals for original
     # problem.
     lp_o = deepcopy(lp)
 
     # Solve trivial problem, eliminate variables, tighten bounds, etc.
-    c0 = 0  # we might get a constant term in the objective
     if solver_options.pop('presolve', True):
         rr = solver_options.pop('rr', True)
-        (lp, c0, x, undo, complete, status, message) = _presolve(lp, rr, tol)
+        (lp, revstack, complete, status, message, presolve_effect) = _presolve(lp, rr, tol)
+    else:
+        message = None
+        presolve_effect = None
 
     C, b_scale = 1, 1  # for trivial unscaling if autoscale is not used
-    postsolve_args = (lp_o._replace(bounds=lp.bounds), undo, C, b_scale)
+    postsolve_args = (lp_o._replace(bounds=lp.bounds), revstack, C, b_scale)
 
-    if not complete:
-        A, b, c, c0, x0 = _get_Abc(lp, c0)
+    if complete:
+        x = np.zeros(lp.c.shape)
+    else:
+        A, b, c, _, x0 = _get_Abc(lp, 0)
         if solver_options.pop('autoscale', False):
             A, b, c, x0, C, b_scale = _autoscale(A, b, c, x0)
             postsolve_args = postsolve_args[:-2] + (C, b_scale)
 
         if meth == 'simplex':
             x, status, message, iteration = _linprog_simplex(
-                c, c0=c0, A=A, b=b, callback=callback,
+                c, c0=0, A=A, b=b, callback=callback,
                 postsolve_args=postsolve_args, **solver_options)
         elif meth == 'interior-point':
             x, status, message, iteration = _linprog_ip(
-                c, c0=c0, A=A, b=b, callback=callback,
+                c, c0=0, A=A, b=b, callback=callback,
                 postsolve_args=postsolve_args, **solver_options)
         elif meth == 'revised simplex':
             x, status, message, iteration = _linprog_rs(
-                c, c0=c0, A=A, b=b, x0=x0, callback=callback,
+                c, c0=0, A=A, b=b, x0=x0, callback=callback,
                 postsolve_args=postsolve_args, **solver_options)
         else:
             raise ValueError('Unknown solver %s' % method)
@@ -572,6 +577,7 @@ def linprog(c, A_ub=None, b_ub=None, A_eq=None, b_eq=None,
         'status': status,
         'message': message,
         'nit': iteration,
-        'success': status == 0}
+        'success': status == 0,
+        'presolve': presolve_effect}
 
     return OptimizeResult(sol)