ó î&]\c@`s=dZddlmZmZmZddlZddlZddl j Z ddl m Z ddlmZddlmZmZeeeed„Zeeeeeed d „Zed „Zd „Zd „Zd„Zd„Zd„Zed„Zd„Zdddddddedeeedeed d„Z dS(s2 An interior-point method for linear programming. i(tprint_functiontdivisiontabsolute_importN(twarn(t LinAlgErrori(tOptimizeWarningt_check_unknown_optionscC`se|r.|s| r"td„}qad„}n3|r@d„}n!|rUtjj}n |d„}|S(s; Given solver options, return a handle to the appropriate linear system solver. Parameters ---------- sparse : bool True if the system to be solved is sparse. This is typically set True when the original ``A_ub`` and ``A_eq`` arrays are sparse. lstsq : bool True if the system is ill-conditioned and/or (nearly) singular and thus a more robust least-squares solver is desired. This is sometimes needed as the solution is approached. sym_pos : bool True if the system matrix is symmetric positive definite Sometimes this needs to be set false as the solution is approached, even when the system should be symmetric positive definite, due to numerical difficulties. cholesky : bool True if the system is to be solved by Cholesky, rather than LU, decomposition. This is typically faster unless the problem is very small or prone to numerical difficulties. Returns ------- solve : function Handle to the appropriate solver function cS`stjj||ƒdS(Ni(tspstlinalgtlsqr(tMtrtsym_pos((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pytsolve/scS`stjj||ddƒS(Nt permc_spect MMD_AT_PLUS_A(RRtspsolve(R R ((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyR 4scS`stjj||ƒdS(Ni(tspRtlstsq(R R ((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyR 9scS`stjj||d|ƒS(NR (RRR (R R R ((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyR @s(tFalseRRt cho_solve(tsparseRR tcholeskyR ((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyt _get_solvers    Rc0 C`sq|jddkr4ttttf\} } } } nt| | | | ƒ}t|ƒ}|||j|ƒ}|||jj|ƒ|}|j|ƒ|jƒj|ƒ|}|j|ƒ|||d}||}t}| rp| rp|jtj |dddƒj|jƒƒ}y%tj j |d|ƒj }t}Wq’t k rlt} t| | | | ƒ}q’Xn"|j|jddƒ|jƒ}| ràytj j|ƒ}Wqàt k rÜt} t| | | | ƒ}qàXn|rìdnd}d}d \}}}} }!xN||kr]| |ƒ|}"| |ƒ|}#tj| |ƒ|ƒjd ƒ}$||||}%tj||||ƒjdƒ}&|dkr.|rd||||||d||}%tjd||||||d| |!ƒjdƒ}&q.|%||8}%|&| |!8}&nt}'x%|'s[y©| rL|n|}(t||(|||||ƒ\})}*t||(||#d||%|"||ƒ\}+},tjtj|)ƒƒsÖtjtj|*ƒƒrßt‚nt}'Wq7ttfk rW}-t} | s<| r&tdtƒt} qBtd tƒt} n|-‚t| | | ƒ}q7Xq7W|$d||&|j|+ƒ |j|,ƒd|||j|)ƒ |j|*ƒ} |+|)| }|,|*| }.d||%||}d||&|| }!t|||||| ||!dƒ }|r+d }n%d }/d|dt|/d|ƒ}|d7}qW||.|| |!fS(sæ Given standard form problem defined by ``A``, ``b``, and ``c``; current variable estimates ``x``, ``y``, ``z``, ``tau``, and ``kappa``; algorithmic parameters ``gamma and ``eta; and options ``sparse``, ``lstsq``, ``sym_pos``, ``cholesky``, ``pc`` (predictor-corrector), and ``ip`` (initial point improvement), get the search direction for increments to the variable estimates. Parameters ---------- As defined in [4], except: sparse : bool True if the system to be solved is sparse. This is typically set True when the original ``A_ub`` and ``A_eq`` arrays are sparse. lstsq : bool True if the system is ill-conditioned and/or (nearly) singular and thus a more robust least-squares solver is desired. This is sometimes needed as the solution is approached. sym_pos : bool True if the system matrix is symmetric positive definite Sometimes this needs to be set false as the solution is approached, even when the system should be symmetric positive definite, due to numerical difficulties. cholesky : bool True if the system is to be solved by Cholesky, rather than LU, decomposition. This is typically faster unless the problem is very small or prone to numerical difficulties. pc : bool True if the predictor-corrector method of Mehrota is to be used. This is almost always (if not always) beneficial. Even though it requires the solution of an additional linear system, the factorization is typically (implicitly) reused so solution is efficient, and the number of algorithm iterations is typically reduced. ip : bool True if the improved initial point suggestion due to [4] section 4.3 is desired. It's unclear whether this is beneficial. permc_spec : str (default = 'MMD_AT_PLUS_A') (Has effect only with ``sparse = True``, ``lstsq = False``, ``sym_pos = True``.) A matrix is factorized in each iteration of the algorithm. This option specifies how to permute the columns of the matrix for sparsity preservation. Acceptable values are: - ``NATURAL``: natural ordering. - ``MMD_ATA``: minimum degree ordering on the structure of A^T A. - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A. - ``COLAMD``: approximate minimum degree column ordering. This option can impact the convergence of the interior point algorithm; test different values to determine which performs best for your problem. For more information, refer to ``scipy.sparse.linalg.splu``. Returns ------- Search directions as defined in [4] References ---------- .. [4] Andersen, Erling D., and Knud D. Andersen. "The MOSEK interior point optimizer for linear programming: an implementation of the homogeneous algorithm." High performance optimization. Springer US, 2000. 197-232. iitformattcscRiÿÿÿÿisÚSolving system with option 'sym_pos':True failed. It is normal for this to happen occasionally, especially as the solution is approached. However, if you see this frequently, consider setting option 'sym_pos' to False.sUSolving system with option 'sym_pos':False failed. This may happen occasionally, especially as the solution is approached. However, if you see this frequently, your problem may be numerically challenging. If you cannot improve the formulation, consider setting 'lstsq' to True. Consider also setting `presolve` to True, if it is not already.i gš™™™™™¹?(iiiii(i(i(i(tshapeRtTrueRtlentdottTt transposeRtdiagsRtspluR t ExceptiontreshapeRt cho_factortnptarrayt _sym_solvetanytisnanRt ValueErrorRRt _get_steptmin(0tAtbtctxtytzttautkappatgammatetaRRR RtpctipRR tn_xtr_Ptr_Dtr_GtmutDinvR!R tLt n_correctionstitalphatd_xtd_ztd_tautd_kappatrhatptrhatdtrhatgtrhatxstrhattktsolvedt solve_thistptqtutvtetd_ytbeta1((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyt _get_deltaFs¢T! &  -  " "$ *    $!0    **$ c C`s_||j||ƒ}|r,||ƒ}n|||ƒ}||jj|ƒ|} | |fS(sX An implementation of [4] equation 8.31 and 8.32 References ---------- .. [4] Andersen, Erling D., and Knud D. Andersen. "The MOSEK interior point optimizer for linear programming: an implementation of the homogeneous algorithm." High performance optimization. Springer US, 2000. 197-232. (RR( R>R R-tr1tr2R R!R RQRP((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyR'8s c C`sæ|dk} |dk} tj| ƒrG|tj|| ||  ƒnd} |dkrh||| nd} tj| ƒr|tj|| ||  ƒnd} |dkr¾||| nd}tjd| | | |gƒ}|S(sO An implementation of [4] equation 8.21 References ---------- .. [4] Andersen, Erling D., and Knud D. Andersen. "The MOSEK interior point optimizer for linear programming: an implementation of the homogeneous algorithm." High performance optimization. Springer US, 2000. 197-232. ii(R%R(R,(R0RCR2RDR3RER4RFtalpha0ti_xti_ztalpha_xt alpha_tautalpha_zt alpha_kappaRB((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyR+Os  5!5!cC`sdddddg}||S(s Given problem status code, return a more detailed message. Parameters ---------- status : int An integer representing the exit status of the optimization:: 0 : Optimization terminated successfully 1 : Iteration limit reached 2 : Problem appears to be infeasible 3 : Problem appears to be unbounded 4 : Serious numerical difficulties encountered Returns ------- message : str A string descriptor of the exit status of the optimization. s%Optimization terminated successfully.s?The iteration limit was reached before the algorithm converged.sTThe algorithm terminated successfully and determined that the problem is infeasible.sSThe algorithm terminated successfully and determined that the problem is unbounded.sNumerical difficulties were encountered before the problem converged. Please check your problem formulation for errors, independence of linear equality constraints, and reasonable scaling and matrix condition numbers. If you continue to encounter this error, please submit a bug report.((tstatustmessages((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyt _get_messageis  c C`sY|| |}|| |}|| |}|| | }|| |}|||||fS(sN An implementation of [4] Equation 8.9 References ---------- .. [4] Andersen, Erling D., and Knud D. Andersen. "The MOSEK interior point optimizer for linear programming: an implementation of the homogeneous algorithm." High performance optimization. Springer US, 2000. 197-232. (( R0R1R2R3R4RCRSRDRERFRB((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyt_do_stepŽs cC`sX|\}}tj|ƒ}tj|ƒ}tj|ƒ}d}d}|||||fS(sO Return the starting point from [4] 4.4 References ---------- .. [4] Andersen, Erling D., and Knud D. Andersen. "The MOSEK interior point optimizer for linear programming: an implementation of the homogeneous algorithm." High performance optimization. Springer US, 2000. 197-232. i(R%tonestzeros(Rtmtntx0ty0tz0ttau0tkappa0((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyt_get_blind_start¢s c `s´tˆjƒ\} } } } } ‡‡fd†}‡‡fd†}‡‡fd†}d„}ˆj||ƒ|}d„}|| | ƒ}|| | | ƒ}|| | | ƒ}|| | | | ƒ}|ˆjj|ƒˆjj|ƒƒ||ˆjj|ƒƒ}||||ƒƒtd||ƒƒ}|||||ƒƒtd||ƒƒ}|||||ƒƒtd||ƒƒ}|||||ƒ|}||||||fS(s‹ Implementation of several equations from [4] used as indicators of the status of optimization. References ---------- .. [4] Andersen, Erling D., and Knud D. Andersen. "The MOSEK interior point optimizer for linear programming: an implementation of the homogeneous algorithm." High performance optimization. Springer US, 2000. 197-232. c`sˆ|ˆj|ƒS(N(R(R0R3(R-R.(s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pytr_pÉsc`sˆ|ˆjj|ƒ|S(N(RR(R1R2R3(R-R/(s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pytr_dÌsc`s|ˆj|ƒˆj|ƒS(N(R(R0R1R4(R.R/(s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pytr_gÏscS`s+|j|ƒtj||ƒt|ƒdS(Ni(RR%R(R0R3R2R4((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyR=ÓscS`stjj|ƒS(N(R%Rtnorm(ta((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyRpØsi(RlRRRtmax(R-R.R/tc0R0R1R2R3R4RgRhRiRjRkRmRnRoR=tobjRptr_p0tr_d0tr_g0tmu_0trho_Atrho_ptrho_dtrho_gtrho_mu((R-R.R/s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyt _indicators·s"  B(++cC`sN|r"tddddddƒnd}t|j||||||ƒƒdS( s\ Print indicators of optimization status to the console. Parameters ---------- rho_p : float The (normalized) primal feasibility, see [4] 4.5 rho_d : float The (normalized) dual feasibility, see [4] 4.5 rho_g : float The (normalized) duality gap, see [4] 4.5 alpha : float The step size, see [4] 4.3 rho_mu : float The (normalized) path parameter, see [4] 4.5 obj : float The objective function value of the current iterate header : bool True if a header is to be printed References ---------- .. [4] Andersen, Erling D., and Knud D. Andersen. "The MOSEK interior point optimizer for linear programming: an implementation of the homogeneous algorithm." High performance optimization. Springer US, 2000. 197-232. sPrimal Feasibility sDual Feasibility sDuality Gap sStep sPath Parameter sObjective s<{0:<20.13}{1:<20.13}{2:<20.13}{3:<17.13}{4:<20.13}{5:<20.13}N(tprintR(RzR{R|RBR}Rttheadertfmt((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyt _display_iterès  c*C`sd}t|jƒ\}}}}}| r0|nt}t|||||||||ƒ \}}}}}}||kp||kp||k}|r¸t|||d||dtƒnd}d}| rëtj|ƒ}|jƒ|_ nx|rÿ|d7}|rd}d„} n/| r"dn|t j ||ƒ}|d„} y8t |||||||||| | | | | | ||ƒ\}!}"}#}$}%|rd}&t ||||||!|"|#|$|%|&ƒ \}}}}}d||dk= 0 using the interior point method of [4]. Parameters ---------- A : 2D array 2D array such that ``A @ x``, gives the values of the equality constraints at ``x``. b : 1D array 1D array of values representing the RHS of each equality constraint (row) in ``A`` (for standard form problem). c : 1D array Coefficients of the linear objective function to be minimized (for standard form problem). c0 : float Constant term in objective function due to fixed (and eliminated) variables. (Purely for display.) alpha0 : float The maximal step size for Mehrota's predictor-corrector search direction; see :math:`\beta_3`of [4] Table 8.1 beta : float The desired reduction of the path parameter :math:`\mu` (see [6]_) maxiter : int The maximum number of iterations of the algorithm. disp : bool Set to ``True`` if indicators of optimization status are to be printed to the console each iteration. tol : float Termination tolerance; see [4]_ Section 4.5. sparse : bool Set to ``True`` if the problem is to be treated as sparse. However, the inputs ``A_eq`` and ``A_ub`` should nonetheless be provided as (dense) arrays rather than sparse matrices. lstsq : bool Set to ``True`` if the problem is expected to be very poorly conditioned. This should always be left as ``False`` unless severe numerical difficulties are frequently encountered, and a better option would be to improve the formulation of the problem. sym_pos : bool Leave ``True`` if the problem is expected to yield a well conditioned symmetric positive definite normal equation matrix (almost always). cholesky : bool Set to ``True`` if the normal equations are to be solved by explicit Cholesky decomposition followed by explicit forward/backward substitution. This is typically faster for moderate, dense problems that are numerically well-behaved. pc : bool Leave ``True`` if the predictor-corrector method of Mehrota is to be used. This is almost always (if not always) beneficial. ip : bool Set to ``True`` if the improved initial point suggestion due to [4]_ Section 4.3 is desired. It's unclear whether this is beneficial. permc_spec : str (default = 'MMD_AT_PLUS_A') (Has effect only with ``sparse = True``, ``lstsq = False``, ``sym_pos = True``.) A matrix is factorized in each iteration of the algorithm. This option specifies how to permute the columns of the matrix for sparsity preservation. Acceptable values are: - ``NATURAL``: natural ordering. - ``MMD_ATA``: minimum degree ordering on the structure of A^T A. - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A. - ``COLAMD``: approximate minimum degree column ordering. This option can impact the convergence of the interior point algorithm; test different values to determine which performs best for your problem. For more information, refer to ``scipy.sparse.linalg.splu``. Returns ------- x_hat : float Solution vector (for standard form problem). status : int An integer representing the exit status of the optimization:: 0 : Optimization terminated successfully 1 : Iteration limit reached 2 : Problem appears to be infeasible 3 : Problem appears to be unbounded 4 : Serious numerical difficulties encountered message : str A string descriptor of the exit status of the optimization. iteration : int The number of iterations taken to solve the problem References ---------- .. [4] Andersen, Erling D., and Knud D. Andersen. "The MOSEK interior point optimizer for linear programming: an implementation of the homogeneous algorithm." High performance optimization. Springer US, 2000. 197-232. .. [6] Freund, Robert M. "Primal-Dual Interior-Point Methods for Linear Programming based on Newton's Method." Unpublished Course Notes, March 2004. Available 2/25/2017 at: https://ocw.mit.edu/courses/sloan-school-of-management/15-084j-nonlinear-programming-spring-2004/lecture-notes/lec14_int_pt_mthd.pdf it-R€s%Optimization terminated successfully.icS`sdS(Ni((tg((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyR6©scS`sd|S(Ni((R„((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyR6²sgð?iii(RlRRR~R‚RRt csc_matrixRRR%tmeanRURbRrR+RtFloatingPointErrorR*tZeroDivisionErrorRatfloatR,R(*R-R.R/RsRXtbetatmaxitertdispttolRRR RR7R8Rt iterationR0R1R2R3R4RzR{RyR|R}RttgoR_tmessageR5R6RCRSRDRERFRBtinf1tinf2tx_hat((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyt_ip_hsds~p3$"   # *! : 3$"*%      gSt$—ÿï?gš™™™™™¹?ièg:Œ0âŽyE>cK`sot|ƒ|tk r%tdƒ‚n| o.| rAtdtƒn| oK| r^tdtƒn| og| rztdtƒn| oƒ| r–tdtƒndddd f}|jƒ|krÞtd t|ƒd tƒd}n| oè| rútd ƒ‚n| tko| o| o| } t||||||||| | | | | |||ƒ\}}}}||||fS( sù+ Minimize a linear objective function subject to linear equality and non-negativity constraints using the interior point method of [4]_. Linear programming is intended to solve problems of the following form: Minimize:: c @ x Subject to:: A @ x == b x >= 0 Parameters ---------- c : 1D array Coefficients of the linear objective function to be minimized. c0 : float Constant term in objective function due to fixed (and eliminated) variables. (Purely for display.) A : 2D array 2D array such that ``A @ x``, gives the values of the equality constraints at ``x``. b : 1D array 1D array of values representing the right hand side of each equality constraint (row) in ``A``. Options ------- maxiter : int (default = 1000) The maximum number of iterations of the algorithm. disp : bool (default = False) Set to ``True`` if indicators of optimization status are to be printed to the console each iteration. tol : float (default = 1e-8) Termination tolerance to be used for all termination criteria; see [4]_ Section 4.5. alpha0 : float (default = 0.99995) The maximal step size for Mehrota's predictor-corrector search direction; see :math:`\beta_{3}` of [4]_ Table 8.1. beta : float (default = 0.1) The desired reduction of the path parameter :math:`\mu` (see [6]_) when Mehrota's predictor-corrector is not in use (uncommon). sparse : bool (default = False) Set to ``True`` if the problem is to be treated as sparse after presolve. If either ``A_eq`` or ``A_ub`` is a sparse matrix, this option will automatically be set ``True``, and the problem will be treated as sparse even during presolve. If your constraint matrices contain mostly zeros and the problem is not very small (less than about 100 constraints or variables), consider setting ``True`` or providing ``A_eq`` and ``A_ub`` as sparse matrices. lstsq : bool (default = False) Set to ``True`` if the problem is expected to be very poorly conditioned. This should always be left ``False`` unless severe numerical difficulties are encountered. Leave this at the default unless you receive a warning message suggesting otherwise. sym_pos : bool (default = True) Leave ``True`` if the problem is expected to yield a well conditioned symmetric positive definite normal equation matrix (almost always). Leave this at the default unless you receive a warning message suggesting otherwise. cholesky : bool (default = True) Set to ``True`` if the normal equations are to be solved by explicit Cholesky decomposition followed by explicit forward/backward substitution. This is typically faster for moderate, dense problems that are numerically well-behaved. pc : bool (default = True) Leave ``True`` if the predictor-corrector method of Mehrota is to be used. This is almost always (if not always) beneficial. ip : bool (default = False) Set to ``True`` if the improved initial point suggestion due to [4]_ Section 4.3 is desired. Whether this is beneficial or not depends on the problem. permc_spec : str (default = 'MMD_AT_PLUS_A') (Has effect only with ``sparse = True``, ``lstsq = False``, ``sym_pos = True``.) A matrix is factorized in each iteration of the algorithm. This option specifies how to permute the columns of the matrix for sparsity preservation. Acceptable values are: - ``NATURAL``: natural ordering. - ``MMD_ATA``: minimum degree ordering on the structure of A^T A. - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A. - ``COLAMD``: approximate minimum degree column ordering. This option can impact the convergence of the interior point algorithm; test different values to determine which performs best for your problem. For more information, refer to ``scipy.sparse.linalg.splu``. Returns ------- x : 1D array Solution vector. status : int An integer representing the exit status of the optimization:: 0 : Optimization terminated successfully 1 : Iteration limit reached 2 : Problem appears to be infeasible 3 : Problem appears to be unbounded 4 : Serious numerical difficulties encountered message : str A string descriptor of the exit status of the optimization. iteration : int The number of iterations taken to solve the problem. Notes ----- This method implements the algorithm outlined in [4]_ with ideas from [8]_ and a structure inspired by the simpler methods of [6]_ and [4]_. The primal-dual path following method begins with initial 'guesses' of the primal and dual variables of the standard form problem and iteratively attempts to solve the (nonlinear) Karush-Kuhn-Tucker conditions for the problem with a gradually reduced logarithmic barrier term added to the objective. This particular implementation uses a homogeneous self-dual formulation, which provides certificates of infeasibility or unboundedness where applicable. The default initial point for the primal and dual variables is that defined in [4]_ Section 4.4 Equation 8.22. Optionally (by setting initial point option ``ip=True``), an alternate (potentially improved) starting point can be calculated according to the additional recommendations of [4]_ Section 4.4. A search direction is calculated using the predictor-corrector method (single correction) proposed by Mehrota and detailed in [4]_ Section 4.1. (A potential improvement would be to implement the method of multiple corrections described in [4]_ Section 4.2.) In practice, this is accomplished by solving the normal equations, [4]_ Section 5.1 Equations 8.31 and 8.32, derived from the Newton equations [4]_ Section 5 Equations 8.25 (compare to [4]_ Section 4 Equations 8.6-8.8). The advantage of solving the normal equations rather than 8.25 directly is that the matrices involved are symmetric positive definite, so Cholesky decomposition can be used rather than the more expensive LU factorization. With the default ``cholesky=True``, this is accomplished using ``scipy.linalg.cho_factor`` followed by forward/backward substitutions via ``scipy.linalg.cho_solve``. With ``cholesky=False`` and ``sym_pos=True``, Cholesky decomposition is performed instead by ``scipy.linalg.solve``. Based on speed tests, this also appears to retain the Cholesky decomposition of the matrix for later use, which is beneficial as the same system is solved four times with different right hand sides in each iteration of the algorithm. In problems with redundancy (e.g. if presolve is turned off with option ``presolve=False``) or if the matrices become ill-conditioned (e.g. as the solution is approached and some decision variables approach zero), Cholesky decomposition can fail. Should this occur, successively more robust solvers (``scipy.linalg.solve`` with ``sym_pos=False`` then ``scipy.linalg.lstsq``) are tried, at the cost of computational efficiency. These solvers can be used from the outset by setting the options ``sym_pos=False`` and ``lstsq=True``, respectively. Note that with the option ``sparse=True``, the normal equations are solved using ``scipy.sparse.linalg.spsolve``. Unfortunately, this uses the more expensive LU decomposition from the outset, but for large, sparse problems, the use of sparse linear algebra techniques improves the solve speed despite the use of LU rather than Cholesky decomposition. A simple improvement would be to use the sparse Cholesky decomposition of ``CHOLMOD`` via ``scikit-sparse`` when available. Other potential improvements for combatting issues associated with dense columns in otherwise sparse problems are outlined in [4]_ Section 5.3 and [10]_ Section 4.1-4.2; the latter also discusses the alleviation of accuracy issues associated with the substitution approach to free variables. After calculating the search direction, the maximum possible step size that does not activate the non-negativity constraints is calculated, and the smaller of this step size and unity is applied (as in [4]_ Section 4.1.) [4]_ Section 4.3 suggests improvements for choosing the step size. The new point is tested according to the termination conditions of [4]_ Section 4.5. The same tolerance, which can be set using the ``tol`` option, is used for all checks. (A potential improvement would be to expose the different tolerances to be set independently.) If optimality, unboundedness, or infeasibility is detected, the solve procedure terminates; otherwise it repeats. The expected problem formulation differs between the top level ``linprog`` module and the method specific solvers. The method specific solvers expect a problem in standard form: Minimize:: c @ x Subject to:: A @ x == b x >= 0 Whereas the top level ``linprog`` module expects a problem of form: Minimize:: c @ x Subject to:: A_ub @ x <= b_ub A_eq @ x == b_eq lb <= x <= ub where ``lb = 0`` and ``ub = None`` unless set in ``bounds``. The original problem contains equality, upper-bound and variable constraints whereas the method specific solver requires equality constraints and variable non-negativity. ``linprog`` module converts the original problem to standard form by converting the simple bounds to upper bound constraints, introducing non-negative slack variables for inequality constraints, and expressing unbounded variables as the difference between two non-negative variables. References ---------- .. [4] Andersen, Erling D., and Knud D. Andersen. "The MOSEK interior point optimizer for linear programming: an implementation of the homogeneous algorithm." High performance optimization. Springer US, 2000. 197-232. .. [6] Freund, Robert M. "Primal-Dual Interior-Point Methods for Linear Programming based on Newton's Method." Unpublished Course Notes, March 2004. Available 2/25/2017 at https://ocw.mit.edu/courses/sloan-school-of-management/15-084j-nonlinear-programming-spring-2004/lecture-notes/lec14_int_pt_mthd.pdf .. [8] Andersen, Erling D., and Knud D. Andersen. "Presolving in linear programming." Mathematical Programming 71.2 (1995): 221-245. .. [9] Bertsimas, Dimitris, and J. Tsitsiklis. "Introduction to linear programming." Athena Scientific 1 (1997): 997. .. [10] Andersen, Erling D., et al. Implementation of interior point methods for large scale linear programming. HEC/Universite de Geneve, 1996. s<method 'interior-point' does not support callback functions.scInvalid option combination 'sparse':True and 'lstsq':True; Sparse least squares is not recommended.s‡Invalid option combination 'sparse':True and 'sym_pos':False; the effect is the same as sparse least squares, which is not recommended.slInvalid option combination 'sparse':True and 'cholesky':True; sparse Colesky decomposition is not available.svInvalid option combination 'lstsq':True and 'cholesky':True; option 'cholesky' has no effect when 'lstsq' is set True.tNATURALtMMD_ATARtCOLAMDsInvalid permc_spec option: 'sc'. Acceptable values are 'NATURAL', 'MMD_ATA', 'MMD_AT_PLUS_A', and 'COLAMD'. Reverting to default.s‘Invalid option combination 'sym_pos':False and 'cholesky':True: Cholesky decomposition is only possible for symmetric positive definite matrices.( RtNonetNotImplementedErrorRRtuppertstrR*R”(R/RsR-R.tcallbackRXRŠR‹RŒRRRR RR7R8Rtunknown_optionstvalid_permc_specR0R_RRŽ((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pyt _linprog_ip÷s<ÿ                (!t__doc__t __future__RRRtnumpyR%tscipyRt scipy.sparseRRtwarningsRt scipy.linalgRtoptimizeRRRRRRUR'R+RaRbRlR~R‚R”R˜RŸ(((s9lib/python2.7/site-packages/scipy/optimize/_linprog_ip.pytsN  B á   %   1 0 á