org.apache.commons.math3.ode

## Class ParameterJacobianWrapper

- java.lang.Object
- - org.apache.commons.math3.ode.ParameterJacobianWrapper

- All Implemented Interfaces:
    Parameterizable, ParameterJacobianProvider

       class ParameterJacobianWrapper
      extends java.lang.Object
      implements ParameterJacobianProvider

  Wrapper class to compute Jacobian matrices by finite differences for ODE which do not compute them by themselves.
  Since:
    3.0
  Version:
    $Id: ParameterJacobianWrapper.java 1416643 2012-12-03 19:37:14Z tn $

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `private FirstOrderDifferentialEquations` | `fode` Main ODE set.
    `private java.util.Map<java.lang.String,java.lang.Double>` | `hParam` Steps for finite difference computation of the Jacobian df/dp w.r.t.
    `private ParameterizedODE` | `pode` Raw ODE without Jacobian computation skill to be wrapped into a ParameterJacobianProvider.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ParameterJacobianWrapper(FirstOrderDifferentialEquations fode, ParameterizedODE pode, ParameterConfiguration[] paramsAndSteps)` Wrap a `ParameterizedODE` into a `ParameterJacobianProvider`.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `computeParameterJacobian(double t, double[] y, double[] yDot, java.lang.String paramName, double[] dFdP)` Compute the Jacobian matrix of ODE with respect to one parameter.
    `java.util.Collection<java.lang.String>` | `getParametersNames()` Get the names of the supported parameters.
    `boolean` | `isSupported(java.lang.String name)` Check if a parameter is supported.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### fode

          private final FirstOrderDifferentialEquations fode

      Main ODE set.

    - #### pode

          private final ParameterizedODE pode

      Raw ODE without Jacobian computation skill to be wrapped into a ParameterJacobianProvider.

    - #### hParam

          private final java.util.Map<java.lang.String,java.lang.Double> hParam

      Steps for finite difference computation of the Jacobian df/dp w.r.t. parameters.

  - ### Constructor Detail

    - #### ParameterJacobianWrapper

          public ParameterJacobianWrapper(FirstOrderDifferentialEquations fode,
                                  ParameterizedODE pode,
                                  ParameterConfiguration[] paramsAndSteps)

      Wrap a `ParameterizedODE` into a `ParameterJacobianProvider`.
      Parameters:
        `fode` - main first order differential equations set
        `pode` - secondary problem, without parameter Jacobian computation skill
        `paramsAndSteps` - parameters and steps to compute the Jacobians df/dp
      See Also:
        `JacobianMatrices.setParameterStep(String, double)`

  - ### Method Detail

    - #### getParametersNames

          public java.util.Collection<java.lang.String> getParametersNames()

      Get the names of the supported parameters.
      Specified by:
        `getParametersNames` in interface `Parameterizable`
      Returns:
        parameters names
      See Also:
        `Parameterizable.isSupported(String)`

    - #### isSupported

          public boolean isSupported(java.lang.String name)

      Check if a parameter is supported.

      Supported parameters are those listed by `Parameterizable.getParametersNames()`.

      Specified by:
        `isSupported` in interface `Parameterizable`
      Parameters:
        `name` - parameter name to check
      Returns:
        true if the parameter is supported
      See Also:
        `Parameterizable.getParametersNames()`

    - #### computeParameterJacobian

          public void computeParameterJacobian(double t,
                                      double[] y,
                                      double[] yDot,
                                      java.lang.String paramName,
                                      double[] dFdP)
                                        throws DimensionMismatchException,
                                               MaxCountExceededException

      Compute the Jacobian matrix of ODE with respect to one parameter.

      If the parameter does not belong to the collection returned by `Parameterizable.getParametersNames()`, the Jacobian will be set to 0, but no errors will be triggered.

      Specified by:
        `computeParameterJacobian` in interface `ParameterJacobianProvider`
      Parameters:
        `t` - current value of the independent time variable
        `y` - array containing the current value of the main state vector
        `yDot` - array containing the current value of the time derivative of the main state vector
        `paramName` - name of the parameter to consider
        `dFdP` - placeholder array where to put the Jacobian matrix of the ODE with respect to the parameter
      Throws:
        `DimensionMismatchException` - if arrays dimensions do not match equations settings
        `MaxCountExceededException` - if the number of functions evaluations is exceeded

Copyright (c) 2003-2013 Apache Software Foundation