ErrorsInXandYProblem

 
ErrorsInXandYProblem = class ErrorsInXandYProblem(Problem)
    ErrorsInXandYProblem(model=None, xdata=None, ydata=None, weights=None, prior=None, copy=None)
 
A ErrorsInXandYProblem is an optimization of parameters which involves
the fitting of data to a Model, where both the ydata and the xdata
contain errors.
 
It entails that the xdata are not at the exact locations. They need to
be optimized too. Consequently the parameters of the model are appended
with a set of parameters, the length of xdata. These extra parameters
will contain the target locations of the xdata. The 2-dimensional distance
between data (xdata,ydata) and (target, model(target)) is minimised.
The target are nuisance parameters which are not part of the modeling
solution.
 
As the targets need to be optimised they need a Prior. In the present
implementation there is the same Prior for all targets, which the centered on
each of the xdata values.
S.Gull (1989) argues to use a GaussPrior with a scale similar to the errors
in both X and Y.
 
Attributes
----------
prior : Prior
    Priors for the x-axis nuisance parameters.
 
 
Attributes from Problem
-----------------------
model, xdata, ydata, weights, partype
 
 
Author :         Do Kester
 
 
Method resolution order:
ErrorsInXandYProblem
Problem
builtins.object

Constructor:
ErrorsInXandYProblem( model=None, xdata=None, ydata=None, weights=None, prior=None, copy=None )
Problem Constructor.
 
Parameters
----------
model : Model
    the model to be solved
xdata : array_like or None
    independent variable
ydata : array_like or None
    dependent variable
weights : array_like or None
    weights associated with ydata
prior : Prior
    prior for the x-axis nuisance parameters. All centered on each of the xdata
copy : Problem
    to be copied
Methods defined here:
copy()
Copy.
derivative( param )
Return the derivative to the Model.
 
Parameters
----------
params : array_like
    list of problem parameters
domain2Unit( dval, kpar )
Return value in [0,1] for the selected parameter.
 
Parameters
----------
dval : float
    domain value for the selected parameter
kpar : int
    selected parameter index, where kp is index in [parameters, hyperparams]
myDistribution()
Return a default preferred ErrorDistribution: "gauss"
myEngines()
Return a default list of preferred engines
myStartEngine()
Return a default preferred start engines: "start"
partial( param )
Return the partials as a matrix [2*nx,np+nx], where nx is the number of
datapoints and np the number of parameters in the model.
The upper left submatrix [nx,np] contains dM/dp
the upper right submatrix [nx,nx] contains dM/dx on the diagonal
the lower left submatrix [nx,np] contains zeros
the lower right submatrix [nx,nx] contains the identity matrix
residuals( param, mockdata=None )
Return the (weighted) true distance between (xdata,ydata) and (xtry,ytry) where xtry are
the trial values for xdata and ytry = model.result( xtry, param )
 
res = hypothenusa( xdata - xtry, ydata - ytry ) * weights
 
Parameters
----------
param : array_like
    model parameters and xdata parameters
mockdata : array_like
    model fit data model.result( xtry, param )
result( param )
Returns the result calculated at the xdatas.
 
Parameters
----------
param : array_like
    values for the parameters + nuisance params.
splitParam( param )
Split the parameters into Model parameters and targets.
unit2Domain( uval, kpar )
Return domain value for the selected parameter.
 
Parameters
----------
uval : array_like
    unit value for the selected parameter
kpar : int
    selected parameter indices, where kp is index in [parameters, hyperparams]
weightedResSq( param, mockdata=None, extra=False )
Return the (weighted) squared distance between (xdata,ydata) and (xtry,ytry) where xtry are
the trial values for xdata and ytry = model.result( xtry, param )
 
Parameters
----------
param : array_like
    model parameters and xdata parameters
mockdata : array_like
    model fit data model.result( xtry, param )
extra : bool (False)
    true  : return ( wgt * res^2, wgt * [yres,xres] )
    false : return wgt * res^2
weightedResiduals( param, mockdata=None, extra=False )
Returns the (weighted) residuals, calculated at the xdata.
 
Parameters
----------
param : array_like
    values for the parameters.
mockdata : array_like
    model fit at xdata
extra : bool (False)
    true  : return ( wgt * dist, wgt * [yres,xres] / dist )
    false : return wgt * dist

Methods inherited from Problem: