# commons-issues mailing list archives

##### Site index · List index
Message view
Top
From "Luc Maisonobe (JIRA)" <j...@apache.org>
Subject [jira] Commented: (MATH-388) ODE integrator: different size needed for state vector and tolerance error vector dimension
Date Mon, 19 Jul 2010 18:53:52 GMT

[ https://issues.apache.org/jira/browse/MATH-388?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12889970#action_12889970
]

Luc Maisonobe commented on MATH-388:
------------------------------------

This issue is in some sense related to MATH-380.
I intend to completely change the way to solve ODE problems with Jacobians soon using a much
better architecture (the current implementation is really bad).
I will however encounter the exact same problem with the new architecture so need to solve
MATH-388 before MATH-380.

The simple Initial Value Problem is:
y(t0) = y0
y'(t) = f(t,y)
its solution is a function y(t)

Here, we want to integrate at the same time this problem and an extension of this problem
which is:
dy(t0)/dy0      = Jy0
dy(t0)/dp       = Jp0
d[dy(t)/dy~0~]/dt = one variational equation
d[dy(t)/dp]/dt  = another variational equation

So we end up with a very large state vector containing the initial y and also two jacobians.
As an example, in some orbit determination problems the size of the initial y vector is 7
and the size of the extended y can be 7 + (7 * 7) + (7 * 2) = 70.

However, we want to compute the step sizes and error estimation only on the first 7 parameters,
not the 63 final ones.

The dimension of the state vector is specified by the user who implements the FirstOrderDifferentialEquations
method and hence provides a getDimension() method. There is no way now to say: my problem
is dimension 70 but error should only be computed on the first 7 components of the vector.

So we need to add a getErrorDimension() or getMainProblemDimension() or something like that.
In the example above, this new method would return 7 and the existing getDimension would return
70. The ODE integrators have to be changed (this is a simple change) to use the appropriate
dimension in the various loops.

Adding the new method in the FirstOrderDifferentialEquations is bad because it breaks compatibility
on user code (the interface is explicitly here to be implemented by users as it represents
the problem they want our integrators to solve). I would suggest to extend the interface using
something like:

{code:title=ExtendedFirstOrderDifferentialEquations.java}
public interface ExtendedFirstOrderDifferentialEquations
extends FirstOrderDifferentialEquations {

/** Return the dimension of the main problem.
* <p>
* The main problem represent the first part of an ODE state
* and the error estimations and adaptive step size computation
* should be done on this first part only, not on the final part
* of the state which represent an extension of the main problem.
* </p>
* @return dimension of the main problem, must be lesser than or
* equal to the {@link #getDimension() total dimension}
*/
int getMainProblemDimension();

}
{code}

Then ODE integrators would have to check if the user provided FirstOrderDifferentialEquations
implements only the base interface or the extended interface. In the former case, getDimension()
would be used for both state dimension and error dimension, in the later case the appropriate
method would be used for each loop.

This is the only solution I see that is backaward compatible. It implies putting in our integrators
code statements like:

{code}
int errorDimension;
if (equations instanceof ExtendedFirstOrderDifferentialEquations) {
errorDimension = equations.getDimension();
} else {
ExtendedFirstOrderDifferentialEquations extEq =  (ExtendedFirstOrderDifferentialEquations)
equations;
errorDimension = extEq.getMainProblemDimension();
}
{code}

This is not really elegant, but I don't see another way yet.

One problem is that some adventurous users may have implemented their own ODE integrators
and would not include this new feature, because basically the requirements for an integrator
are only defined in terms of FirstOrderDifferentialEquations not on the proposed new ExtendedFirstOrderDifferentialEquations.
However, this is not an incompatible change: these custom integrator currently use the complete
dimension to compute size, and they would still do it. So this problem is probably not important
(and I'm pretty sure noone as attempted yet to implement their own integrators from scratch).

What do other developers think ?

> ODE integrator: different size needed for state vector and tolerance error vector dimension
> -------------------------------------------------------------------------------------------
>
>                 Key: MATH-388
>                 URL: https://issues.apache.org/jira/browse/MATH-388
>             Project: Commons Math
>          Issue Type: Bug
>            Reporter: Pascal Parraud
>            Assignee: Luc Maisonobe
>             Fix For: 2.2
>
>
> The user should be allowed to chose a tolerance vector dimension different from the state
vector dimension.
> For example, using the FirstOrderIntegratorWithJacibians, we don't want to set some tolerance
error for the jacobian part in order to not interfere with the main state vector integration.
> This is really a problem with the dimension of the tolerance vector, there is no work-around
assigning some particular value to the tolerance vector.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Mime
View raw message