Model

 
Model = class Model(FixedModel)
    Model(nparams=0, ndim=1, copy=None, params=None, **kwargs)
 
Model implements the common parts of (compound) models.
It is the last common anchestor of all Models.
 
Models can be handled by the Fitter classes.
 
A model consists of one or more instantiations of (base) models which
are concatenated in a chain of models using various operations
(+-*/). A special operation is the pipe (|). It works like a unix pipe,
i.e. the output of the left-hand process in used as input of the
right-hand process.
 
Methods defined in BaseModel as eg. baseResult() are recursively called
here as result(). They are the ones used in the fitters.
 
The Model is the place where model-related items are kept, like parameters,
stdevs.
 
Model also implements a numerical derivation of partial to be
used when partial is not given in the model definition itself. This same
numerical derivation of partial is used in testPartial to indeed test
whether the partial has been implemented properly.
 
Example:
--------
>>> x = numpy.arange( 10 )
>>> poly = PolynomialModel( 2 )             # quadratic model
>>> poly.parameters = [3,2,1]               # set the parameters for the model
>>> y = poly( x )                           # evaluate the model at x
>>> p0 = poly[0]                            # 3: the first parameter
>>>
>>> # To make a compound model consisting of a gaussian and a constant background
>>>
>>> gauss = GaussModel( )                   # gaussian model
>>> gauss += PolynomialModel( 0 )           # gaussian on a constant background
>>> print( gauss.getNumberOfParameters( ) )
>>> 4
>>>
>>> # Set limits to this model
>>>
>>> lolim = [0,-10,0,-5]                    # lower limits for the parameters
>>> hilim = [10,10,2, 5]                    # high limits for parameters
>>> gauss.setLimits( lolim, hilim )         # set limits. Does not work with all Fitters
>>>
>>> # Pipe a model; The order of operation matters.
>>> # m5 = ( m1 | m2 ) + m3
>>>
>>> m1 = PolynomialModel( 1 )               # m1( x, p )
>>> m2 = SineModel()                        # m2( x, q )
>>> m3 = PolynomialModel( 0 )               # m3( x, r )
>>> m4 = m1 | m2                            # m2( m1( x, p ), q )
>>> m5 = m4 + m3                            # m2( m1( x, p ), q ) + m3( x, r )
>>> print( m5.parameters )                  # [p, q, r]
>>>
>>> # Implicit brackets
>>> # m5 = m1 | ( m2 + m3 )
>>>
>>> m1 = PolynomialModel( 1 )               # m1( x, p )
>>> m2 = SineModel()                        # m2( x, q )
>>> m3 = PolynomialModel( 0 )               # m3( x, r )
>>> m4 = m2 + m3                            # m2( x, q ) + m3( x, r )
>>> m5 = m1 | m4                            # m2( m1( x, p ), q ) + m3( m1( x, p ), r )
>>> print( m5.parameters )                  # [p, q, r]
 
Attributes
----------
parameters : array_like
    parameters of the model
stdevs : None or array_like
    standard deviations after a fit to the data
xUnit : astropy.units or list of
    unit of the x-values (list of in case of more dimensions)
yUnit : astropy.units
    unit of the y-values
npars : int (read only)
    number of parameters in this model
npchain : int (read only)
    identical to npars
 
Attributes from FixedModel
--------------------------
    npmax, fixed, parlist, mlist
 
Attributes from BaseModel
--------------------------
    npbase, ndim, priors, posIndex, nonZero,
         tiny, deltaP, parNames

 
Author       Do Kester
 
 
Method resolution order:
Model
FixedModel
BaseModel
builtins.object

Constructor:
Model( nparams=0, ndim=1, copy=None, params=None, **kwargs )
Initializes the Model with all attributes set to None, except for
the parammeters which are all initialized to 0.
 
Parameters
----------
nparams : int
    the number of parameters in this model
ndim : int
    the dimensionality of the xdatas (default: 1)
copy : Model
    model to be copied (default: None)
params : array_like
    initial parameters of the model
fixed : None or dictionary of {int:float|Model}
    int         index of parameter to fix permanently.
    float|Model values for the fixed parameters.
    Attribute fixed can only be set in the constructor.
    See: FixedModel
Methods defined here:
addModel( model )
Make a compound model by concatinating/adding model to this.
 
The final result is the sum of the individual results.
 
The compound model is implemented as a chain of Models.
Each of these base models contain the attributes ( parameters, limits etc. )
and when needed these attributes are taken from there, or stored there.
 
The operation (addition in this case) is always with the total result of the
existing chain. For the use of "brackets" in a chain use BracketModel.
 
