(phPSrSSKrSSKJr SSKrSSKJr SSKJ r /SQr \ Rr \"5r "SS\ 5r"S S \5r"S S \5r\r\r\ R("\\5 SS jrSr"SS5r"SS\5r"SS5r"SS5r"SS5rg)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)Lock)warn) __odrpack) odr OdrWarningOdrErrorOdrStopDataRealDataModelOutputODR odr_errorodr_stopc\rSrSrSrSrg)r5z 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____firstlineno____doc____static_attributes__rE/var/www/html/venv/lib/python3.13/site-packages/scipy/odr/_odrpack.pyrr5   rrc\rSrSrSrSrg)r>zr Exception indicating an error in fitting. This is raised by `~scipy.odr.odr` if an error occurs during fitting. rNrrrrrr>rrrc\rSrSrSrSrg)r Gz Exception stopping fitting. You can raise this exception in your objective function to tell `~scipy.odr.odr` to stop fitting. rNrrrrr r Gs   rr cUcU$Uc[R"U5nO[R"X5nURS:XaURR U5$U$)zJConvert an object to the preferred form for input to the odr routine. r)npasarrayshapedtypetype)objr&s r_convr)XsQ { =**S/C**S(C 99?99>>#& &JrcSUS-nUS:Ga;US-S-US-S-US-S-US-S-US-4n/nUSS:XaaUSS:waURS 5 US S:waURS 5 US S:waURS 5 URU5 U$USS:XajUSS:waURS5 US S:waURS5 US S:waURS5 USS:waURS5 U$USS :XajUSS:waURS5 US S:waURS5 US S:waURS5 USS:waURS5 U$USS :XajUSS:waURS5 US S:waURS5 US S:waURS5 USS:waURS5 U$USS:XaURS5 U$USS:XaURS 5 U$USS:XaURS5 U$U/$)zInterprets 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' drz Derivatives possibly not correctzError occurred in callbackz$Problem is not full rank at solutionzN < 1zM < 1zNP < 1 or NP > NzNQ < 1zLDY and/or LDX incorrectz)LDWE, LD2WE, LDWD, and/or LD2WD incorrectz&LDIFX, LDSTPD, and/or LDSCLD incorrectzLWORK and/or LIWORK too smallzSTPB and/or STPD incorrectzSCLB and/or SCLD incorrectz WE incorrectz WD incorrectzError in derivativeszNumerical error detected)append)info stopreasonIproblemss r _report_errorr;js-.2AX 7J  qy5[2  4Z"_ 3Y^ 2X] BY    Q419tqy BCtqy <=tqy FG OOJ 'FEqTQYtqy(tqy(tqy 23tqy)43qTQYtqy :;tqy KLtqy HItqy ?@"!qTQYtqy <=tqy <=tqy/tqy/qTQY OO2 3  qTQY OO8 9qTQY OO6 7|rc.\rSrSrSrSSjrSrSrSrg) 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. Ncr[U5Ul[UR[R5(d,[ S[ UR5RS35e[U5Ul[U5Ul [U5Ul [U5Ul Uc0Ul gUUl g)NEExpected an 'ndarray' of data for 'x', but instead got data of type '') r)x isinstancer#ndarray ValueErrorr'rywewdfixmeta)selfrArErFrGrHrIs r__init__ Data.__init__sq$&&"**-->>B466l>S>S=TTUWX Xq)):,B D rc :URRU5 g)zUpdate the metadata dictionary with the keywords and data provided by keywords. Examples -------- :: data.set_meta(lab="Ph 7; Lab 26", title="Ag110 + Ag108 Decay") NrIupdaterJkwdss rset_meta Data.set_metas rchUS:waXR;aURU$[SUS35e)z>Dispatch attribute access to the metadata dictionary. rIr@' not in metadatarIAttributeErrorrJattrs r __getattr__Data.__getattr__ s7 6>dii/99T? " 1TF*;!<= =r)rHrIrGrFrArENNNNN rrrrrrKrRrZrrrrr r sKZ 1 >rr c8\rSrSrSrS SjrSrSrSrSr g) r i)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./np.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] = np.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 UbUb [S5eUbUb [S5e0UlUbSURS'OSURS'UbSURS'OSURS'[U5Ul[ UR[ R 5(d,[S [UR5RS 35e[U5Ul [U5Ul [U5Ul [U5Ul [U5Ul [U5UlUc0UlgUUlg) Nzcannot set both sx and covxzcannot set both sy and covysxrGcovxsyrFcovyr?r@)rD _ga_flagsr)rArBr#rCr'rrEr`rbrarcrHrI) rJrArEr`rbrarcrHrIs rrKRealData.__init__fs N!1:; ; N!1:; ; >#'DNN4 #)DNN4 >#'DNN4 #)DNN4 q$&&"**--??CDFF|?T?T>UUVXY Yq))$K $K :,B D rc6S[R"US5- $)z/Convert standard deviation to weights. g?r2)r#power)rJsds r_sd2wtRealData._sd2wts"((2q/!!rcSSKJn [UR5S:XaU"U5$[R "UR[ 5n[URS5HnU"USS2SS2U45USS2SS2U4'M! U$)z5Convert covariance matrix(-ices) to weights. r)invr2N) scipy.linalgrllenr%r#zerosfloatrange)rJcovrlweightsis r_cov2wtRealData._cov2wtso % syy>Q s8Ohhsyy%0G399R=)!$S1QZ!A*NrcpUS;a3US:waXR;aURU$[SUS35eURUR4URUR 4URUR 4URUR4S.nX!URU4up4UbU"U46$g)N)rGrFrIr@rU))rGr`)rGra)rFrb)rFrc) rIrWrir`rvrarbrcrd)rJrY lookup_tblfuncargs rrZRealData.__getattr__s | #v~$))"3yy&$q.?%@AA)-dgg(>'+||TYY&?%)[[$''$:'+||TYY&?AJ #$..*>#?@IDcV}$r) rdrarcrHrIr`rbrArENNNNNNN) rrrrrrKrirvrZrrrrr r )s':xEI $1@"  rr c2\rSrSrSrSSjrSrSrSrg) r ia 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,)``. NcXlX lX0lUb [U5nX@lXPlX`lUbXplg0UlgN)fcnfjacbfjacdtuple extra_argsestimateimplicitrI)rJrrrrrrrIs rrKModel.__init__sB   !z*J$   ,D " rc :URRU5 g)zUpdate the metadata dictionary with the keywords and data provided here. Examples -------- set_meta(name="Exponential", equation="y = a exp(b x) + c") NrNrPs rrRModel.set_meta s rchUS:waXR;aURU$[SUS35e)z3Dispatch attribute access to the metadata. rIr@rUrVrXs rrZModel.__getattr__s7 6>dii/99T? " 1TF*;!<= =r)rrrrrrrI)NNNNrNr]rrrr r s IV/3BF 5 >rr c$\rSrSrSrSrSrSrg)r i!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). Note that this `cov_beta` is not scaled by the residual variance `res_var`, whereas `sd_beta` is. This means ``np.sqrt(np.diag(output.cov_beta * output.res_var))`` is the same result as `output.sd_beta`. 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``. cUSUlUSUlUSUl[U5S:Xa9URR US5 [ UR5Ulgg)Nrr1r2r4r3) betasd_betacov_betaro__dict__rOr;r7r8)rJoutputs rrKOutput.__init__VsZ1I ay q  v;!  MM  ++DII6DO rc\[SUR5 [SUR5 [SUR5 [ US5(aY[SUR 5 [SUR 5 [S5 URHn[SU35 M g g ) z(Pretty-print important results. zBeta:zBeta Std Error:zBeta Covariance:r7zResidual Variance:zInverse Condition #:zReason(s) for Halting:z N)printrrrhasattrres_var inv_condnumr8)rJrs rpprint Output.pprint`s gtyy! .  $--0 4 &t|| 4 ($*:*: ; * +__1#h% !r)rrrr8N)rrrrrrKrrrrrr r !s2h7  rr cd\rSrSrSrS SjrSrSrS SjrSSjr S r SS jr S r g)rioa 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() NcXlX lUcVURRb4[URRUR55UlO[ S5e[U5UlUcUR b UR nU(azU b:[RRU 5(a[R"U 5 U b:[RRU 5(a[R"U 5 [U5Ul [U[RS9Ul[U[RS9UlXplXlXlXlXlXlXlXlXl[U5Ul[U5Ul[U5Ul[U5Ul[U5Ul[U5UlSUlURA5 g)Nz9must specify beta0 or provide an estimator with the model)r&)!datamodelrr)beta0rDrHospathexistsremovedelta0r#int32ifixxifixbjobiprinterrfilerptfilendigittaufacsstolpartolmaxitstpbstpdsclbscldworkiworkr_check)rJrrrrrrrrrrrrrrrrrrrrr overwrites rrK ODR.__init__sq   =zz""."4::#6#6tyy#AB  MuDJ =TXX1HHE "rww~~g'>'> '""rww~~g'>'> '"Fm 51 51         $K $K $K $K $K 5\   rcJ[URRR5n[ URR [ R5(aP[URR R5nURR(a [S5eOPURR US/nURR(d [S5eURSS9 USUS:wa [S5eUSn[U5S:XaUSnOSn[U5S:XaUSnOSn[UR5nXS4/nXTU4/nXVU4/n US:Xa6URU45 URXC45 U RXc45 US:XaURXS45 US:XaU RXS45 XEs=:XaS:XaO OURU45 Xes=:XaS:XaO OU RU45 URURR4n URRbXRR-n URR "U 6n U RU;a/[#U R5 [#U5 [S US 35eURR$bCURR$"U 6n U RU;a[S ['XTU45S 35eURR(bCURR("U 6n U RU ;a[S ['XVU45S 35eUR*bnUR*RURRR:wa6[S['URRR5S 35eURRR,S:Xa[/S[0SS9 g g )zmCheck the inputs for consistency, but don't bother checking things that the builtin function odr will check. z*an implicit model cannot use response datarmz%an explicit model needs response datar1)fit_typez#number of observations do not matchr2rNzfcn does not output z -shaped arrayzfjacd does not output zfjacb does not output zdelta0 is not a zHEmpty data detected for ODR instance. Do not expect any fitting to occurr3) stacklevel)listrrAr%rBrEr#rCrrrset_jobrorr6rrrrreprrrsizerr) rJx_sy_snmqp fcn_perms fjacd_perms fjacb_permsarglistress rr ODR._checksx 499;;$$% diikk2:: . .tyy{{(()Czz""KLL#99;;B(C::&&FGG LL!L $ r7c"g @A A G s8q=AAA s8q=AAA  OVH ayk ayk 6   aT "   v &   v & 6   v & 6   v & ;Q;   t $ ;Q;   t $ ::tyy{{+ :: , 5 55Gjjnng& 99I % #))  ) 1#mDE E ::   '**""G,Cyy +,T1)_,=]KMM ::   '**""G,Cyy +,T1)_,=]KMM ;; "t{{'8'8DIIKK1QqHqSU1W s#%&qS)+,c7359Z\BE"Q$Y_q(13.1Q61Q>1QqHqSc7#%)Z\2E dii , ,UH1LIIOO''0066 %51DIrcURc/SQnOTURS-S-URS-S-URS-S-URS-S-URS-/nUS;aXS'US ;aX&S 'US;aX6S 'US ;aXFS 'US ;aXVS'USS-US S--US S--US S--US-Ulg)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)rrrrrr-r.r/r0)rr1r2r4)rr1r2r3r3r2)rr1r1r)r)rJrderivvar_calcdel_initrestartjob_ls rr ODR.set_jobsp 88 #EXX&+XX%*XX_r)XX^b(XX] $E y !H L !H y !H v !H f !H!HUNU1Xd]2!HSL!#(8B;/16q:rcURcSUlURS-S-URS-S-URS-S-URS-/nSS/SS/SS/SS/SS/SS/SS//n URcUcUcUb [S5eXSXS-XS -n UbXS'UbX*S'UbX:S'UbXJS 'UbXjS 'UbXzS 'U[S5;aXXS'U R U SS5US'U R U SS 5US'U R U S S 5US 'USS-USS--USS--US -Ulg) aSet 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. Nrr/r.r0r1r2z3no rptfile specified, cannot output to stdout twicer3r4r,r5)rrrrrindex) rJinitso_inititerso_iter iter_stepfinalso_finalipip2argiprint_ls r set_iprintODR.set_iprints4 ;; DKkkT!B&kkS 2%kkR"$kkB a&a&a&a&a&a&a&  LL    !EG GQ%=6Q%=06Q%=@  QK  !QK  QK  !QK  QK  "QK b !qE Xa]+1 Xa]+1 Xa]+1eDj2a59,r!uRx7"Q%? rc8URRURURRURR 4nSS0n/SQnUR b]URS-S-S:XaGUR5 [R"UR 5nX@RS[U5&URRbURRUS'URRbURRUS 'URRbURRUS 'URR bURR US 'URR"bURR"US 'UHn[%X5nUcMXbU'M [& [)[+U0UD65UlSSS5 UR,$!,(df  UR,$=f) zRun 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_outputr1)rrrrrrrrrrrrrrrrrNr-r.rrrrFrGr)rrrrrErArrrr#ravelrrorrrFrGrgetattrODR_LOCKr rr)rJargsrQkwd_ld0rYr(s rrunODR.run=s  DIIKKEq!: ;; "E(9R'?1'D NN $++&B"$IIhs2w  ::   ' JJ,,DM ::   ' JJ,,DM 99<< #DJ 99<< #DJ :: ,!%!6!6D D$%C T   d!3d!34DK{{X{{s H HcURc [S5eURSS9 URRUlURRUlXlUR 5$)zRestarts 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 . z0cannot restart: run() has not been called beforer1)r)rrrrrrr)rJrs rr ODR.restartks[ ;; MN N Q KK$$ [[&&  xxzr)rrrrrrrrrrrrrrrrrrrrrr)NNNNNNNNNNNNNNNNNNNFr\r}r) rrrrrrKrrrrrrrrrrrrosYn`DHAEAEEI 5nV+p12f;?#M;^-1FJJ@X,\rrr)rr threadingrnumpyr#warningsr scipy.odrr__all__rr UserWarningr Exceptionrr rr_set_exceptionsr)r;r r r r rrrrrs$J  $mm 6   y  i    (G,$K\n>n>bEtEPm>m>`K K \SSr