These methods are explicit Runge-Kutta methods, their Butcher arrays are as follows :
0 |
c2 | a21
c3 | a31 a32
... | ...
cs | as1 as2 ... ass-1
|--------------------------
| b1 b2 ... bs-1 bs
EulerIntegrator, ClassicalRungeKuttaIntegrator, GillIntegrator, MidpointIntegrator
| Modifier and Type | Field and Description |
|---|---|
| private final double[][] | a
Internal weights from Butcher array (without the first empty row). |
| private final double[] | b
External weights for the high order method from Butcher array. |
| private final double[] | c
Time steps from Butcher array (without the first zero). |
| private final RungeKuttaStepInterpolator | prototype
Prototype of the step interpolator. |
| private final double | step
Integration step. |
| Access | Constructor and Description |
|---|---|
| protected | RungeKuttaIntegrator(final String
name of the method name, final double[] time steps from Butcher array (without the first zero) c, final double[][] internal weights from Butcher array (without the first empty row) a, final double[] propagation weights for the high order method from Butcher array b, final RungeKuttaStepInterpolator prototype of the step interpolator to use prototype, final double integration step step)Simple constructor. |
| Modifier and Type | Method and Description |
|---|---|
| public void | integrate(final ExpandableStatefulODE
complete set of differential equations to integrate equations, final double target time for the integration
(can be set to a value smaller than t)t0 for backward integration)Implements abstract org. Integrate a set of differential equations up to the given time. |
| public double[] | Returns: state vector attdifferential equations to integrate equations, final double initial time t0, final double[] initial value of the state vector at t0 y0, final double target time for the integration
(can be set to a value smaller than t)t0 for backward integration)Fast computation of a single step of ODE integration. |
| a | back to summary |
|---|---|
| private final double[][] a Internal weights from Butcher array (without the first empty row). | |
| b | back to summary |
|---|---|
| private final double[] b External weights for the high order method from Butcher array. | |
| c | back to summary |
|---|---|
| private final double[] c Time steps from Butcher array (without the first zero). | |
| prototype | back to summary |
|---|---|
| private final RungeKuttaStepInterpolator prototype Prototype of the step interpolator. | |
| step | back to summary |
|---|---|
| private final double step Integration step. | |
| RungeKuttaIntegrator | back to summary |
|---|---|
| protected RungeKuttaIntegrator(final String name, final double[] c, final double[][] a, final double[] b, final RungeKuttaStepInterpolator prototype, final double step) Simple constructor. Build a Runge-Kutta integrator with the given step. The default step handler does nothing.
| |
| integrate | back to summary |
|---|---|
| public void integrate(final ExpandableStatefulODE equations, final double t) throws NumberIsTooSmallException, DimensionMismatchException, MaxCountExceededException, NoBracketingException Implements abstract org. Doc from org. Integrate a set of differential equations up to the given time. This method solves an Initial Value Problem (IVP). The set of differential equations is composed of a main set, which can be extended by some sets of secondary equations. The set of equations must be already set up with initial time and partial states. At integration completion, the final time and partial states will be available in the same object. Since this method stores some internal state variables made
available in its public interface during integration (
| |
| singleStep | back to summary |
|---|---|
| public double[] singleStep(final FirstOrderDifferentialEquations equations, final double t0, final double[] y0, final double t) Fast computation of a single step of ODE integration. This method is intended for the limited use case of very fast computation of only one step without using any of the rich features of general integrators that may take some time to set up (i.e. no step handlers, no events handlers, no additional states, no interpolators, no error control, no evaluations count, no sanity checks ...). It handles the strict minimum of computation, so it can be embedded in outer loops.
This method is not used at all by the As this method does not use any of the state-dependent features of the integrator, it should be reasonably thread-safe if and only if the provided differential equations are themselves thread-safe.
| |