Parameters
----------
model : Model
    model to be added to
appendModel( model, operation )
Append a model to the present chain using a operation.
 
Parameters
----------
model : Model
    the model to be appended
operation : int
    operation index
 
Raises
------
ValueError when a model of a different dimensionality is offered.
assignDF1( partial, i, dpi )
assignDF2( partial, i, dpi )
chainLength()
Return length of the chain.
checkLimits( param, parlist )
Checks whether the parameters are within limits.
 
It only works in *Fitter classes which can support it. Eg. Fitter
itself cannot handle limits as it would turn the problem into
a *non*-linear one.
 
Parameters
----------
param : list of float
    parameters to be checked
parlist : list of int
    indices of the fitable parameters
 
Raises
------
ValueError when out of limits.
copy()
Return a copy.
correctParameters( params )
Check parameters for non-zero and positivity
 
Parameters
----------
params : array_like
    parameters for the model.
derivative( xdata, param, useNum=False )
Return the derivatives (df/dx) of the model at the inputs
 
Parameters
----------
xdata : array_like
    an input vector or array
param : array_like
    parameters for the model
useNum : bool
    if true, numeric derivatives are used.
divideModel( model )
Make a compound model by concatinating/dividing by a model.
 
The final result is the division of the models.
 
Parameters
----------
model : Model
    model to be divided by
domain2Unit( dvalue, kpar=None )
Convert a value within the domain of the parameter to one in [0,1].
 
Parameters
----------
dvalue : (list of) float
    value of parameter
kpar : int
    index of the parameter
getIntegralUnit()
Return the unit of the integral of the model over x.
getLimits()
Return the limits stored in the priors
 
Returns
-------
limits : tuple of 2 array-like or of 2 None (if `self.priors` is None)
    (lowlimits, highlimits)
getLinearIndex()
Return null.
getNumberOfParameters()
Returns the number of parameters of the ( compound ) model.
getParameterName( k )
Return the name of the indicated parameter.
 
Parameters
----------
k : int
    parameter number.
 
Raises
------
IndexError when k is larger than the number of parameters.
getParameterUnit( k )
Return the unit of the indicated parameter.
 
Parameters
----------
k : int
    parameter number.
 
Raise
-----
IndexError when k is > number of parameters
getPrior( k )
Return the prior of the indicated parameter.
 
Parameters
----------
k : int
    parameter number.
 
Raises
------
IndexError when k is larger than the number of parameters.
hasLimits( fitindex=None )
Return true if limits has been set for this model.
 
Parameters
----------
fitindex    list of indices to be fitted.
hasPriors( isBound=True )
Return True when the model has priors for all its parameters.
 
Parameters
----------
isBound : bool
    Also check if the prior is bound.
isDynamic()
Return whether the model can change the number of parameters dynamically.
isMixed()
Return false.
isNullModel()
Return True if the model has no parameters (a NullModel).
isolateModel( k )
Return a ( isolated ) copy of the k-th model in the chain.
Fixed parameters and priors which might be present in the compound model
will be lost in the isolated model.
 
Parameters
----------
k : int
    the model number ( head = 0 )
 
Raises
------
IndexError when the chain is shorter than k.
multiplyModel( model )
Make a compound model by concatinating/multiplying a model with this.
 
The final result is the product of the models.
 
Parameters
----------
model : Model
    model to be multiplied by
nextPrior()
numDerivative( xdata, param )
Returns numerical derivatives (df/dx) of the model function.
 
Parameters
----------
xdata : array_like
    input data
param : array_like
    a parameters vector
numPartial( xdata, param )
Returns numerical partial derivatives of the model function.
 
Parameters
----------
xdata : array_like
    input data
param : array_like
    a parameters vector
operate( res, pars, next )
partial( xdata, param, useNum=False )
Return the partial derivatives of the model at the inputs
 
Parameters
----------
xdata : array_like
    an input vector or array
param : array_like
    parameters for the model
useNum : bool
    if true, numeric partials are used.
partialDomain2Unit( dvalue )
Return a the derivate of the domain2Unit function to dval.
 
Parameters
----------
dvalue : (list of) float
   parameter array
pipeModel( model )
Make a compound model by piping the result into the next.
 
Parameters
----------
model : Model
    model to pipe into
result( xdata, param=None )
Return the result of the model as applied to an array of input data.
 
Parameters
----------
xdata : array_like
    input data
param : array_like
    parameters for the model. Default parameters from the Model
setLimits( lowLimits=None, highLimits=None )
Sets the limits for the parameters of the compound model.
 
