| Server IP : 217.160.0.135 / Your IP : 216.73.217.37 Web Server : Apache System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64 User : sws1074145052 ( 1074145052) PHP Version : 8.3.32 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /lib/python3/dist-packages/scipy/optimize/__pycache__/ |
Upload File : |
�
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