| 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ĕ � � � d dl Z ddlmZ d dlZd dlmZmZmZmZm Z m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZ d dlmZ d dlmZmZmZmZm Z d dl m Z m Z d dl m Z! dd l"m#Z#m$Z$m%Z% dd
l&m'Z' dd l(m)Z) d d l*m+Z+ ej, Z,g d
�Z- d'd�Z. d(d�Z/ d)d�Z0g d�Z1g d�Z2 d*d�Z3d� Z4d� Z5d� Z6dddd ej ej fddfdd �d �Z7d+d �Z8d � Z9d!� Z:d"� Z;d,d&�Z<dS )-� N� )�_minpack)�
atleast_1d�dot�take�triu�shape�eye� transpose�zeros�prod�greater�asarray�inf�finfo�inexact�
issubdtype�dtype)�linalg)�svd�cholesky�solve_triangular� LinAlgError�inv)�_asarray_validated�
_lazywhere)�getfullargspec_no_self)�OptimizeResult�_check_unknown_options�OptimizeWarning)�
least_squares)�prepare_bounds)�Bounds)�fsolve�leastsq� fixed_point� curve_fitc � � t ||d |� f|z � � � }|��t |� � |k r�|d dk rt |� � dk r|d dk rt |� � S | �d|�d�}t |dd � � } | r |d| z z
}n|dz
}|d|�d t |� � �d�z
}t |� � �t |j t � � r|j }
nt
t � � }
t |� � |
fS )
Nr r zA: there is a mismatch between the input and output shape of the 'z
' argument�__name__z '%s'.�.zShape should be z but it is ) r r �len�getattr� TypeErrorr r r �float) �checker�argname�thefunc�x0�args� numinputs� output_shape�res�msg� func_name�dts �</usr/lib/python3/dist-packages/scipy/optimize/_minpack_py.py� _check_funcr; s$ � �
�W�W��:�I�:�� 0�4� 7�9�
:�
:�C�� �u�S�z�z�\�'A�'A� ��O�q� � ��<� � �1�$�$� ��?�a�'�'� ��:�:�%�29�'�'�7�7�7�D�C� ���T�:�:�I��
��x�)�+�+����s�
�� �C� � � �u�S�z�z�z�z�R� R�C��C�.�.� ��#�)�W�%�%� �
�Y���
�5�\�\�� ��:�:�r�>�� � �J�� P>�d c � �� ||||| |
| d�} t | ||fd|i| ���|r@�d }
t �fd�dD � � � � }�d |d< |
|�d �d fS �d }�d }|d
k rt |� � �|d k rn.|d v rt j |t
� � nt |� � ��d S )
a�
Find the roots of a function.
Return the roots of the (non-linear) equations defined by
``func(x) = 0`` given a starting estimate.
Parameters
----------
func : callable ``f(x, *args)``
A function that takes at least one (possibly vector) argument,
and returns a value of the same length.
x0 : ndarray
The starting estimate for the roots of ``func(x) = 0``.
args : tuple, optional
Any extra arguments to `func`.
fprime : callable ``f(x, *args)``, optional
A function to compute the Jacobian of `func` with derivatives
across the rows. By default, the Jacobian will be estimated.
full_output : bool, optional
If True, return optional outputs.
col_deriv : bool, optional
Specify whether the Jacobian function computes derivatives down
the columns (faster, because there is no transpose operation).
xtol : float, optional
The calculation will terminate if the relative error between two
consecutive iterates is at most `xtol`.
maxfev : int, optional
The maximum number of calls to the function. If zero, then
``100*(N+1)`` is the maximum where N is the number of elements
in `x0`.
band : tuple, optional
If set to a two-sequence containing the number of sub- and
super-diagonals within the band of the Jacobi matrix, the
Jacobi matrix is considered banded (only for ``fprime=None``).
epsfcn : float, optional
A suitable step length for the forward-difference
approximation of the Jacobian (for ``fprime=None``). If
`epsfcn` is less than the machine precision, it is assumed
that the relative errors in the functions are of the order of
the machine precision.
factor : float, optional
A parameter determining the initial step bound
(``factor * || diag * x||``). Should be in the interval
``(0.1, 100)``.
diag : sequence, optional
N positive entries that serve as a scale factors for the
variables.
Returns
-------
x : ndarray
The solution (or the result of the last iteration for
an unsuccessful call).
infodict : dict
A dictionary of optional outputs with the keys:
``nfev``
number of function calls
``njev``
number of Jacobian calls
``fvec``
function evaluated at the output
``fjac``
the orthogonal matrix, q, produced by the QR
factorization of the final approximate Jacobian
matrix, stored column wise
``r``
upper triangular matrix produced by QR factorization
of the same matrix
``qtf``
the vector ``(transpose(q) * fvec)``
ier : int
An integer flag. Set to 1 if a solution was found, otherwise refer
to `mesg` for more information.
mesg : str
If no solution is found, `mesg` details the cause of failure.
See Also
--------
root : Interface to root finding algorithms for multivariate
functions. See the ``method='hybr'`` in particular.
Notes
-----
``fsolve`` is a wrapper around MINPACK's hybrd and hybrj algorithms.
Examples
--------
Find a solution to the system of equations:
``x0*cos(x1) = 4, x1*x0 - x1 = 5``.
>>> import numpy as np
>>> from scipy.optimize import fsolve
>>> def func(x):
... return [x[0] * np.cos(x[1]) - 4,
... x[1] * x[0] - x[1] - 5]
>>> root = fsolve(func, [1, 1])
>>> root
array([6.50409711, 0.90841421])
>>> np.isclose(func(root), [0.0, 0.0]) # func(root) should be almost 0.0.
array([ True, True])
)� col_deriv�xtol�maxfev�band�eps�factor�diag�jac�xc 3 �N �K � | ] }|�v �|�� |� � fV � � d S �N)�get)�.0�kr6 s �r: � <genexpr>zfsolve.<locals>.<genexpr>� sF �� � � � O� O��Q�#�X�X� �����
�
�O�EM�X�X�X�O� Or< )�nfev�njev�fjac�r�qtf�fun�fvec�status�messager r )� � � � )�
_root_hybr�dictr- �warnings�warn�RuntimeWarning)�funcr2 r3 �fprime� full_outputrA rB rC rD �epsfcnrF rG �optionsrI �inforW r7 r6 s @r: r$ r$ 0 s" �� �V &�� �� � ��
� �G� �T�2�t�
;�
;��
;�7�
;�
;�C�� � ��H��� O� O� O� O� A�O� O� O� O� O���5�z��V� ��$��H�
�s�9�~�5�5��X� ���)�n�� �Q�;�;��C�.�.� �
�q�[�[� �
�|�
#�
#� �M�#�~� .� .� .� .��C�.�.� ��3�x�r< c
�L � t | � � |} t |� � � � � }t |� � }
t |t
� � s|f}t
dd| |||
|
f� � \ }}| �t |� � j } |}|�B|�d\ }}n
|dd� \ }}|dk rd|
dz z }t j
| ||d||||| | |
� � }nBt
dd ||||
|
|
f� � |dk rd
|
dz z }t j | |||d|||| |
�
�
}|d |d }}d d
d|z d|z dddd�}|d }|� d� � |d< t ||dk |�� � }|� |� � || |d< n# t $ r |d |d< Y nw xY w|S )a�
Find the roots of a multivariate function using MINPACK's hybrd and
hybrj routines (modified Powell method).
Options
-------
col_deriv : bool
Specify whether the Jacobian function computes derivatives down
the columns (faster, because there is no transpose operation).
xtol : float
The calculation will terminate if the relative error between two
consecutive iterates is at most `xtol`.
maxfev : int
The maximum number of calls to the function. If zero, then
``100*(N+1)`` is the maximum where N is the number of elements
in `x0`.
band : tuple
If set to a two-sequence containing the number of sub- and
super-diagonals within the band of the Jacobi matrix, the
Jacobi matrix is considered banded (only for ``fprime=None``).
eps : float
A suitable step length for the forward-difference
approximation of the Jacobian (for ``fprime=None``). If
`eps` is less than the machine precision, it is assumed
that the relative errors in the functions are of the order of
the machine precision.
factor : float
A parameter determining the initial step bound
(``factor * || diag * x||``). Should be in the interval
``(0.1, 100)``.
diag : sequence
N positive entries that serve as a scale factors for the
variables.
r$ rb N)���ri rY r �� r rc r? ���z'Improper input parameters were entered.zThe solution converged.z8The number of calls to function has reached maxfev = %d.�Wxtol=%f is too small, no further improvement in the approximate
solution is possible.zuThe iteration is not making good progress, as measured by the
improvement from the last five Jacobian evaluations.zjThe iteration is not making good progress, as measured by the
improvement from the last ten iterations.zAn error occurred.)r r rY rZ r[ r\ �unknownrV rU )rI �successrW rX rm )r r �flattenr+ �
isinstance�tupler; r rE r �_hybrd�_hybrj�popr �update�KeyError)rb r2 r3 rH rA rB rC rD rE rF rG �unknown_optionsre �nr r �Dfun�ml�mu�retvalrI rW �errorsrg �sols r: r] r] � s. � �L �?�+�+�+�
�F� ���� � � � �B� �B���A� �d�E� "� "� ��w�� �x���r�4��Q�D�I�I�L�E�5�
�~��u� � �!�� �D� �|� �<� �F�B����"�1�"�X�F�B�� �Q�;�;��A��E�]�F�� ��r�4��D�&�!#�R����?� ?��� �H�h��b�$��A�q�6�B�B�B� �a�K�K��A��E�]�F�� ��t�R��q�!*�D�&�&�$�H� H�� �q� �6�"�:�v�A�:�*�)�+1�2�!�#'�(�*�$� .�
/�
/�F� �!�9�D��(�(�6�"�"�D��K�
�1�v��{�F�
C�
C�
C�C��J�J�t����+� �� ��I���� � +� +� +� � �*��I����+���� �Js �= F � F!� F!�r rY rZ r[ )r\ � � � � c
� � t |� � � � � }t |� � }
t |t � � s|f}t dd| |||
� � \ }}|d }|
|k rt
d|
� d|� �� � �|
�t |� � j }
|�-| dk rd|
dz z } t j
| ||||||| |
| | � � }n^|rt dd ||||
|
|f� � nt dd ||||
||
f� � | dk rd
|
dz z } t j | ||||||||| | | � � }d t gd |z dgd
|z dgd||fz dgd|z dgd| z t gd|z t gd|z t gd|z t gd� }|d }|r�d}|t v r�|d d dz
}t |� � }
t t |d d � � d|
�dd�f � � }t! j d|f� � } ||� � \ }}|dk rt% d|� �� � �|� � � ||< ||j z }n# t$ t f$ r Y nw xY w|d |f|dd� z || d |fz S |t* v r't- j || d t0 � � n)|dk r# || d || d � � �|d |fS )a:
Minimize the sum of squares of a set of equations.
::
x = arg min(sum(func(y)**2,axis=0))
y
Parameters
----------
func : callable
Should take at least one (possibly length ``N`` vector) argument and
returns ``M`` floating point numbers. It must not return NaNs or
fitting might fail. ``M`` must be greater than or equal to ``N``.
x0 : ndarray
The starting estimate for the minimization.
args : tuple, optional
Any extra arguments to func are placed in this tuple.
Dfun : callable, optional
A function or method to compute the Jacobian of func with derivatives
across the rows. If this is None, the Jacobian will be estimated.
full_output : bool, optional
non-zero to return all optional outputs.
col_deriv : bool, optional
non-zero to specify that the Jacobian function computes derivatives
down the columns (faster, because there is no transpose operation).
ftol : float, optional
Relative error desired in the sum of squares.
xtol : float, optional
Relative error desired in the approximate solution.
gtol : float, optional
Orthogonality desired between the function vector and the columns of
the Jacobian.
maxfev : int, optional
The maximum number of calls to the function. If `Dfun` is provided,
then the default `maxfev` is 100*(N+1) where N is the number of elements
in x0, otherwise the default `maxfev` is 200*(N+1).
epsfcn : float, optional
A variable used in determining a suitable step length for the forward-
difference approximation of the Jacobian (for Dfun=None).
Normally the actual step length will be sqrt(epsfcn)*x
If epsfcn is less than the machine precision, it is assumed that the
relative errors are of the order of the machine precision.
factor : float, optional
A parameter determining the initial step bound
(``factor * || diag * x||``). Should be in interval ``(0.1, 100)``.
diag : sequence, optional
N positive entries that serve as a scale factors for the variables.
Returns
-------
x : ndarray
The solution (or the result of the last iteration for an unsuccessful
call).
cov_x : ndarray
The inverse of the Hessian. `fjac` and `ipvt` are used to construct an
estimate of the Hessian. A value of None indicates a singular matrix,
which means the curvature in parameters `x` is numerically flat. To
obtain the covariance matrix of the parameters `x`, `cov_x` must be
multiplied by the variance of the residuals -- see curve_fit.
infodict : dict
a dictionary of optional outputs with the keys:
``nfev``
The number of function calls
``fvec``
The function evaluated at the output
``fjac``
A permutation of the R matrix of a QR
factorization of the final approximate
Jacobian matrix, stored column wise.
Together with ipvt, the covariance of the
estimate can be approximated.
``ipvt``
An integer array of length N which defines
a permutation matrix, p, such that
fjac*p = q*r, where r is upper triangular
with diagonal elements of nonincreasing
magnitude. Column j of p is column ipvt(j)
of the identity matrix.
``qtf``
The vector (transpose(q) * fvec).
mesg : str
A string message giving information about the cause of failure.
ier : int
An integer flag. If it is equal to 1, 2, 3 or 4, the solution was
found. Otherwise, the solution was not found. In either case, the
optional output variable 'mesg' gives more information.
See Also
--------
least_squares : Newer interface to solve nonlinear least-squares problems
with bounds on the variables. See ``method='lm'`` in particular.
Notes
-----
"leastsq" is a wrapper around MINPACK's lmdif and lmder algorithms.
cov_x is a Jacobian approximation to the Hessian of the least squares
objective function.
This approximation assumes that the objective function is based on the
difference between some observed target data (ydata) and a (non-linear)
function of the parameters `f(xdata, params)` ::
func(params) = ydata - f(xdata, params)
so that the objective function is ::
min sum((ydata - f(xdata, params))**2, axis=0)
params
The solution, `x`, is always a 1-D array, regardless of the shape of `x0`,
or whether `x0` is a scalar.
Examples
--------
>>> from scipy.optimize import leastsq
>>> def func(x):
... return 2*(x-3)**2+1
>>> leastsq(func, 0)
(array([2.99999999]), 1)
r% rb r z+Improper input: func input vector length N=z- must not exceed func output vector length M=Nrj r ry r? zImproper input parameters.zTBoth actual and predicted relative reductions in the sum of squares
are at most %fzAThe relative error between two consecutive iterates is at most %fz�Both actual and predicted relative reductions in the sum of squares
are at most %f and the relative error between two consecutive iterates is at
most %fzhThe cosine of the angle between func(x) and any column of the
Jacobian is at most %f in absolute valuez4Number of calls to function has reached maxfev = %d.zOftol=%f is too small, no further reduction in the sum of squares
is possible.rl zbgtol=%f is too small, func(x) is orthogonal to the columns of
the Jacobian to machine precision.) r r rY rZ r[ r\ r� r� r� rk �ipvtrR �trtriztrtri returned info )r ro r+ rp rq r; r- r rE r �_lmdif�_lmder�
ValueError�LEASTSQ_SUCCESSr r r �get_lapack_funcsr �copy�T�LEASTSQ_FAILUREr_ r` ra )rb r2 r3 ry rd rA �ftolrB �gtolrC re rF rG rx r r �mr| r} rg �cov_x�permrS �inv_triu�invR�
trtri_infos r: r% r% s� � �~
���� � � � �B� �B���A� �d�E� "� "� ��w�� �y�&�$��D�!�D�D�L�E�5�
�a��A��1�u�u�� G�a� G� G�CD�G� G� H� H� H� �~��u� � �!�� �|� �Q�;�;��!�a�%�[�F�� ��r�4��d�D�!%�v�v�v�t�E� E��� � F� � �6�4��T�1�q�!�f� E� E� E� E� � �6�4��T�1�q�!�f� E� E� E� �Q�;�;��A��E�]�F�� ��t�R��{�!*�D�$��f�!'��/� /�� /� �:�<�>B�C�DH�J�+�-1�2�37�9�/� 37�� �>� @D�E�#�%)�*�+/�1�!�#)�*�+5�7�:�<@�A� � �=�?C�D� � � �!%�&�'1�3�)4� 4�F�2 �"�:�D�� ��� �?� "� "� �!�9�V�$�q�(�D��D� � �A��Y�v�a�y�� 0�1�1�"�1�"�a�a�a�%�8�9�9�A� �.�w���=�=�H�
�#+�8�A�;�;� ��j� ��?�?�%�&I�Z�&I�&I�J�J�J� !�Y�Y�[�[��T�
� �t�v�
���� ��,�
�
�
���
�����q� �5�!�F�1�R�4�L�0�F�4�L��O�T�3J�J�J� �?� "� "� �M�&��,�q�/�>� :� :� :� :�
�Q�Y�Y�!�&��,�q�/�&��,�q�/�2�2� 2��a�y�$�� s �7AH? �?I�Ic �Z � ���� ��� ��fd�}n �j dk r � ���fd�}n� ���fd�}|S )Nc � �� ��g| �R � �z
S rK r= )�paramsrb �xdata�ydatas ���r: � func_wrappedz _wrap_func.<locals>.func_wrapped� s �� ��4��'��'�'�'�%�/� /r< r c �" �� � ��g| �R � �z
z S rK r= �r� rb � transformr� r� s ����r: r� z _wrap_func.<locals>.func_wrapped� s% �� � ���U� 4�V� 4� 4� 4�u� <�=� =r< c �< �� t � ��g| �R � �z
d�� � S �NT��lower)r r� s ����r: r� z _wrap_func.<locals>.func_wrapped s0 �� �#�I�t�t�E�/C�F�/C�/C�/C�e�/K�SW�X�X�X� Xr< ��ndim)rb r� r� r� r� s ```` r: �
_wrap_funcr� � s� ����� ��� 0� 0� 0� 0� 0� 0� 0� 0� � �1� � � >� >� >� >� >� >� >� >� >� Y� Y� Y� Y� Y� Y� Y� Y� �r< c �R � ��� ��� �fd�}n�j dk r� ��fd�}n� ��fd�}|S )Nc � �� ��g| �R � S rK r= )r� rH r� s ��r: � jac_wrappedz _wrap_jac.<locals>.jac_wrapped s �� ��3�u�&�v�&�&�&� &r< r c �h �� �d d �t j f t j ��g| �R � � � z S rK )�np�newaxisr �r� rH r� r� s ���r: r� z _wrap_jac.<locals>.jac_wrapped s9 �� � �Q�Q�Q��
�]�+�b�j���U�9L�V�9L�9L�9L�.M�.M�M� Mr< c �Z �� t �t j ��g| �R � � � d�� � S r� )r r� r r� s ���r: r� z _wrap_jac.<locals>.jac_wrapped s5 �� �#�I�r�z�#�#�e�:M�f�:M�:M�:M�/N�/N�VZ�[�[�[� [r< r� )rH r� r� r� s ``` r: � _wrap_jacr� s� ���� ��� '� '� '� '� '� '� '� � �1� � � N� N� N� N� N� N� N� N� \� \� \� \� \� \� \� �r< c � � t j | � � }t j | � � }t j |� � }||z }d| | || z z ||< || z }| | dz ||< | |z }|| dz
||< |S )N� �?r )r� � ones_like�isfinite)�lb�ub�p0� lb_finite� ub_finite�masks r: �_initialize_feasibler� s� � � � �b� � �B�� �B���I�� �B���I� �y� �D��b��h��D��)�*�B�t�H� � �z� !�D��$�x�!�|�B�t�H� �:� � !�D��$�x�!�|�B�t�H�
�Ir< FT)rd c
�$
� |�Kt | � � } | j }
t |
� � dk rt d� � �t |
� � dz
}nt j |� � }|j }t |t � � r|j |j
}}nt ||� � \ }}|�t ||� � }t j
|t j k |t j k z � � }|�|rd}nd}|dk r|rt d� � �|rt j |t � � }nt j |t � � }t |t$ t& t j f� � r7|rt j |t � � }nt j |t � � }|j dk rt d � � �|��t j |� � }|j |j fk rd
|z }n]|j |j |j fk r5 t- |d � � � }n3# t. $ r}t d
� � |�d}~ww xY wt d� � �d}t1 | |||� � }t3 | � � rt5 | ||� � } n
| �|dk rd} d| v rt d� � �|dk r�|j dk r%||j k rt7 d|� d|j � �� � �t9 ||f| dd�| ��}|\ }}}}}t |d � � }t j |d dz � � } |dvrt= d|z � � ��n1d| vr| � dd� � | d< tA ||f| ||d�| ��}|j! st= d|j" z � � �tG |j$ |j% �� � }|j& }|j" }t |j% � � }d|j' z } |j( }tS |j* d � � � \ } } } t j+ t � � j, t[ |j* j � � z | d z } | | | k } | d| j � } t j. | j/ | dz z | � � }d }!|�Ota t |� � t |� � ft � � � }|�1 t � � d }!n<|s:||j k r| ||j z
z }"||"z }n |�1 t � � d }!|!rte j3 d th � � � |
r|||||fS ||fS )!a�$
Use non-linear least squares to fit a function, f, to data.
Assumes ``ydata = f(xdata, *params) + eps``.
Parameters
----------
f : callable
The model function, f(x, ...). It must take the independent
variable as the first argument and the parameters to fit as
separate remaining arguments.
xdata : array_like
The independent variable where the data is measured.
Should usually be an M-length sequence or an (k,M)-shaped array for
functions with k predictors, and each element should be float
convertible if it is an array like object.
ydata : array_like
The dependent data, a length M array - nominally ``f(xdata, ...)``.
p0 : array_like, optional
Initial guess for the parameters (length N). If None, then the
initial values will all be 1 (if the number of parameters for the
function can be determined using introspection, otherwise a
ValueError is raised).
sigma : None or M-length sequence or MxM array, optional
Determines the uncertainty in `ydata`. If we define residuals as
``r = ydata - f(xdata, *popt)``, then the interpretation of `sigma`
depends on its number of dimensions:
- A 1-D `sigma` should contain values of standard deviations of
errors in `ydata`. In this case, the optimized function is
``chisq = sum((r / sigma) ** 2)``.
- A 2-D `sigma` should contain the covariance matrix of
errors in `ydata`. In this case, the optimized function is
``chisq = r.T @ inv(sigma) @ r``.
.. versionadded:: 0.19
None (default) is equivalent of 1-D `sigma` filled with ones.
absolute_sigma : bool, optional
If True, `sigma` is used in an absolute sense and the estimated parameter
covariance `pcov` reflects these absolute values.
If False (default), only the relative magnitudes of the `sigma` values matter.
The returned parameter covariance matrix `pcov` is based on scaling
`sigma` by a constant factor. This constant is set by demanding that the
reduced `chisq` for the optimal parameters `popt` when using the
*scaled* `sigma` equals unity. In other words, `sigma` is scaled to
match the sample variance of the residuals after the fit. Default is False.
Mathematically,
``pcov(absolute_sigma=False) = pcov(absolute_sigma=True) * chisq(popt)/(M-N)``
check_finite : bool, optional
If True, check that the input arrays do not contain nans of infs,
and raise a ValueError if they do. Setting this parameter to
False may silently produce nonsensical results if the input arrays
do contain nans. Default is True.
bounds : 2-tuple of array_like or `Bounds`, optional
Lower and upper bounds on parameters. Defaults to no bounds.
There are two ways to specify the bounds:
- Instance of `Bounds` class.
- 2-tuple of array_like: Each element of the tuple must be either
an array with the length equal to the number of parameters, or a
scalar (in which case the bound is taken to be the same for all
parameters). Use ``np.inf`` with an appropriate sign to disable
bounds on all or some parameters.
method : {'lm', 'trf', 'dogbox'}, optional
Method to use for optimization. See `least_squares` for more details.
Default is 'lm' for unconstrained problems and 'trf' if `bounds` are
provided. The method 'lm' won't work when the number of observations
is less than the number of variables, use 'trf' or 'dogbox' in this
case.
.. versionadded:: 0.17
jac : callable, string or None, optional
Function with signature ``jac(x, ...)`` which computes the Jacobian
matrix of the model function with respect to parameters as a dense
array_like structure. It will be scaled according to provided `sigma`.
If None (default), the Jacobian will be estimated numerically.
String keywords for 'trf' and 'dogbox' methods can be used to select
a finite difference scheme, see `least_squares`.
.. versionadded:: 0.18
full_output : boolean, optional
If True, this function returns additioal information: `infodict`,
`mesg`, and `ier`.
.. versionadded:: 1.9
**kwargs
Keyword arguments passed to `leastsq` for ``method='lm'`` or
`least_squares` otherwise.
Returns
-------
popt : array
Optimal values for the parameters so that the sum of the squared
residuals of ``f(xdata, *popt) - ydata`` is minimized.
pcov : 2-D array
The estimated covariance of popt. The diagonals provide the variance
of the parameter estimate. To compute one standard deviation errors
on the parameters use ``perr = np.sqrt(np.diag(pcov))``.
How the `sigma` parameter affects the estimated covariance
depends on `absolute_sigma` argument, as described above.
If the Jacobian matrix at the solution doesn't have a full rank, then
'lm' method returns a matrix filled with ``np.inf``, on the other hand
'trf' and 'dogbox' methods use Moore-Penrose pseudoinverse to compute
the covariance matrix.
infodict : dict (returned only if `full_output` is True)
a dictionary of optional outputs with the keys:
``nfev``
The number of function calls. Methods 'trf' and 'dogbox' do not
count function calls for numerical Jacobian approximation,
as opposed to 'lm' method.
``fvec``
The function values evaluated at the solution.
``fjac``
A permutation of the R matrix of a QR
factorization of the final approximate
Jacobian matrix, stored column wise.
Together with ipvt, the covariance of the
estimate can be approximated.
Method 'lm' only provides this information.
``ipvt``
An integer array of length N which defines
a permutation matrix, p, such that
fjac*p = q*r, where r is upper triangular
with diagonal elements of nonincreasing
magnitude. Column j of p is column ipvt(j)
of the identity matrix.
Method 'lm' only provides this information.
``qtf``
The vector (transpose(q) * fvec).
Method 'lm' only provides this information.
.. versionadded:: 1.9
mesg : str (returned only if `full_output` is True)
A string message giving information about the solution.
.. versionadded:: 1.9
ier : int (returnned only if `full_output` is True)
An integer flag. If it is equal to 1, 2, 3 or 4, the solution was
found. Otherwise, the solution was not found. In either case, the
optional output variable `mesg` gives more information.
.. versionadded:: 1.9
Raises
------
ValueError
if either `ydata` or `xdata` contain NaNs, or if incompatible options
are used.
RuntimeError
if the least-squares minimization fails.
OptimizeWarning
if covariance of the parameters can not be estimated.
See Also
--------
least_squares : Minimize the sum of squares of nonlinear functions.
scipy.stats.linregress : Calculate a linear least squares regression for
two sets of measurements.
Notes
-----
Users should ensure that inputs `xdata`, `ydata`, and the output of `f`
are ``float64``, or else the optimization may return incorrect results.
With ``method='lm'``, the algorithm uses the Levenberg-Marquardt algorithm
through `leastsq`. Note that this algorithm can only deal with
unconstrained problems.
Box constraints can be handled by methods 'trf' and 'dogbox'. Refer to
the docstring of `least_squares` for more information.
Examples
--------
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.optimize import curve_fit
>>> def func(x, a, b, c):
... return a * np.exp(-b * x) + c
Define the data to be fit with some noise:
>>> xdata = np.linspace(0, 4, 50)
>>> y = func(xdata, 2.5, 1.3, 0.5)
>>> rng = np.random.default_rng()
>>> y_noise = 0.2 * rng.normal(size=xdata.size)
>>> ydata = y + y_noise
>>> plt.plot(xdata, ydata, 'b-', label='data')
Fit for the parameters a, b, c of the function `func`:
>>> popt, pcov = curve_fit(func, xdata, ydata)
>>> popt
array([2.56274217, 1.37268521, 0.47427475])
>>> plt.plot(xdata, func(xdata, *popt), 'r-',
... label='fit: a=%5.3f, b=%5.3f, c=%5.3f' % tuple(popt))
Constrain the optimization to the region of ``0 <= a <= 3``,
``0 <= b <= 1`` and ``0 <= c <= 0.5``:
>>> popt, pcov = curve_fit(func, xdata, ydata, bounds=(0, [3., 1., 0.5]))
>>> popt
array([2.43736712, 1. , 0.34463856])
>>> plt.plot(xdata, func(xdata, *popt), 'g--',
... label='fit: a=%5.3f, b=%5.3f, c=%5.3f' % tuple(popt))
>>> plt.xlabel('x')
>>> plt.ylabel('y')
>>> plt.legend()
>>> plt.show()
NrY z-Unable to determine number of fit parameters.r �trf�lmzQMethod 'lm' only works for unconstrained problems. Use 'trf' or 'dogbox' instead.r z`ydata` must not be empty!g �?Tr� z"`sigma` must be positive definite.z `sigma` has incorrect shape.z2-pointr3 z+'args' is not a supported keyword argument.z The number of func parameters=z+ must not exceed the number of data points=)ry rd rV r z Optimal parameters not found: �max_nfevrC )rH �bounds�method)rP rV F)�
full_matrices)r z3Covariance of the parameters could not be estimated)�category)5�_getfullargspecr3 r+ r� r� r �sizerp r# r� r� r" r� �anyr �asarray_chkfiniter. r �listrq �ndarrayr r r r� �callabler� r- r% �sum� RuntimeErrorrt r! rn rX r^ rP rU rW �costrI r rH r rE �maxr r� r �fillr_ r` r )#�fr� r� r� �sigma�absolute_sigma� check_finiter� r� rH rd �kwargs�sigr3 rx r� r� �bounded_problemr� �erb r6 �popt�pcov�infodict�errmsg�ier�ysizer� �_�s�VT� threshold�warn_cov�s_sqs# r: r' r' % s� � �B
�z� �a� � ���x�� �t�9�9�q�=�=� � L�M�M� M� ��I�I��M���
�]�2�
�
�� �G���&�&�!�!� +���F�I�B��� ���*�*���B� �z�
!�"�b�
)�
)���f�b�B�F�7�l�r�B�F�{� ;�<�<�O�
�~� � ��F�F��F�
��~�~�/�~�� :� ;� ;� ;� � )��$�U�E�2�2����
�5�%�(�(���%�$��r�z�2�3�3� -� � -��(���6�6�E�E��J�u�e�,�,�E� �z�Q����5�6�6�6�
���
�5�!�!�� �;�5�:�.� (� (��e� �I�I� �[�U�Z��� 4�
4�
4�
N� $�U�$� 7� 7� 7� � �� �
N�
N�
N� �!E�F�F�A�M�����
N���� � ;�<�<� <�� � �a���y� 1� 1�D���}�}� ���U�I�.�.��� ���4� � ���
���� �F�G�G�G�
��~�~� �:��?�?�q�5�:�~�~�� N�Q� N� N�AF�� N� N� O� O�
O��d�B�B�S�a�B�B�6�B�B��,/�)��d�H�f�c��H�V�$�%�%���v�h�v�&�!�+�,�,�� �l� "� "� � ?�&� H�I�I� I� #� �V� #� #�!'���H�d�!;�!;�F�:� ��D�"� &�#�f�V� &� &� $�&� &�� �{� O� � ?�#�+� M�N�N� N��S�X�C�G�4�4�4���j������C�G� � ���3�8�|���u�� �s�w�e�4�4�4���1�b��H�U�O�O�'�#�c�g�m�*<�*<�<�q��t�C� �
�a�)�m� ��
�����[���v�b�d�Q��T�k�2�&�&���H� �|��c�$�i�i��T���+�5�9�9�9�� � � �#�������
� � �2�7�?�?��5�2�7�?�+�D��$�;�D�D� �I�I�c�N�N�N��H�� 0��
�K� .� 0� 0� 0� 0� � ��T�8�V�S�0�0��T�z�s �:H �
H+�H&�&H+c �� � t |� � }t |� � }|� |f� � }t | |g|�R � � � }t |� � }|� |f� � }|} t ||g|�R � � � }
|
� ||f� � }
|dk rt |
� � }
t |ft
� � } t |ft
� � } d}
t
j |||||
| | |
d| �
�
t | | g|�R � � � }
|
� |f� � }
t
j |||||
| | |
d| �
�
t t | d� � d�� � }|| fS )z=Perform a simple check on the gradient for correctness.
r Nr rY r� )�axis)
r r+ �reshaper r r. r �_chkderr
r )�fcn�Dfcnr2 r3 rA rI rx rV r� �ldfjacrR �xp�err�fvecp�goods r: �check_gradientr� � sn � �
�2���A� �A���A� � � �1�$���A� �c�c�!�m�d�m�m�m� $� $�D� �D� � �A� �<�<��� � �D�
�F� �d�d�1�n�t�n�n�n� %� %�D� �<�<��A�� � �D��A�~�~������ ��t�U� � �B�
���e�
�
�C� �E� ��Q��1�d�D�&�"�e�Q��D�D�D� �s�s�2�~��~�~�~� &� &�E� �M�M�1�$� � �E� ��Q��1�d�D�&�"�e�Q��D�D�D� ���c�"�"�� +� +� +�D� �#�;�r< c �< � | t j || z
� � |z z
S rK )r� �square)r� �p1�ds r: �_del2r� � s � �
�� �"�r�'�"�"�Q�&� &�&r< c � � | |z
|z S rK r= )�actual�desireds r: �_relerrr� � s � � �W� �� '�'r< c �t � |}t |� � D ]�} | |g|�R � }|r4 | |g|�R � } | d|z z
|z }
t |
dk |||
ft | �� � } n|} t |dk | |ft | �� � } t j t j | � � |k � � r| c S | }��d|| fz }
t |
� � �)Ng @r )r� � fillvaluez3Failed to converge after %d iterations, value is %s)�ranger r� r� r� �all�absr� )rb r2 r3 rB �maxiter� use_accelr� �ir� �p2r� �p�relerrr7 s r: �_fixed_point_helperr � s� � � �B�
�7�^�^� � ��
�T�"�_�t�_�_�_�� � ���b� �4� � � �B��S�2�X�
��"�A��1��6�B��A�;�%�2�F�F�F�A�A��A��B�!�G�a��W��1�E�E�E��
�6�"�&��.�.�4�'� (� (� ��H�H�H�
���
?�7�A�,�
N�C�
�s�
�
�r< �:�0�yE>�� �del2c �b � ddd�| }t |d�� � }t | |||||� � S )a'
Find a fixed point of the function.
Given a function of one or more variables and a starting point, find a
fixed point of the function: i.e., where ``func(x0) == x0``.
Parameters
----------
func : function
Function to evaluate.
x0 : array_like
Fixed point of function.
args : tuple, optional
Extra arguments to `func`.
xtol : float, optional
Convergence tolerance, defaults to 1e-08.
maxiter : int, optional
Maximum number of iterations, defaults to 500.
method : {"del2", "iteration"}, optional
Method of finding the fixed-point, defaults to "del2",
which uses Steffensen's Method with Aitken's ``Del^2``
convergence acceleration [1]_. The "iteration" method simply iterates
the function until convergence is detected, without attempting to
accelerate the convergence.
References
----------
.. [1] Burden, Faires, "Numerical Analysis", 5th edition, pg. 80
Examples
--------
>>> import numpy as np
>>> from scipy import optimize
>>> def func(x, c1, c2):
... return np.sqrt(c1/(x+c2))
>>> c1 = np.array([10,12.])
>>> c2 = np.array([3, 5.])
>>> optimize.fixed_point(func, [1.2, 1.3], args=(c1,c2))
array([ 1.4920333 , 1.37228132])
TF)r � iteration)�
as_inexact)r r )rb r2 r3 rB r� r� r� s r: r& r& � sA � �T �E�2�2�6�:�I� �B�4� 0� 0� 0�B� �t�R��t�W�i� H� H�Hr< rK )
r= Nr r r> r NNr? N) r= Nr r> r NNr? N) r= Nr r r> r> r� r Nr? N)r= r )r= r r r )=r_ � r �numpyr� r r r r r r
r r r
r r r r r r r �scipyr � scipy.linalgr r r r r �scipy._lib._utilr r r r� � _optimizer r r �_lsqr! �_lsq.least_squaresr" �scipy.optimize._minimizer# �error�__all__r; r$ r] r� r� r% r� r� r� r' r� r� r� r r& r= r< r: �<module>r s �� ���� � � � � � � � � � �6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� 6� � � � � � � J� J� J� J� J� J� J� J� J� J� J� J� J� J� ;� ;� ;� ;� ;� ;� ;� ;� F� F� F� F� F� F� N� N� N� N� N� N� N� N� N� N� � � � � � � .� .� .� .� .� .� +� +� +� +� +� +����
;�
;�
;�� "�� � � �0 89�8<�)-�E� E� E� E�P '+�GK� $�[� [� [� [�| �,�,�� �,�,�� 78�/9�>B�U � U � U � U �p� � �*
�
�
�� � �" #'�d�5� �"�&��"�&�(9�$��k�',�k� k� k� k� k�\ � � � �>'� '� '�(� (� (� � � �$,I� ,I� ,I� ,I� ,I� ,Ir<