Selon Al Lelopath <jdaues@gmail.com>:
> I see that apache commons has Estimators (aka Solvers, yes?):
> EstimatedParameter
> GaussNewtonEstimator
> LevenbergMarquardtEstimator
> SimpleEstimationProblem
> WeightedMeasurement
Not all these classes represent solvers. Only the ones that implement Estimator
(i.e. GaussNewtonEstimator and LevenbergMarquardtEstimator) are estimators. The
other classes are used for estimation but are not the solvers themselves.
EStimatedParameters represent the parameters of the models, and the job of the
solver is to update these parameters in order to minimize a cost function. When
the solvers has finished its work, retrieving the results is a matter of reading
the updated value hold by the instances of this class. SimpleEstimationProblem
is mostly a container for the parameters and the measurements. The basic usage
is for the user to create a problemspecific class extending this one, the
created class implementing the logic of the model (relation between parameters
and model, relation between model and theoretical measurements, container for
the observed measurements). The cost function is automatically computed from the
residuals between theoretical and observed measurements). The
WeightedMeasurements class represent a measurement, it should also be
specialized by creating a class extending this one for each type of
measurements.
>
> Our mathematician has specified features we will need:
> 1. Assume nonnegative parameters,
This feature is a simple bound constraint. The estimators do not
handle any constraints yet (neither simple bounds, nor linear, nor nonlinear).
This will most probably be added one day as it is rather important.
Simple bounds constraints can be simulated artificially though, by adding a
layer between the solved parameters and the real parameters of the model. For
example, if your model needs three parameters p1, p2 and p3 with p1 that should
be positive, you can really solve using q1, p2, p3 with an additional transform
p1 = q1^2 implemented by your model. Similar transforms can be built for double
bounds constraints.
> 2. forward and central derivatives,
The derivatives are not computed by the classes provided by commonsmath, they
should be provided by the user when extending the SimpleEstimationProblem class
(or implementing directly the EstimationProblem interface if prefered). This
means you can use any method you prefer for computeing them : forward, central
or backward finite differences or analycally computed derivatives.
> 3. tangent estimates
I'm not sure I understand what you mean here. The solvers are based on gradient
computation at the current point which is updated according to the selected
solver algorithm.
> 4. quadratic estimates,
I'm also not sure to understand what you mean here. The problem are defined in
terms of observed measurements which are defined at problem start and
theoretical measurements which are automatically recomputed during the search as
the current point moves. The algorithms compute a quadratic cost function as the
sum of the weighted residuals between theoretical measurements and observed
measurements. This cost function is minimized (i.e. parameters are adjusted in
such a way theoretically recomputed measurements match the observations). The
quadratic structure of the cost function is fixed, but the measurements involved
and the weights can be specified by the user.
> 5. Newton and conjugate search direction
The GaussNewtonEstimator is based on ... the GaussNewton algorithm which
iterates over a Newton search.
The LevenbergMarquardtEstimator is a much more elaborate algorithm which
interpolates between a GaussNewton and a gradient method. It is more robust
than GaussNewton and highly recommended.
Commonsmath currently does not yet provide a simple conjugategradient method.
>
> Does apache commons have these capabilities?
To conclude, commonsmath provide some of these capabilities, but not all of
them.
Luc

To unsubscribe, email: userunsubscribe@commons.apache.org
For additional commands, email: userhelp@commons.apache.org
