← Back
Editing: _linprog_simplex.cpython-311.pyc
� d�c�` � �j � d Z ddlZddlmZ ddlmZmZmZ ddl m Z dd �Z dd �Z dd �Z dd�Z dd�ZdS )a Simplex method for linear programming The *simplex* method uses a traditional, full-tableau implementation of Dantzig's simplex algorithm [1]_, [2]_ (*not* the Nelder-Mead simplex). This algorithm is included for backwards compatibility and educational purposes. .. versionadded:: 0.15.0 Warnings -------- The simplex method may encounter numerical difficulties when pivot values are close to the specified tolerance. If encountered try remove any redundant constraints, change the pivot strategy to Bland's rule or increase the tolerance value. Alternatively, more robust methods maybe be used. See :ref:`'interior-point' <optimize.linprog-interior-point>` and :ref:`'revised simplex' <optimize.linprog-revised_simplex>`. 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. � N)�warn� )�OptimizeResult�OptimizeWarning�_check_unknown_options)� _postsolve��&� .>Fc �� � t j � | ddd�f | k | ddd�f d�� � }|� � � dk rdt j fS |rKdt j t j t j |j � � � � � � d d fS dt j � ||� � � k � � d d fS )a5 Given a linear programming simplex tableau, determine the column of the variable to enter the basis. Parameters ---------- T : 2-D array A 2-D array representing the simplex tableau, T, corresponding to the linear programming 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``. tol : float Elements in the objective row larger than -tol will not be considered for pivoting. Nominally this value is zero, but numerical issues cause a tolerance about zero to be necessary. bland : bool If True, use Bland's rule for selection of the column (select the first column with a negative coefficient in the objective row, regardless of magnitude). Returns ------- status: bool True if a suitable pivot column was found, otherwise False. A return of False indicates that the linear programming simplex algorithm is complete. col: int The index of the column of the pivot element. If status is False, col will be returned as nan. ���NF��copyr T) �np�ma� masked_where�count�nan�nonzero� logical_not� atleast_1d�mask�min)�T�tol�blandr s �A/usr/lib/python3/dist-packages/scipy/optimize/_linprog_simplex.py� _pivot_colr % s� � �h �� � �A�b�#�2�#�g�J�3�$� .��"�c�r�c�'� �� � G� G�B� �x�x�z�z�Q����b�f�}� � � N��R�Z���r�}�R�W�/E�/E� F� F�G�G��J�1�M�M�M� ��� � �r�R�V�V�X�X�~�.�.�q�1�!�4� 4�4� c �J � |dk rd}nd}t j � | d| �|f |k | d| �|f d�� � }|� � � dk rdt j fS t j � | d| �|f |k | d| �df d�� � }||z } t j � | | � � � k � � d } |r/d| t j t j || � � � � fS d| d fS ) a� Given a linear programming simplex tableau, determine the row for the pivot operation. Parameters ---------- T : 2-D array A 2-D array representing the simplex tableau, T, corresponding to the linear programming 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``. basis : array A list of the current basic variables. pivcol : int The index of the pivot column. phase : int The phase of the simplex algorithm (1 or 2). tol : float Elements in the pivot column smaller than tol will not be considered for pivoting. Nominally this value is zero, but numerical issues cause a tolerance about zero to be necessary. bland : bool If True, use Bland's rule for selection of the row (if more than one row can be used, choose the one with the lowest variable index). Returns ------- status: bool True if a suitable pivot row was found, otherwise False. A return of False indicates that the linear programming problem is unbounded. row: int The index of the row of the pivot element. If status is False, row will be returned as nan. r � NFr r r T) r r r r r r r �argmin�take) r �basis�pivcol�phaser r �kr �mb�q�min_rowss r � _pivot_rowr) b s � �p ��z�z� ��� �� �� � �A�c��r�c�6�k�N�c� 1�1�S�q�b�S�&�[�>�� � N� N�B� �x�x�z�z�Q����b�f�}� � �� � �A�c��r�c�6�k�N�c� 1�1�S�q�b�S�"�W�:�E� � J� J�B� �R��A��u�}�}�Q�!�%�%�'�'�\�*�*�1�-�H� � C��X�b�i����x�(@�(@� A� A�B�B�B� ��!�� � r c �R � |||< | ||f }| | |z | |< t | j d � � D ]'}||k r | | | | | ||f z z | |< �(t j ||dd�� � r/d� ||� � }t |t d�� � dS dS )a� Pivot the simplex tableau inplace on the element given by (pivrow, pivol). The entering variable corresponds to the column given by pivcol forcing the variable basis[pivrow] to leave the basis. Parameters ---------- T : 2-D array A 2-D array representing the simplex tableau, T, corresponding to the linear programming 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``. basis : 1-D 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 _apply_pivot. pivrow : int Row index of the pivot. pivcol : int Column index of the pivot. r g ��@)�atol�rtolaQ The pivot operation produces a pivot value of:{0: .1e}, which is only slightly greater than the specified tolerance{1: .1e}. This may lead to issues regarding the numerical stability of the simplex method. Removing redundant constraints, changing the pivot strategy via Bland's rule or increasing the tolerance may help reduce the issue.� )� stacklevelN)�range�shaper �isclose�formatr r )r r" �pivrowr# r �pivval�irow�messages r � _apply_pivotr7 � s� � �V �E�&�M� �v�v�~� �F��&� �F�"�A�f�I��a�g�a�j�!�!� <� <�� �6�>�>���g��&� �A�d�F�l�O� ;�;�A�d�G�� �z�&�#�A�C�0�0�0� 5� %� &,�V�F�C�%8�%8� � �W�o�!�4�4�4�4�4�4� 5� 5r �� r c � � ���� | } d} d} d} |dk r� j d dz }n&|dk r� j d dz }nt d� � �|dk r�� �fd�t �j � � D � � D ]`�� ��fd�t � j d dz � � D � � }t |� � dk r |d }t � ��|�� � | dz } �at �d |� � � dk r/t j � j d dz t j � � � }nTt j t � j d dz t �d |� � � dz � � t j � � � }| s�t � �|� � \ }}|s t j }t j �d} d } n t � �||�|� � \ }�|sd } d } |�hd|d d �< � d |�d f |�d |� < |d |� }t ||� � \ }}}}t ||||| | | | dk o| || d� � � } ||� � | s#| |k rd} d } nt � ��|�� � | dz } | ��| | fS )a� Solve a linear programming problem in "standard form" using the Simplex Method. Linear Programming is intended to solve the following problem form: Minimize:: c @ x Subject to:: A @ x == b x >= 0 Parameters ---------- T : 2-D array A 2-D array representing the simplex tableau, T, corresponding to the linear programming 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 : 1-D 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 callback : callable, optional If a callback function is provided, it will be called within each iteration of the algorithm. The callback must accept a `scipy.optimize.OptimizeResult` consisting of the following fields: x : 1-D array Current solution vector fun : float Current value of the objective function success : bool True only when a phase has completed successfully. This will be False for most iterations. slack : 1-D array The values of the slack variables. Each slack variable corresponds to an inequality constraint. If the slack is zero, the corresponding constraint is active. con : 1-D array The (nominally zero) residuals of the equality constraints, that is, ``b - A_eq @ x`` 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. 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 nit : int The number of iterations performed. message : str A string descriptor of the exit status of the optimization. postsolve_args : tuple Data needed by _postsolve to convert the solution to the standard-form problem into the solution to the original problem. maxiter : int The maximum number of iterations to perform before aborting the optimization. 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 serve as an optimal solution. 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. 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. nit0 : int The initial iteration number used to keep an accurate iteration total in a two-phase problem. Returns ------- nit : int The number of iterations. Used to keep an accurate iteration total in the two-phase 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 r � Fr r z1Argument 'phase' to _solve_simplex must be 1 or 2c �H �� g | ] }�| �j d dz k � |�� S )r r )r0 )�.0�rowr r" s ��r � <listcomp>z"_solve_simplex.<locals>.<listcomp>x s; �� � 7� 7� 7�s� ��*�q�w�q�z�A�~�5�5� �5�5�5r c �J �� g | ] }t ��|f � � �k � |�� S � )�abs)r< �colr r3 r s ���r r> z"_solve_simplex.<locals>.<listcomp>z s= �� � :� :� :�C� "�1�V�S�[�>� 2� 2�S� 8� 8� � 8� 8� 8r N)�dtypeT� r ) �x�fun�slack�con�statusr6 �nit�successr$ �complete)r0 � ValueErrorr/ �size�lenr7 r �empty�float64�maxr r r) r r )r �nr" �callback�postsolve_args�maxiterr r$ r �nit0rJ rI r6 rL �m� non_zero_rowr# �solution� pivcol_found� pivrow_foundrE rF rG rH �resr3 s ` ` ` @r �_solve_simplexr^ � s ����� �v �C� �F��G��H� ��z�z� �G�A�J�q�L��� �!��� �G�A�J�q�L����L�M�M�M� ��z�z�7� 7� 7� 7� 7�e�E�J�&7�&7� 7� 7� 7� � �F� :� :� :� :� :� :�5�����a� �+@�+@� :� :� :�L��<� � �1�$�$�%�a� �� �Q��v�v�s�;�;�;��q���� �5��!��9�~�~�����8�A�G�A�J��N�"�*�=�=�=����8�C���� �Q���E�"�1�"�I����0B� C� C�"$�*�.� .� .�� � +� )�!�S�%� 8� 8� � �f�� ��V�F��V�F��F��H�H� $.�a����s�E�#R�#R� �L�&� � ��� �� � ��H�Q�Q�Q�K�"#�B�Q�B��F�)�H�U�2�A�2�Y� ���!�� �A�!+��>�"� "� �A�s�E�3� !��� �� �"��!�Q�;�3�8� � $� "� "� � �C� �H�S�M�M�M�� ��g�~�~��� ��� �Q��v�v�s�;�;�;��q���W � +�X ��;�r c �2 � t | � � d} dddddd�} |j \ } }t j |d� � }||xx dz cc< ||xx dz cc< t j | � � |z }|� � � }t j |t j | � � |d d �t j f f� � }t j | t j | � � |f� � }|� d� � � }d||< t j |||f� � }t || |||||d | � � � \ }} |}t |d � � |k r%|d d�d d �f }t j ||d � � }n.d} d� t |d � � |� � | | < | dk r t || |||||d| |�� � \ }} t j | |z � � }|d | �df ||d | � < |d |� }|| | | t! |� � fS )a� Minimize a linear objective function subject to linear equality and non-negativity constraints using the two phase simplex method. Linear programming is intended to solve problems of the following form: Minimize:: c @ x Subject to:: A @ x == b x >= 0 User-facing documentation is in _linprog_doc.py. Parameters ---------- c : 1-D 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 : 2-D array 2-D array such that ``A @ x``, gives the values of the equality constraints at ``x``. b : 1-D array 1-D array of values representing the right hand side of each equality constraint (row) in ``A``. callback : callable, optional If a callback function is provided, it will be called within each iteration of the algorithm. The callback function must accept a single `scipy.optimize.OptimizeResult` consisting of the following fields: x : 1-D array Current solution vector fun : float Current value of the objective function success : bool True when an algorithm has completed successfully. slack : 1-D array The values of the slack variables. Each slack variable corresponds to an inequality constraint. If the slack is zero, the corresponding constraint is active. con : 1-D array The (nominally zero) residuals of the equality constraints, that is, ``b - A_eq @ x`` phase : int The phase of the algorithm being executed. status : int An integer representing the status of the optimization:: 0 : Algorithm proceeding nominally 1 : Iteration limit reached 2 : Problem appears to be infeasible 3 : Problem appears to be unbounded 4 : Serious numerical difficulties encountered nit : int The number of iterations performed. message : str A string descriptor of the exit status of the optimization. postsolve_args : tuple Data needed by _postsolve to convert the solution to the standard-form problem into the solution to the original problem. Options ------- maxiter : int The maximum number of iterations to perform. disp : bool If True, print exit status message to sys.stdout 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 serve as an optimal solution. 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 ------- x : 1-D 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. 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. Notes ----- 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. r z%Optimization terminated successfully.zIteration limit reached.z>Optimization failed. Unable to find a feasible starting point.z9Optimization failed. The problem appears to be unbounded.z1Optimization failed. Singular matrix encountered.)r r r rD � r N)�axisr )rT rU rV r r$ r )r r r au Phase 1 of the simplex method failed to find a feasible solution. The pseudo-objective function evaluates to {0:.1e} which exceeds the required tolerance of {1} for a solution to be considered 'close enough' to zero to be a basic solution. Consider increasing the tolerance to be greater than {0:.1e}. If this tolerance is unacceptably large the problem may be infeasible.)rT rU rV r r$ r rW )r r0 r �less�aranger �hstack�eye�newaxis�zeros�sum�vstackr^ rA �deleter2 �int)�c�c0�A�brT rU rV r �dispr �unknown_optionsrI �messagesrS rX �is_negative_constraint�avr" �row_constraints� row_objective�row_pseudo_objectiver �nit1�nit2rZ rE s r �_linprog_simplexrz � sp � �v �?�+�+�+� �F�:�-�&�N�F� H� H�H� �7�D�A�q� �W�Q��]�]��� � � � ��#� � � �� � � � ��#� � � � ��1� � �� �B� �G�G�I�I�E� �i��B�F�1�I�I�q����B�J� �/?� @�A�A�O��I�q�"�(�1�+�+�r� 2�3�3�M� +� /� /�Q� /� 7� 7�7�� ��� � � �?�M�3G�H�I�I�A�!�!�Q���1?�*1�s�!�(-�$� $� $�L�D�&� �D� �1�V�9�~�~���� �c�r�c�1�1�1�f�I�� �I�a��Q� � ��� �� � !�&��Q�v�Y� � ��5�5� ��� ��{�{�%�a��E�H�5C�.5�3�a�,1��(� (� (� ��f� �x��A����H��B�Q�B��F�)�H�U�2�A�2�Y����!�� �A� �f�h�v�&��D� � � 1�1r )r F)r )r8 r r Fr )r8 r FF)�__doc__�numpyr �warningsr � _optimizer r r � _linprog_utilr r r) r7 r^ rz r@ r r �<module>r� s� �� � �< � � � � � � � � � � N� N� N� N� N� N� N� N� N� N� %� %� %� %� %� %�:5� :5� :5� :5�zD � D � D � D �N<5� <5� <5� <5�@ GH�K� K� K� K�^ @E�_2� _2� _2� _2� _2� _2r
Save File
Cancel