| Server IP : 217.160.0.135 / Your IP : 216.73.217.85 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 : /usr/lib/python3/dist-packages/scipy/odr/__pycache__/ |
Upload File : |
�
d�cW� � �X � d Z ddlZddlZddlmZ ddlmZ g d�Zej Z G d� de � � Z
G d� d e � � Z G d
� d e � � Z
e Ze
Z ej e e
� � dd �Zd
� Z G d� d� � Z G d� de� � Z G d� d� � Z G d� d� � Z G d� d� � ZdS )a
Python wrappers for Orthogonal Distance Regression (ODRPACK).
Notes
=====
* Array formats -- FORTRAN stores its arrays in memory column first, i.e., an
array element A(i, j, k) will be next to A(i+1, j, k). In C and, consequently,
NumPy, arrays are stored row first: A[i, j, k] is next to A[i, j, k+1]. For
efficiency and convenience, the input and output arrays of the fitting
function (and its Jacobians) are passed to FORTRAN without transposition.
Therefore, where the ODRPACK documentation says that the X array is of shape
(N, M), it will be passed to the Python function as an array of shape (M, N).
If M==1, the 1-D case, then nothing matters; if M>1, then your
Python functions will be dealing with arrays that are indexed in reverse of
the ODRPACK documentation. No real issue, but watch out for your indexing of
the Jacobians: the i,jth elements (@f_i/@x_j) evaluated at the nth
observation will be returned as jacd[j, i, n]. Except for the Jacobians, it
really is easier to deal with x[0] and x[1] than x[:,0] and x[:,1]. Of course,
you can always use the transpose() function from SciPy explicitly.
* Examples -- See the accompanying file test/test.py for examples of how to set
up fits of your own. Some are taken from the User's Guide; some are from
other sources.
* Models -- Some common models are instantiated in the accompanying module
models.py . Contributions are welcome.
Credits
=======
* Thanks to Arnold Moene and Gerard Vermeulen for fixing some killer bugs.
Robert Kern
robert.kern@gmail.com
� N)�warn)� __odrpack) �odr�
OdrWarning�OdrError�OdrStop�Data�RealData�Model�Output�ODR� odr_error�odr_stopc � � e Zd ZdZdS )r z�
Warning indicating that the data passed into
ODR will cause problems when passed into 'odr'
that the user should be aware of.
N��__name__�
__module__� __qualname__�__doc__� � �4/usr/lib/python3/dist-packages/scipy/odr/_odrpack.pyr r 3 � � � � � � �� �
�Dr r c � � e Zd ZdZdS )r z~
Exception indicating an error in fitting.
This is raised by `~scipy.odr.odr` if an error occurs during fitting.
Nr r r r r r < r r r c � � e Zd ZdZdS )r z�
Exception stopping fitting.
You can raise this exception in your objective function to tell
`~scipy.odr.odr` to stop fitting.
Nr r r r r r E s � � � � � �� � �Dr r c � � | �| S |�t j | � � } nt j | |� � } | j dk r| j � | � � S | S )zK Convert an object to the preferred form for input to the odr routine.
Nr )�numpy�asarray�shape�dtype�type)�objr s r �_convr# V sY � � �{��
� �=��-��$�$�C�C��-��U�+�+�C� �9��?�?��9�>�>�#�&�&� &��Jr c � � d| dz }| dk �r�| dz dz | dz dz | dz dz | dz dz | dz f}g }|d dk rz|d dk r|� d � � |d
dk r|� d � � |d dk r|� d
� � |� |� � �n|d dk r�|d dk r|� d� � |d
dk r|� d� � |d dk r|� d� � |d dk r|� d� � �n�|d d
k r�|d dk r|� d� � |d
dk r|� d� � |d dk r|� d� � |d dk r|� d� � n�|d d k r�|d dk r|� d� � |d
dk r|� d� � |d dk r|� d� � |d dk r|� d� � ne|d dk r|� d� � nC|d dk r|� d � � n!|d d k r|� d � � |S |gS ) a Interprets the return code of the odr routine.
Parameters
----------
info : int
The return code of the odr routine.
Returns
-------
problems : list(str)
A list of messages about why the odr() routine stopped.
)�BlankzSum of squares convergencezParameter convergencez-Both sum of squares and parameter convergencezIteration limit reached� �' �
�� �d r � z Derivatives possibly not correct� zError occurred in callback� z$Problem is not full rank at solutionzN < 1zM < 1zNP < 1 or NP > N� zNQ < 1zLDY and/or LDX incorrectz)LDWE, LD2WE, LDWD, and/or LD2WD incorrectz&LDIFX, LDSTPD, and/or LDSCLD incorrectz LWORK and/or LIWORK too smallzSTPB and/or STPD incorrectzSCLB and/or SCLD incorrectz WE incorrectz WD incorrectzError in derivatives� zNumerical error detected)�append)�info�
stopreason�I�problemss r �
_report_errorr5 h s � � -� .2�A�X� 7�J� �q�y�y� �5�[�2�
�
�4�Z�"�_�
�3�Y��^�
�2�X��]�
�B�Y�
��
�� �Q�4�1�9�9���t�q�y�y���� B�C�C�C���t�q�y�y���� <�=�=�=���t�q�y�y���� F�G�G�G� �O�O�J� '� '� '� '�
�q�T�Q�Y�Y���t�q�y�y�����(�(�(���t�q�y�y�����(�(�(���t�q�y�y���� 2�3�3�3���t�q�y�y�����)�)�)��
�q�T�Q�Y�Y���t�q�y�y���� :�;�;�;���t�q�y�y���� K�L�L�L���t�q�y�y���� H�I�I�I���t�q�y�y���� ?�@�@�@��
�q�T�Q�Y�Y���t�q�y�y���� <�=�=�=���t�q�y�y���� <�=�=�=���t�q�y�y�����/�/�/���t�q�y�y�����/�/�/��
�q�T�Q�Y�Y� �O�O� 2� 3� 3� 3� 3�
�q�T�Q�Y�Y� �O�O� 8� 9� 9� 9� 9�
�q�T�Q�Y�Y� �O�O� 6� 7� 7� 7��� �|�r c �& � e Zd ZdZdd�Zd� Zd� ZdS )r a\
The data to fit.
Parameters
----------
x : array_like
Observed data for the independent variable of the regression
y : array_like, optional
If array-like, observed data for the dependent variable of the
regression. A scalar input implies that the model to be used on
the data is implicit.
we : array_like, optional
If `we` is a scalar, then that value is used for all data points (and
all dimensions of the response variable).
If `we` is a rank-1 array of length q (the dimensionality of the
response variable), then this vector is the diagonal of the covariant
weighting matrix for all data points.
If `we` is a rank-1 array of length n (the number of data points), then
the i'th element is the weight for the i'th response variable
observation (single-dimensional only).
If `we` is a rank-2 array of shape (q, q), then this is the full
covariant weighting matrix broadcast to each observation.
If `we` is a rank-2 array of shape (q, n), then `we[:,i]` is the
diagonal of the covariant weighting matrix for the i'th observation.
If `we` is a rank-3 array of shape (q, q, n), then `we[:,:,i]` is the
full specification of the covariant weighting matrix for each
observation.
If the fit is implicit, then only a positive scalar value is used.
wd : array_like, optional
If `wd` is a scalar, then that value is used for all data points
(and all dimensions of the input variable). If `wd` = 0, then the
covariant weighting matrix for each observation is set to the identity
matrix (so each dimension of each observation has the same weight).
If `wd` is a rank-1 array of length m (the dimensionality of the input
variable), then this vector is the diagonal of the covariant weighting
matrix for all data points.
If `wd` is a rank-1 array of length n (the number of data points), then
the i'th element is the weight for the ith input variable observation
(single-dimensional only).
If `wd` is a rank-2 array of shape (m, m), then this is the full
covariant weighting matrix broadcast to each observation.
If `wd` is a rank-2 array of shape (m, n), then `wd[:,i]` is the
diagonal of the covariant weighting matrix for the ith observation.
If `wd` is a rank-3 array of shape (m, m, n), then `wd[:,:,i]` is the
full specification of the covariant weighting matrix for each
observation.
fix : array_like of ints, optional
The `fix` argument is the same as ifixx in the class ODR. It is an
array of integers with the same shape as data.x that determines which
input observations are treated as fixed. One can use a sequence of
length m (the dimensionality of the input observations) to fix some
dimensions for all observations. A value of 0 fixes the observation,
a value > 0 makes it free.
meta : dict, optional
Free-form dictionary for metadata.
Notes
-----
Each argument is attached to the member of the instance of the same name.
The structures of `x` and `y` are described in the Model class docstring.
If `y` is an integer, then the Data instance can only be used to fit with
implicit models where the dimensionality of the response is equal to the
specified value of `y`.
The `we` argument weights the effect a deviation in the response variable
has on the fit. The `wd` argument weights the effect a deviation in the
input variable has on the fit. To handle multidimensional inputs and
responses easily, the structure of these arguments has the n'th
dimensional axis first. These arguments heavily use the structured
arguments feature of ODRPACK to conveniently and flexibly support all
options. See the ODRPACK User's Guide for a full explanation of how these
weights are used in the algorithm. Basically, a higher value of the weight
for a particular data point makes a deviation at that point more
detrimental to the fit.
Nc � � t |� � | _ t | j t j � � s:t d� t | j � � j �� � � � �t |� � | _ t |� � | _
t |� � | _ t |� � | _ |�i n|| _
d S )N�LExpected an 'ndarray' of data for 'x', but instead got data of type '{name}'��name)r# �x�
isinstancer �ndarray�
ValueError�formatr! r �y�we�wd�fix�meta)�selfr; r@ rA rB rC rD s r �__init__z
Data.__init__ s� � ��q������$�&�%�-�0�0� 1� � F�GM�v� �d�f� � �.� HN� H0� H0�1� 1�
1� �q�������)�)�����)�)�����:�:��� �,�B�B�D�� � � r c �: � | j � |� � dS )z� Update the metadata dictionary with the keywords and data provided
by keywords.
Examples
--------
::
data.set_meta(lab="Ph 7; Lab 26", title="Ag110 + Ag108 Decay")
N�rD �update�rE �kwdss r �set_metaz
Data.set_meta s � �
� ���� � � � � r c �R � || j v r
| j | S t d|z � � �)z? Dispatch attribute access to the metadata dictionary.
�'%s' not in metadata�rD �AttributeError�rE �attrs r � __getattr__zData.__getattr__ s1 � � �4�9� � ��9�T�?� "� �!7�$�!>�?�?� ?r �NNNNN�r r r r rF rL rS r r r r r � sX � � � � � �K� K�Z 1� 1� 1� 1� � � �@� @� @� @� @r r c �0 � e Zd ZdZ dd�Zd� Zd� Zd� ZdS )r
a�
The data, with weightings as actual standard deviations and/or
covariances.
Parameters
----------
x : array_like
Observed data for the independent variable of the regression
y : array_like, optional
If array-like, observed data for the dependent variable of the
regression. A scalar input implies that the model to be used on
the data is implicit.
sx : array_like, optional
Standard deviations of `x`.
`sx` are standard deviations of `x` and are converted to weights by
dividing 1.0 by their squares.
sy : array_like, optional
Standard deviations of `y`.
`sy` are standard deviations of `y` and are converted to weights by
dividing 1.0 by their squares.
covx : array_like, optional
Covariance of `x`
`covx` is an array of covariance matrices of `x` and are converted to
weights by performing a matrix inversion on each observation's
covariance matrix.
covy : array_like, optional
Covariance of `y`
`covy` is an array of covariance matrices and are converted to
weights by performing a matrix inversion on each observation's
covariance matrix.
fix : array_like, optional
The argument and member fix is the same as Data.fix and ODR.ifixx:
It is an array of integers with the same shape as `x` that
determines which input observations are treated as fixed. One can
use a sequence of length m (the dimensionality of the input
observations) to fix some dimensions for all observations. A value
of 0 fixes the observation, a value > 0 makes it free.
meta : dict, optional
Free-form dictionary for metadata.
Notes
-----
The weights `wd` and `we` are computed from provided values as follows:
`sx` and `sy` are converted to weights by dividing 1.0 by their squares.
For example, ``wd = 1./numpy.power(`sx`, 2)``.
`covx` and `covy` are arrays of covariance matrices and are converted to
weights by performing a matrix inversion on each observation's covariance
matrix. For example, ``we[i] = numpy.linalg.inv(covy[i])``.
These arguments follow the same structured argument conventions as wd and
we only restricted by their natures: `sx` and `sy` can't be rank-3, but
`covx` and `covy` can be.
Only set *either* `sx` or `covx` (not both). Setting both will raise an
exception. Same with `sy` and `covy`.
Nc � � |�|�t d� � �|�|�t d� � �i | _ |� d| j d< n
d| j d< |� d| j d< n
d| j d< t |� � | _ t | j t
j � � s:t d � t | j � � j �
� � � � �t |� � | _
t |� � | _ t |� � | _ t |� � | _
t |� � | _ t |� � | _ |�i n|| _ d S ) Nzcannot set both sx and covxzcannot set both sy and covy�sxrB �covx�syrA �covyr8 r9 )r> � _ga_flagsr# r; r< r r= r? r! r r@ rX rZ rY r[ rC rD ) rE r; r@ rX rZ rY r[ rC rD s r rF zRealData.__init__e sA � � �N��!1� � :�;�;� ;� �N��!1� � :�;�;� ;� ���
�>�#'�D�N�4� � �#)�D�N�4� �
�>�#'�D�N�4� � �#)�D�N�4� ��q������$�&�%�-�0�0� 1� � F�GM�v� �d�f� � �.� HN� H0� H0�1� 1�
1� �q�������)�)�����)�)����$�K�K�� ��$�K�K�� ���:�:��� �,�B�B�D�� � � r c �2 � dt j |d� � z S )z0 Convert standard deviation to weights.
g �?r, )r �power)rE �sds r �_sd2wtzRealData._sd2wt� s � � �%�+�b�!�$�$�$�$r c � � ddl m} t |j � � dk r ||� � S t j |j t � � }t |j d � � D ]$} ||dd�dd�|f � � |dd�dd�|f< �%|S )z6 Convert covariance matrix(-ices) to weights.
r )�invr, ���N)� scipy.linalgrb �lenr r �zeros�float�range)rE �covrb �weights�is r �_cov2wtzRealData._cov2wt� s� � � %�$�$�$�$�$� �s�y�>�>�Q� � ��3�s�8�8�O��k�#�)�U�3�3�G��3�9�R�=�)�)�
1�
1��!$��S����1�1�1�Q��Z� � �����!�!�!�A�����Nr c � � | j | j f| j | j f| j | j f| j | j fd�}|dvr(|| j v r
| j | S t d|z � � �||| j | f \ }}|� ||f� S d S )N))rB rX )rB rY )rA rZ )rA r[ )rB rA rN ) r` rX rl rY rZ r[ rD rP r\ )rE rR �
lookup_tbl�func�args r rS zRealData.__getattr__� s� � �%)�[�$�'�$:�'+�|�T�Y�&?�%)�[�$�'�$:�'+�|�T�Y�&?�A� A�
�
�|� #� #��t�y� � ��y���&�$�%;�d�%B�C�C�C�"�D�$�.��*>�#?�@�I�D�#����t�c�V�}�$��tr �NNNNNNN)r r r r rF r` rl rS r r r r
r
( sk � � � � � �:� :�x EI� $� 1� 1� 1� 1�B%� %� %� � � � � � � � r r
c �* � e Zd ZdZ dd�Zd� Zd� ZdS )r a�
The Model class stores information about the function you wish to fit.
It stores the function itself, at the least, and optionally stores
functions which compute the Jacobians used during fitting. Also, one
can provide a function that will provide reasonable starting values
for the fit parameters possibly given the set of data.
Parameters
----------
fcn : function
fcn(beta, x) --> y
fjacb : function
Jacobian of fcn wrt the fit parameters beta.
fjacb(beta, x) --> @f_i(x,B)/@B_j
fjacd : function
Jacobian of fcn wrt the (possibly multidimensional) input
variable.
fjacd(beta, x) --> @f_i(x,B)/@x_j
extra_args : tuple, optional
If specified, `extra_args` should be a tuple of extra
arguments to pass to `fcn`, `fjacb`, and `fjacd`. Each will be called
by `apply(fcn, (beta, x) + extra_args)`
estimate : array_like of rank-1
Provides estimates of the fit parameters from the data
estimate(data) --> estbeta
implicit : boolean
If TRUE, specifies that the model
is implicit; i.e `fcn(beta, x)` ~= 0 and there is no y data to fit
against
meta : dict, optional
freeform dictionary of metadata for the model
Notes
-----
Note that the `fcn`, `fjacb`, and `fjacd` operate on NumPy arrays and
return a NumPy array. The `estimate` object takes an instance of the
Data class.
Here are the rules for the shapes of the argument and return
arrays of the callback functions:
`x`
if the input data is single-dimensional, then `x` is rank-1
array; i.e., ``x = array([1, 2, 3, ...]); x.shape = (n,)``
If the input data is multi-dimensional, then `x` is a rank-2 array;
i.e., ``x = array([[1, 2, ...], [2, 4, ...]]); x.shape = (m, n)``.
In all cases, it has the same shape as the input data array passed to
`~scipy.odr.odr`. `m` is the dimensionality of the input data,
`n` is the number of observations.
`y`
if the response variable is single-dimensional, then `y` is a
rank-1 array, i.e., ``y = array([2, 4, ...]); y.shape = (n,)``.
If the response variable is multi-dimensional, then `y` is a rank-2
array, i.e., ``y = array([[2, 4, ...], [3, 6, ...]]); y.shape =
(q, n)`` where `q` is the dimensionality of the response variable.
`beta`
rank-1 array of length `p` where `p` is the number of parameters;
i.e. ``beta = array([B_1, B_2, ..., B_p])``
`fjacb`
if the response variable is multi-dimensional, then the
return array's shape is `(q, p, n)` such that ``fjacb(x,beta)[l,k,i] =
d f_l(X,B)/d B_k`` evaluated at the ith data point. If `q == 1`, then
the return array is only rank-2 and with shape `(p, n)`.
`fjacd`
as with fjacb, only the return array's shape is `(q, m, n)`
such that ``fjacd(x,beta)[l,j,i] = d f_l(X,B)/d X_j`` at the ith data
point. If `q == 1`, then the return array's shape is `(m, n)`. If
`m == 1`, the shape is (q, n). If `m == q == 1`, the shape is `(n,)`.
Nr c � � || _ || _ || _ |�t |� � }|| _ || _ || _ |�|ni | _ d S �N)�fcn�fjacb�fjacd�tuple�
extra_args�estimate�implicitrD )rE ru rv rw ry rz r{ rD s r rF zModel.__init__� sU � � �����
���
� � !� �z�*�*�J�$��� ��
� ��
� � ,�D�D�"�� � � r c �: � | j � |� � dS )z� Update the metadata dictionary with the keywords and data provided
here.
Examples
--------
set_meta(name="Exponential", equation="y = a exp(b x) + c")
NrH rJ s r rL zModel.set_meta s � �
� ���� � � � � r c �R � || j v r
| j | S t d|z � � �)z4 Dispatch attribute access to the metadata.
rN rO rQ s r rS zModel.__getattr__ s1 � � �4�9� � ��9�T�?� "� �!7�$�!>�?�?� ?r )NNNNr NrU r r r r r � s` � � � � � �I� I�V /3�BF�
5�
5�
5�
5� � � �@� @� @� @� @r r c � � e Zd ZdZd� Zd� ZdS )r a�
The Output class stores the output of an ODR run.
Attributes
----------
beta : ndarray
Estimated parameter values, of shape (q,).
sd_beta : ndarray
Standard deviations of the estimated parameters, of shape (p,).
cov_beta : ndarray
Covariance matrix of the estimated parameters, of shape (p,p).
delta : ndarray, optional
Array of estimated errors in input variables, of same shape as `x`.
eps : ndarray, optional
Array of estimated errors in response variables, of same shape as `y`.
xplus : ndarray, optional
Array of ``x + delta``.
y : ndarray, optional
Array ``y = fcn(x + delta)``.
res_var : float, optional
Residual variance.
sum_square : float, optional
Sum of squares error.
sum_square_delta : float, optional
Sum of squares of delta error.
sum_square_eps : float, optional
Sum of squares of eps error.
inv_condnum : float, optional
Inverse condition number (cf. ODRPACK UG p. 77).
rel_error : float, optional
Relative error in function values computed within fcn.
work : ndarray, optional
Final work array.
work_ind : dict, optional
Indices into work for drawing out values (cf. ODRPACK UG p. 83).
info : int, optional
Reason for returning, as output by ODRPACK (cf. ODRPACK UG p. 38).
stopreason : list of str, optional
`info` interpreted into English.
Notes
-----
Takes one argument for initialization, the return value from the
function `~scipy.odr.odr`. The attributes listed as "optional" above are
only present if `~scipy.odr.odr` was run with ``full_output=1``.
c �� � |d | _ |d | _ |d | _ t |� � dk r;| j � |d � � t
| j � � | _ d S d S )Nr r+ r, r. r- ) �beta�sd_beta�cov_betare �__dict__rI r5 r1 r2 )rE �outputs r rF zOutput.__init__Q sk � ��1�I�� � �a�y�� � �q� ��
� �v�;�;�!� � � �M� � ���� +� +� +� +�D�I� 6� 6�D�O�O�O� � r c �R � t d| j � � t d| j � � t d| j � � t | d� � rUt d| j � � t d| j � � t d� � | j D ]}t d|z � � �d S d S )
z) Pretty-print important results.
zBeta:zBeta Std Error:zBeta Covariance:r1 zResidual Variance:zInverse Condition #:zReason(s) for Halting:z %sN)�printr� r� r� �hasattr�res_var� inv_condnumr2 )rE �rs r �pprintz
Output.pprint[ s� � � �g�t�y�!�!�!�
� �� �.�.�.�
� �$�-�0�0�0� �4�� � � "� �&�t�|� 4� 4� 4� �(�$�*:� ;� ;� ;� �*� +� +� +��_�
"�
"���f�q�j�!�!�!�!� "� "�
"�
"r N)r r r r rF r� r r r r r s= � � � � � �.� .�`7� 7� 7� "� "� "� "� "r r c �V � e Zd ZdZ d d�Zd� Zd� Z d d�Z d
d�Zd � Z dd
�Z
dS )r
al
The ODR class gathers all information and coordinates the running of the
main fitting routine.
Members of instances of the ODR class have the same names as the arguments
to the initialization routine.
Parameters
----------
data : Data class instance
instance of the Data class
model : Model class instance
instance of the Model class
Other Parameters
----------------
beta0 : array_like of rank-1
a rank-1 sequence of initial parameter values. Optional if
model provides an "estimate" function to estimate these values.
delta0 : array_like of floats of rank-1, optional
a (double-precision) float array to hold the initial values of
the errors in the input variables. Must be same shape as data.x
ifixb : array_like of ints of rank-1, optional
sequence of integers with the same length as beta0 that determines
which parameters are held fixed. A value of 0 fixes the parameter,
a value > 0 makes the parameter free.
ifixx : array_like of ints with same shape as data.x, optional
an array of integers with the same shape as data.x that determines
which input observations are treated as fixed. One can use a sequence
of length m (the dimensionality of the input observations) to fix some
dimensions for all observations. A value of 0 fixes the observation,
a value > 0 makes it free.
job : int, optional
an integer telling ODRPACK what tasks to perform. See p. 31 of the
ODRPACK User's Guide if you absolutely must set the value here. Use the
method set_job post-initialization for a more readable interface.
iprint : int, optional
an integer telling ODRPACK what to print. See pp. 33-34 of the
ODRPACK User's Guide if you absolutely must set the value here. Use the
method set_iprint post-initialization for a more readable interface.
errfile : str, optional
string with the filename to print ODRPACK errors to. If the file already
exists, an error will be thrown. The `overwrite` argument can be used to
prevent this. *Do Not Open This File Yourself!*
rptfile : str, optional
string with the filename to print ODRPACK summaries to. If the file
already exists, an error will be thrown. The `overwrite` argument can be
used to prevent this. *Do Not Open This File Yourself!*
ndigit : int, optional
integer specifying the number of reliable digits in the computation
of the function.
taufac : float, optional
float specifying the initial trust region. The default value is 1.
The initial trust region is equal to taufac times the length of the
first computed Gauss-Newton step. taufac must be less than 1.
sstol : float, optional
float specifying the tolerance for convergence based on the relative
change in the sum-of-squares. The default value is eps**(1/2) where eps
is the smallest value such that 1 + eps > 1 for double precision
computation on the machine. sstol must be less than 1.
partol : float, optional
float specifying the tolerance for convergence based on the relative
change in the estimated parameters. The default value is eps**(2/3) for
explicit models and ``eps**(1/3)`` for implicit models. partol must be less
than 1.
maxit : int, optional
integer specifying the maximum number of iterations to perform. For
first runs, maxit is the total number of iterations performed and
defaults to 50. For restarts, maxit is the number of additional
iterations to perform and defaults to 10.
stpb : array_like, optional
sequence (``len(stpb) == len(beta0)``) of relative step sizes to compute
finite difference derivatives wrt the parameters.
stpd : optional
array (``stpd.shape == data.x.shape`` or ``stpd.shape == (m,)``) of relative
step sizes to compute finite difference derivatives wrt the input
variable errors. If stpd is a rank-1 array with length m (the
dimensionality of the input variable), then the values are broadcast to
all observations.
sclb : array_like, optional
sequence (``len(stpb) == len(beta0)``) of scaling factors for the
parameters. The purpose of these scaling factors are to scale all of
the parameters to around unity. Normally appropriate scaling factors
are computed if this argument is not specified. Specify them yourself
if the automatic procedure goes awry.
scld : array_like, optional
array (scld.shape == data.x.shape or scld.shape == (m,)) of scaling
factors for the *errors* in the input variables. Again, these factors
are automatically computed if you do not provide them. If scld.shape ==
(m,), then the scaling factors are broadcast to all observations.
work : ndarray, optional
array to hold the double-valued working data for ODRPACK. When
restarting, takes the value of self.output.work.
iwork : ndarray, optional
array to hold the integer-valued working data for ODRPACK. When
restarting, takes the value of self.output.iwork.
overwrite : bool, optional
If it is True, output files defined by `errfile` and `rptfile` are
overwritten. The default is False.
Attributes
----------
data : Data
The data for this fit
model : Model
The model used in fit
output : Output
An instance if the Output class containing all of the returned
data from an invocation of ODR.run() or ODR.restart()
NFc �, � || _ || _ |�M| j j �2t | j � | j � � � � | _ n#t d� � �t |� � | _ |�|j �|j }|rj|
�3t j � |
� � rt j
|
� � | �3t j � | � � rt j
| � � t |� � | _ t |t j
�� � | _ t |t j
�� � | _ || _ || _ | | _ |
| _ | | _ | | _ |
| _ || _ || _ t |� � | _ t |� � | _ t |� � | _ t |� � | _ t |� � | _ t |� � | _ d | _ | � � � d S )Nz9must specify beta0 or provide an estimater with the model)r )!�data�modelrz r# �beta0r> rC �os�path�exists�remove�delta0r �int32�ifixx�ifixb�job�iprint�errfile�rptfile�ndigit�taufac�sstol�partol�maxit�stpb�stpd�sclb�scld�work�iworkr� �_check)rE r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� � overwrites r rF z ODR.__init__� s� � � �� ���
� �=��z�"�.� "�4�:�#6�#6�t�y�#A�#A� B� B��
�
� �M�� � � �u� � �D�J� �=�T�X� 1��H�E� � #��"�r�w�~�~�g�'>�'>�"�� �'�"�"�"��"�r�w�~�~�g�'>�'>�"�� �'�"�"�"��F�m�m�� � �5�� �4�4�4��
��5�� �4�4�4��
���� �� � �� � �� � �� � �� ���
� �� ���
��$�K�K�� ��$�K�K�� ��$�K�K�� ��$�K�K�� ��$�K�K�� ��5�\�\��
��� � � � �
�
�
�
�
r c �J � t | j j j � � }t | j j t j � � r:t | j j j � � }| j j rt d� � �nE| j j |d g}| j j st d� � �| � d�� � |d |d k rt d� � �|d }t |� � dk r |d }nd}t |� � dk r |d }nd}t | j
� � }||fg}|||fg}|||fg} |dk rD|� |f� � |� ||f� � | � ||f� � |dk r|� ||f� � |dk r| � ||f� � ||cxk rdk rn n|� |f� � ||cxk rdk rn n| � |f� � | j
| j j f}
| j j �|
| j j z }
| j j |
� } | j |vr5t# | j � � t# |� � t d
|z � � �| j j �: | j j |
� } | j |vr"t d t' |||f� � z � � �| j j �: | j j |
� } | j | vr"t d t' |||f� � z � � �| j �M| j j | j j j k r.t d
t' | j j j � � z � � �| j j j dk rt/ dt0 � � d S d S )z~ Check the inputs for consistency, but don't bother checking things
that the builtin function odr will check.
z*an implicit model cannot use response datarc z%an explicit model needs response datar+ )�fit_typez#number of observations do not matchr, r Nz#fcn does not output %s-shaped arrayz%fjacd does not output %s-shaped arrayz%fjacb does not output %s-shaped arrayz delta0 is not a %s-shaped arrayzHEmpty data detected for ODR instance. Do not expect any fitting to occur)�listr� r; r r< r@ r r= r� r{ r �set_jobre r� r0 ry ru r� rw �reprrv r� �sizer r ) rE �x_s�y_s�n�m�q�p� fcn_perms� fjacd_perms� fjacb_perms�arglist�ress r r� z
ODR._check s� � �
�4�9�;�$�%�%�� �d�i�k�5�=� 1� 1� %��t�y�{�(�)�)�C��z�"�
M� � K�L�L�L�
M� �9�;��B��(�C��:�&�
H� � F�G�G�G� �L�L�!�L� $� $� $� �r�7�c�"�g� � ��@�A�A� A� ��G�� �s�8�8�q�=�=��A��A�A��A� �s�8�8�q�=�=��A��A�A��A� ��
�O�O�� ��V�H� ��1�a�y�k� ��1�a�y�k� � ��6�6� � � �a�T� "� "� "� � � ��1�v� &� &� &� � � ��1�v� &� &� &� ��6�6� � � ��1�v� &� &� &� ��6�6� � � ��1�v� &� &� &� ��;�;�;�;�Q�;�;�;�;�;� � � ��t� $� $� $� ��;�;�;�;�Q�;�;�;�;�;� � � ��t� $� $� $�
�:�t�y�{�+�� �:� � ,� ��
� 5�5�G� �d�j�n�g�&�� �9�I� %� %� �#�)� � � � �)� � � ��@�3�F�G�G� G� �:� � '�"�$�*�"�G�,�C��y� �+�+� �;�d�A�q�!�9�o�o�M�O� O� O� �:� � '�"�$�*�"�G�,�C��y� �+�+� �;�d�A�q�!�9�o�o�M�O� O� O�
�;� "�t�{�'8�D�I�K�<M�'M�'M��1�D����9J�4K�4K�K�M� M�
M� �9�;� �q� � � � 7��
�
�
�
�
� !� r c � � | j j j d }| j j d }t | j j j � � dk r| j j j d }nd}| j j r
| j j }n<t | j j j � � dk r| j j j d }nd}| j j �dx}}nXt | j j j � � dk r | j j j dd� \ }}nd}| j j j d }| j dz dk r`dd |z z ||z z |z ||z z d
|z |z z d |z |z z d|z |z |z z d|z |z |z z ||z z d |z z |||z z z ||z |z z }nMdd |z z ||z z |z ||z z d
|z |z z d|z |z z d|z |z |z z d |z z |||z z z ||z |z z }t | j t j
� � r7| j j |fk r&| j j j � d
� � rdS t j |ft$ � � | _ dS )zG Generate a suitable work array if one does not already exist.
rc r r, r+ Nr- r( � � r. r/ r& �f8)r� r; r r� re r� r{ r@ rA r� r< r� r r= r �str�endswithrf rg )rE r� r� r� r� �ldwe�ld2we�lworks r � _gen_workz
ODR._gen_workj s� � �
�I�K� �b� !�� �J� �Q� �� �t�y�{� � !� !�Q� &� &�� � �!�!�$�A�A��A� �:� � �� � �A�A�
����"�
#�
#�q�
(�
(�� � �!�!�$�A�A��A� �9�<� � � �D�5�5�
��� �#�
$�
$��
)�
)� �)�,�,�Q�R�R�0�K�E�4�4� �D��I�L�&�q�)�E� �8�b�=�1� � ��"�Q�$�Y��1��_�q�(�1�Q�3�.��1��Q��6��1��Q��>��1��Q��q��H��q�S��U�1�W� � ��s�#�%&�q�S�)�+,�a��c�7�3�59�%�Z��\�B�E�E� �"�Q�$�Y��1��_�q�(�1�Q�3�.��1��Q��6��1��Q��>��1��Q��q��H��q�S�� �a��c�7�#�%)�%�Z��\�2�E� �d�i�� � /� /� 5�D�I�O��x�4O�4O��I�O�'�0�0��6�6� 5P�
�F� � �U�H�e�4�4�D�I�I�Ir c �h � | j �g d�}n;| j dz dz | j dz dz | j dz dz | j dz dz | j dz g}|dv r||d< |d v r||d
< |dv r||d < |d v r||d
< |d v r||d< |d dz |d
dz z |d dz z |d
dz z |d z | _ dS )a,
Sets the "job" parameter is a hopefully comprehensible way.
If an argument is not specified, then the value is left as is. The
default value from class initialization is for all of these options set
to 0.
Parameters
----------
fit_type : {0, 1, 2} int
0 -> explicit ODR
1 -> implicit ODR
2 -> ordinary least-squares
deriv : {0, 1, 2, 3} int
0 -> forward finite differences
1 -> central finite differences
2 -> user-supplied derivatives (Jacobians) with results
checked by ODRPACK
3 -> user-supplied derivatives, no checking
var_calc : {0, 1, 2} int
0 -> calculate asymptotic covariance matrix and fit
parameter uncertainties (V_B, s_B) using derivatives
recomputed at the final solution
1 -> calculate V_B and s_B using derivatives from last iteration
2 -> do not calculate V_B and s_B
del_init : {0, 1} int
0 -> initial input variable offsets set to 0
1 -> initial offsets provided by user in variable "work"
restart : {0, 1} int
0 -> fit is not a restart
1 -> fit is a restart
Notes
-----
The permissible values are different from those given on pg. 31 of the
ODRPACK User's Guide only in that one cannot specify numbers greater than
the last value for each variable.
If one does not supply functions to compute the Jacobians, the fitting
procedure will change deriv to 0, finite differences, as a default. To
initialize the input variable offsets by yourself, set del_init to 1 and
put the offsets into the "work" variable correctly.
N)r r r r r r' r( r) r* )r r+ r, r. )r r+ r, r- r- r, )r r+ r+ r )r� )rE r� �deriv�var_calc�del_init�restart�job_ls r r� z ODR.set_job� s � �p �8� �#�O�O�E�E��X��&��+��X��%��*��X��_�r�)��X��^�b�(��X��]� $�E� �y� � � �E�!�H� �L� � � �E�!�H� �y� � � �E�!�H� �v� � � �E�!�H� �f� � � �E�!�H��!�H�U�N�U�1�X�d�]�2��!�H�S�L�!�#(��8�B�;�/�16�q��:����r c �� � | j �d| _ | j dz dz | j dz dz | j dz dz | j dz g}ddgddgddgddgddgddgddgg} | j �|�|�|�t d� � �| |d | |d z | |d z }
|�||
d< |�||
d< |�||
d< |�||
d < |�||
d
< |�||
d < |t d� � v r||d< | � |
dd� � � |d< | � |
dd
� � � |d< | � |
d
d � � � |d < |d dz |d dz z |d dz z |d z | _ dS )
a5 Set the iprint parameter for the printing of computation reports.
If any of the arguments are specified here, then they are set in the
iprint member. If iprint is not set manually or with this method, then
ODRPACK defaults to no printing. If no filename is specified with the
member rptfile, then ODRPACK prints to stdout. One can tell ODRPACK to
print to stdout in addition to the specified filename by setting the
so_* arguments to this function, but one cannot specify to print to
stdout but not a file since one can do that by not specifying a rptfile
filename.
There are three reports: initialization, iteration, and final reports.
They are represented by the arguments init, iter, and final
respectively. The permissible values are 0, 1, and 2 representing "no
report", "short report", and "long report" respectively.
The argument iter_step (0 <= iter_step <= 9) specifies how often to make
the iteration report; the report will be made for every iter_step'th
iteration starting with iteration one. If iter_step == 0, then no
iteration report is made, regardless of the other arguments.
If the rptfile is None, then any so_* arguments supplied will raise an
exception.
Nr r) r( r* r+ r, z3no rptfile specified, cannot output to stdout twicer- r. r& r/ )r� r� r rh �index) rE �init�so_init�iter�so_iter� iter_step�final�so_final�ip�ip2arg�iprint_ls r �
set_iprintzODR.set_iprint� s� � �4 �;� ��D�K��k�T�!�B�&��k�S� �2�%��k�R� �"�$��k�B� � �� �a�&��a�&��a�&��a�&��a�&��a�&��a�&�
��
�L� �
�
�
�
�
�
!��E�G� G�
G� �"�Q�%�=�6�"�Q�%�=�0�6�"�Q�%�=�@�� � � �H�Q�K� � �!�H�Q�K� � � �H�Q�K� � �!�H�Q�K� � � �H�Q�K� � �"�H�Q�K� ��b� � � !� !� �B�q�E�� � �X�a��c�]�+�+��1��� � �X�a��c�]�+�+��1��� � �X�a��c�]�+�+��1����e�D�j�2�a�5��9�,�r�!�u�R�x�7�"�Q�%�?�� � � r c � � | j j | j | j j | j j f}ddi}g d�}| j �W| j dz dz dk rF| � � � t j
| j � � }|| j dt |� � �< | j j
�| j j
|d< | j j �| j j |d < | j j �| j j |d
< | j j �| j j |d < | j j �| j j |d < |D ]}t% | |� � }|�|||< �t' t) |i |��� � | _ | j S )
z� Run the fitting routine with all of the information given and with ``full_output=1``.
Returns
-------
output : Output instance
This object is also assigned to the attribute .output .
� full_outputr+ )r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� Nr' r( r rv rw rA rB ry )r� ru r� r� r@ r; r� r� r� r �ravelr� re rv rw rA rB ry �getattrr r r� )rE �argsrK �kwd_l�d0rR r" s r �runzODR.run2 sa � � �
���
�D�I�K����E�� �q�!��:� :� :�� �;� "���E�(9�R�'?�1�'D�'D� �N�N� � � ���T�[�)�)�B�"$�D�I�h�s�2�w�w�h� � �:� � '� �J� ,�D��M� �:� � '� �J� ,�D��M� �9�<� #� �� �D��J� �9�<� #� �� �D��J� �:� � ,�!%��!6�D� � � � !� !�D��$��%�%�C��� ��T�
�� �S�$� /�$� /� /�0�0�� ��{�r c �� � | j �t d� � �| � d�� � | j j | _ | j j | _ || _ | � � � S )aE Restarts the run with iter more iterations.
Parameters
----------
iter : int, optional
ODRPACK's default for the number of new iterations is 10.
Returns
-------
output : Output instance
This object is also assigned to the attribute .output .
Nz0cannot restart: run() has not been called beforer+ )r� )r� r r� r� r� r� r� )rE r� s r r� z ODR.restart_ s\ � � �;� ��M�N�N� N� � � �Q� � � � ��K�$�� ��[�&��
���
��x�x�z�z�r )NNNNNNNNNNNNNNNNNNNFrT rq rt ) r r r r rF r� r� r� r� r� r� r r r r
r
j s� � � � � � �n� n�` DH�AE�AE�EI�� 5� 5� 5� 5�nV � V � V �p+5� +5� +5�Z ;?� #�M;� M;� M;� M;�^ -1�FJ�J@� J@� J@� J@�X+� +� +�Z� � � � � r r
rt )r r� r �warningsr � scipy.odrr �__all__r � UserWarningr � Exceptionr r r r �_set_exceptionsr# r5 r r
r r r
r r r �<module>r� s: ��$� $�J
� � � � � � � � � � � � � � � � � � � � $� $� $�� �m�� � � � � �� � � � � � � � �y� � � � � � � � �i� � � �
� � �� � � �(�G� ,� ,� ,�� � � �$K � K � K �\o@� o@� o@� o@� o@� o@� o@� o@�dE � E � E � E � E �t� E � E � E �Pm@� m@� m@� m@� m@� m@� m@� m@�`G"� G"� G"� G"� G"� G"� G"� G"�TL� L� L� L� L� L� L� L� L� Lr