1. It is valid to insert for either parameter a None value
indicating no lower/upper limits.
2. When a lowerlimit >= upperlimit no limits are enforced.
It only works in *Fitter classes which support it.
 
Parameters
----------
lowLimits : array_like
    lower limits on the parameters
highLimits : array_like
    upper limits on the parameters
setPrior( k, prior=None, **kwargs )
Set the prior for the indicated parameter.
 
Parameters
----------
k : int
    parameter number.
prior : Prior
    prior for parameter k
kwargs : keyword arguments
    attributes to be passed to the prior
 
Raises
------
IndexError when k is larger than the number of parameters.
shortName()
Return a short version the string representation: upto first non-letter.
stayInLimits( oldpar, trypar, parlist )
Return parameters guaranteed to be within limits.
 
If out-of-limits the parameter is replaced by the midpoint between the
old parameter and the limit.
 
Parameters
----------
oldpar : array_like
    old parameters ( must be inside limits )
trypar : array_like
    parameters to be checked
fitindex : array_like
    indices of the fitable parameters
strictNumericDerivative( xdata, param )
Strictly numeric calculation of derivative.
 
For compound models it is different from numPartial and numDerivative.
 
    ## More dimensions in x
 
Parameters
----------
xdata : float
    single xdata point (possibly multidimensional)
param : array-like
    parameters
strictNumericPartial( xdata, params, parlist=None )
Strictly numeric calculation of partials to params.
 
For compound models it is different from numPartial and numDerivative.
 
Parameters
----------
xdata : float
    single xdata point (possibly multidimensional)
params : array-like
    parameters
kpar : None or int or list of int
    int  : return derivative to parameter kpar.
subtractModel( model )
Make a compound model by concatinating/subtracting a model from this.
 
The final result is the difference of the models.
 
Parameters
----------
model : Model
    model to be subtracted from
testPartial( xdata, params )
A test routine to check the calculation of the partial derivatives.
 
It is compared to a numerical calculation.
 
Parameters
----------
xdata : (list of) float
    values of the independent variable
params : list of floats
    parameters for the model
 
Return
------
The number of large deviations.
unit2Domain( uvalue, kpar=None )
Convert a value in [0,1] to one inside the limits of the parameter.
 
Parameters
----------
uvalue : (list of) float
    value in [0,1]
kpar : int
    index of the parameter
__add__( model )
Method for making compound models using + operator.
 
>>> model1 = model2 + model3
 
Parameters
----------
model : Model
    a copy of model to add to a copy of self (the existing chain)
__call__( x )
Return the result of the model.
 
>>> y = model( x )
is equivalent to
>>> y = model.result( x, model.parameters )
 
Parameters
----------
x : (list of) float
    apply the model to x (as input)
__getitem__( i )
Return the i-th parameter.
 
>>> p_i = model[i]
 
Parameters
----------
i : int
    index for the parameter.
__iadd__( model )
Method for making compound models using += operator.
 
>>> model1 += model2
 
Parameters
----------
model : Model
    a model to add to self (the existing chain)
__imul__( model )
Method for making compound models using *= operator.
 
>>> model1 *= model2
 
Parameters
----------
model : Model
    a model to multiply with self (the existing chain)
__ior__( model )
Method for making compound models using |= operator.
 
>>> model1 |= model2
 
Use the results of model1 as input for model2.
 
Parameters
----------
model : Model
    a model to pipe the previous results through
__isub__( model )
Method for making compound models using -= operator.
 
>>> model1 -= model2
 
Parameters
----------
model : Model
    a model to subtract from self (the existing chain)
__itruediv__( model )
Method for making compound models using /= operator.
 
>>> model1 /= model2
 
Parameters
----------
model : Model
    a model to divide self with (the existing chain)
__mul__( model )
Method for making compound models using * operator.
 
>>> model1 = model2 * model3
 
Parameters
----------
model : Model
    a copy of model to multiply with a copy of self (the existing chain)
__or__( model )
Method for making compound models using | (pipe) operator.
 
>>> model1 = model2 | model3
 
Parameters
----------
model : Model
    a copy of model to pipe the results of a copy of self (the existing chain)
__sub__( model )
Method for making compound models using - operator.
 
>>> model1 = model2 - model3
 
Parameters
----------
model : Model
    a copy of model to subtract from a copy of self (the existing chain)
__truediv__( model )
Method for making compound models using / operator.
 
>>> model1 = model2 / model3
 
Parameters
----------
model : Model
    a copy of model to divide a copy of self with (the existing chain)

Methods inherited from FixedModel:
Methods inherited from BaseModel: