# doc-cache created by Octave 7.1.0
# name: cache
# type: cell
# rows: 3
# columns: 13
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
bwe_inexact_newton


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2262
 -- Command: [T_NEXT, X_NEXT] = bwe_inexact_newton (@FUN, T, X, DT,
          [OPTIONS])
 -- Command: [T_NEXT, X_NEXT, X_EST] = bwe_inexact_newton (@FUN, T, X,
          DT, [OPTIONS])

     This function can be used to integrate a set of non-stiff ordinary
     differential equations (non-stiff ODEs) with a given initial
     condition X from T to T+DT, with the Backward-Euler method using an
     inexact Newton method to solve the nonlinear system and estimating
     the error comparing the solution to that one given in two substeps
     by the Crank-Nicolson method.

     First output argument is the final integration time value.

     Second output parameter is the computed solution at time T_NEXT.

     Third output parameter is a solution of higher order for the
     estimation of the error.

     First input argument is the function describing the system of ODEs
     to be integrated.

     Second input parameter is the first extreme of integration
     interval.

     Third input argument is the initial condition of the system.

     Fourth input argument is the timestep, that is the length of the
     integration interval.

     Fifth input parameter is optional and describes a set of options
     useful to adapt the computation to what is needed.  Possible fields
     are
     'UseJacobian'
          is a switch variable ['YES','NO'] that tells the program how
          to set the 'JACOBIAN' option within optimset function,
     'NewtonTol'
          tolerance for termination test on residual,
     'MaxNewtonIterations'
          maximum number of nonlinear iterations,
     'Eta'
          initial forcing term (must be in the interval [0,1)).  For
          details see [1],
     'Choice'
          formula to use to select the forcing term may be 1 or 2,
          default value is 1.  For details see [1],
     'Algorithm'
          iterative method to solve the linearized system (default is
          ''GMRES''),
     'Restart'
          restart parameter for the GMRES solver (ignored for other
          solvers).

     References: [1] S.C. Eisenstat and H.F. Walker, "Choosing the
     Forcing Terms in an Inexact Newton Method."  SIAM Journal on
     Scientific Computing, 17(1), pp.  16-16, 1996.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a set of non-stiff ordinary
differenti...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
bwe_newton_raphson


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1772
 -- Command: [T_NEXT, X_NEXT] = bwe_newton_raphson (@FUN, T, X, DT,
          [OPTIONS])
 -- Command: [T_NEXT, X_NEXT, X_EST] = bwe_newton_raphson (@FUN, T, X,
          DT, [OPTIONS])

     This function can be used to integrate a set of non-stiff ordinary
     differential equations (non-stiff ODEs) with a given initial
     condition X from T to T+DT, with the Backward-Euler method using
     the Newton-Raphson method to solve the nonlinear system and
     estimating the error comparing the solution to that one given in
     two substeps by the same method.

     First output argument is the final integration time value.

     Second output parameter is the computed solution at time T_NEXT.

     Third output parameter is a higher order solution for the
     estimation of the error.

     First input argument is the function describing the system of ODEs
     to be integrated.

     Second input parameter is the first extreme of integration
     interval.

     Third input argument is the initial condition of the system.

     Fourth input argument is the timestep, that is the length of the
     integration interval.

     Fifth input parameter is optional and describes a set of options
     useful to adapt the computation to what is needed.  Possible fields
     are
     'NewtonTol'
          tolerance for termination test on residual,
     'MaxNewtonIterations'
          maximum number of nonlinear iterations,
     'Mass'
          a function_handle or a constant matrix defining the Mass
          matrix,
     'Jacobian'
          a function_handle defining the Jacobian,
     'havemasshandle'
          whether or not Mass is a function_handle,
     'massdependence'
          whether or not Mass depends on the solution.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a set of non-stiff ordinary
differenti...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
fwe_heun


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1256
 -- Command: [T_NEXT, X_NEXT] = fwe_heun (@FUN, T, X, DT, [OPTIONS])
 -- Command: [T_NEXT, X_NEXT, ERR] = fwe_heun (@FUN, T, X, DT,
          [OPTIONS])

     This function can be used to integrate a set of non-stiff ordinary
     differential equations (non-stiff ODEs) with a given initial
     condition X from T to T+DT, with the Forward-Euler method using the
     Heun-Euler method to estimate the error.  For the definition of
     this method see
     <http://en.wikipedia.org/wiki/List_of_Runge%E2%80%93Kutta_methods>.

     First output argument is the final integration time value.

     Second output parameter is the computed solution at time T_NEXT.

     Third output parameter is a higher order solution for the
     estimation of the error.

     First input argument is the function describing the system of ODEs
     to be integrated.

     Second input parameter is the first extreme of integration
     interval.

     Third input argument is the initial condition of the system.

     Fourth input argument is the timestep, that is the length of the
     integration interval.

     Fifth input parameter is optional and describes a set of options
     useful to adapt the computation to what is needed.

     See also: odepkg, ode12.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a set of non-stiff ordinary
differenti...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
fwe_richardson


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1170
 -- Command: [T_NEXT, X_NEXT] = fwe_richardson (@FUN, T, X, DT,
          [OPTIONS])
 -- Command: [T_NEXT, X_NEXT, X_EST] = fwe_richardson (@FUN, T, X, DT,
          [OPTIONS])

     This function can be used to integrate a set of non-stiff ordinary
     differential equations (non-stiff ODEs) with a given initial
     condition X from T to T+DT, with the Forward-Euler method using the
     Richardson extrapolation method to estimate the error.

     First output argument is the final integration time value.

     Second output parameter is the computed solution at time T_NEXT.

     Third output parameter is a higher order solution for the
     estimation of the error.

     First input argument is the function describing the system of ODEs
     to be integrated.

     Second input parameter is the first extreme of integration
     interval.

     Third input argument is the initial condition of the system.

     Fourth input argument is the timestep, that is the length of the
     integration interval.

     Fifth input parameter is optional and describes a set of options
     useful to adapt the computation to what is needed.

     See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a set of non-stiff ordinary
differenti...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
rattle


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1960
 -- Command: [T_NEXT, X_NEXT] = rattle (@FUN, T, X, DT, [OPTIONS])
 -- Command: [T_NEXT, X_NEXT, X_EST] = rattle (@FUN, T, X, DT,
          [OPTIONS])

     This function can be used to integrate a constrained Hamiltonian
     system with a given initial condition X from T to T+DT, with the
     RATTLE method using the Richardson extrapolation method to estimate
     the error.  For details about this method see [1].

     First output argument is the final integration time value.

     Second output parameter is the computed solution at time T_NEXT.

     Third output parameter is a higher order solution for the
     estimation of the error.

     First input argument is the function describing the system of ODEs
     to be integrated.

     Second input parameter is the first extreme of integration
     interval.

     Third input argument is the initial condition of the system.

     Fourth input argument is the timestep, that is the length of the
     integration interval.

     Fifth input parameter is optional and describes a set of options
     useful to adapt the computation to what is needed.  Possible fields
     are
     'HamiltonianHessFcn'
          a function_handle that represents the Hessian of the
          Hamiltonian of the system,
     'ConstraintFcn'
          a function_handle that represents the constraints of the
          system,
     'ConstraintsNb'
          a positive integer equal to the number of constraints of the
          system,
     'ConstraintGradFcn'
          a function_handle that represents the gradient of the
          constraints of the system,
     'ConstraintHessFcn'
          a function_handle that represents the Hessian of the
          constraints of the system.

     References: [1] E. Hairer, C. Lubich and G. Wanner, "Geometric
     Numerical Integration: Structure-Preserving Algorithms for Ordinary
     Differential Equations."  Second Edition, Springer.

     See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a constrained Hamiltonian system
with ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
runge_kutta_23


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2062
 -- Function File: [T_NEXT, X_NEXT] = runge_kutta_23 (@FUN, T, X, DT)
 -- Function File: [T_NEXT, X_NEXT] = runge_kutta_23 (@FUN, T, X, DT,
          OPTIONS)
 -- Function File: [T_NEXT, X_NEXT] = runge_kutta_23 (@FUN, T, X, DT,
          OPTIONS, K_VALS_IN)
 -- Function File: [T_NEXT, X_NEXT] = runge_kutta_23 (@FUN, T, X, DT,
          OPTIONS, K_VALS_IN, T_NEXT)
 -- Function File: [T_NEXT, X_NEXT, X_EST] = runge_kutta_23 (...)
 -- Function File: [T_NEXT, X_NEXT, X_EST, K_VALS_OUT] = runge_kutta_23
          (...)

     This function can be used to integrate a system of ODEs with a
     given initial condition X from T to T+DT, with the Bogacki-Shampine
     method of third order.  For the definition of this method see
     <http://en.wikipedia.org/wiki/List_of_Runge%E2%80%93Kutta_methods>.

     @FUN is a function handle that defines the ODE: 'y' = f(tau,y)'.
     The function must accept two inputs where the first is time TAU and
     the second is a column vector of unknowns Y.

     T is the first extreme of integration interval.

     X is the initial condition of the system..

     DT is the timestep, that is the length of the integration interval.

     The optional fourth argument OPTIONS specifies options for the ODE
     solver.  It is a structure generated by 'odeset'.  In particular it
     contains the field FUNARGUMENTS with the optional arguments to be
     used in the evaluation of @FUN.

     The optional fifth argument K_VALS_IN contains the Runge-Kutta
     evaluations of the previous step to use in a FSAL scheme.

     The optional sixth argument T_NEXT ('t_next = t + dt') specifies
     the end of the integration interval.  The output X_NEXT s the
     higher order computed solution at time T_NEXT (local extrapolation
     is performed).

     Optionally the functions can also return X_EST, a lower order
     solution for the estimation of the error, and K_VALS_OUT, a matrix
     containing the Runge-Kutta evaluations to use in a FSAL scheme or
     for dense output.

     See also: runge_kutta_45_dorpri.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a system of ODEs with a given
initial ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
runge_kutta_23s


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1933
 -- [T_NEXT, X_NEXT] = runge_kutta_23s (F, T, X, DT)
 -- [T_NEXT, X_NEXT] = runge_kutta_23s (F, T, X, DT, OPTIONS)
 -- [T_NEXT, X_NEXT] = runge_kutta_23s (F, T, X, DT, OPTIONS,
          K_VALS_IN)
 -- [T_NEXT, X_NEXT] = runge_kutta_23s (F, T, X, DT, OPTIONS,
          K_VALS_IN, T_NEXT)
 -- [T_NEXT, X_NEXT, X_EST] = runge_kutta_23s (...)
 -- [T_NEXT, X_NEXT, X_EST, K_VALS_OUT] = runge_kutta_23s (...)

     This function can be used to integrate a system of ODEs with a
     given initial condition X from T to T+DT, with a Rosenbrock method
     of order (2,3).  All the mathematical formulas are from "The MATLAB
     ode suite", L.F. Shampine, options.Mass.W. Reichelt, pp.6-71.

     F is a function handle that defines the ODE: 'y' = f(tau,y)'.  The
     function must accept two inputs where the first is time TAU and the
     second is a column vector of unknowns Y.

     T is the first extreme of integration interval.

     X is the initial condition of the system..

     DT is the timestep, that is the length of the integration interval.

     The optional fourth argument OPTIONS specifies options for the ODE
     solver.  It is a structure generated by 'odeset'.  In particular it
     contains the field FUNARGUMENTS with the optional arguments to be
     used in the evaluation of F.

     The optional fifth argument K_VALS_IN contains the Runge-Kutta
     evaluations of the previous step to use in a FSAL scheme.

     The optional sixth argument T_NEXT ('t_next = t + dt') specifies
     the end of the integration interval.  The output X_NEXT s the
     higher order computed solution at time T_NEXT (local extrapolation
     is performed).

     Optionally the functions can also return X_EST, a lower order
     solution for the estimation of the error, and K_VALS_OUT, a matrix
     containing the Runge-Kutta evaluations to use in a FSAL scheme or
     for dense output.

     See also: runge_kutta_23.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a system of ODEs with a given
initial ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
runge_kutta_45_fehlberg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1168
 -- Command: [T_NEXT, X_NEXT] = runge_kutta_45_fehlberg (@FUN, T, X, DT,
          [OPTIONS])
 -- Command: [T_NEXT, X_NEXT, X_EST] = runge_kutta_45_fehlberg (@FUN, T,
          X, DT, [OPTIONS])

     This function can be used to integrate a system of ODEs with a
     given initial condition X from T to T+DT, with the Fehlberg method.
     For the definition of this method see
     <http://en.wikipedia.org/wiki/Dormand%E2%80%93Prince_method>.

     First output argument is the final integration time value.

     Second output parameter is the computed solution at time T_NEXT.

     Third output parameter is a higher order solution for the
     estimation of the error.

     First input argument is the function describing the system of ODEs
     to be integrated.

     Second input parameter is the first extreme of integration
     interval.

     Third input argument is the initial condition of the system.

     Fourth input argument is the timestep, that is the length of the
     integration interval.

     Fifth input parameter is optional and describes a set of options
     useful to adapt the computation to what is needed.

     See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a system of ODEs with a given
initial ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
runge_kutta_78


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1084
 -- Command: [T_NEXT, X_NEXT] = runge_kutta_78 (@FUN, T, X, DT,
          [OPTIONS])
 -- Command: [T_NEXT, X_NEXT, X_EST] = runge_kutta_78 (@FUN, T, X, DT,
          [OPTIONS])

     This function can be used to integrate a system of ODEs with a
     given initial condition X from T to T+DT.  For the definition of
     this method see p.91 in Ascher & Petzold.

     First output argument is the final integration time value.

     Second output parameter is the computed solution at time T_NEXT.

     Third output parameter is a higher order solution for the
     estimation of the error.

     First input argument is the function describing the system of ODEs
     to be integrated.

     Second input parameter is the first extreme of integration
     interval.

     Third input argument is the initial condition of the system.

     Fourth input argument is the timestep, that is the length of the
     integration interval.

     Fifth input parameter is optional and describes a set of options
     useful to adapt the computation to what is needed.

     See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a system of ODEs with a given
initial ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
spectral_var_int


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3318
 -- Command: [T_NEXT, X_NEXT] = spectral_var_int (@FUN, T, X, DT,
          [OPTIONS])
 -- Command: [T_NEXT, X_NEXT, X_EST] = spectral_var_int (@FUN, T, X, DT,
          [OPTIONS])

     This function can be used to integrate a Hamiltonian system with a
     given initial condition X from T to T+DT, with the spectral
     variational integrators method.  The error is estimated comparing
     the solution with that one obtained with the same method but one
     order higher polynomials and one degree higher quadrature rule.
     For details about the theory see [1].

     First output argument is the final integration time value.

     Second output parameter is the computed solution at time T_NEXT.

     Third output parameter is a higher order solution for the
     estimation of the error.

     First input argument is the function describing the system of ODEs
     to be integrated.

     Second input parameter is the first extreme of integration
     interval.

     Third input argument is the initial condition of the system.

     Fourth input argument is the timestep, that is the length of the
     integration interval.

     Fifth input parameter is optional and describes a set of options
     useful to adapt the computation to what is needed.  The possible
     fields are
     'HamiltonianHessFcn'
          a function_handle that represents the Hessian of the
          Hamiltonian of the system,
     'Q_DoFs'
          a positive integer equal to Gauss quadrature rule degrees of
          freedom,
     'P_DoFs'
          a positive integer equal to Legendre polynomial degrees of
          freedom,
     'Nodes'
          a vector containing Gauss quadrature nodes,
     'Weights'
          a vector containing Gauss quadrature weights,
     'Legendre'
          a matrix containing Legendre polynomials values at quadrature
          nodes,
     'Derivatives'
          a matrix containing derivatives of Legendre polynomials
          evaluated at quadrature nodes,
     'Extremes'
          a matrix containing Legendre polynomials values at extremes,
     'Q_DoFs_err'
          a positive integer equal to Gauss quadrature rule degrees of
          freedom for the solution used to estimate the error,
     'P_DoFs_err'
          a positive integer equal to Legendre polynomial degrees of
          freedom for the solution used to estimate the error,
     'Nodes_err'
          a vector containing Gauss quadrature nodes for the solution
          used to estimate the error,
     'Weights_err'
          a vector containing Gauss quadrature weights for the solution
          used to estimate the error,
     'Legendre_err'
          a matrix containing Legendre polynomials values at quadrature
          nodes for the solution used to estimate the error,
     'Derivatives_err'
          a matrix containing derivatives of Legendre polynomials
          evaluated at quadrature nodes for the solution used to
          estimate the error,
     'Extremes_err'
          a matrix containing Legendre polynomials values at extremes
          for the solution used to estimate the error.

     References: [1] J.E. Marsden and M. West, "Discrete Mechanics and
     Variational Integrators."  Acta Numerica (2001), pp 1-158,
     Cambridge University Press.

     See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a Hamiltonian system with a given
init...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
stormer_verlet


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1647
 -- Command: [T_NEXT, X_NEXT] = stormer_verlet (@FUN, T, X, DT,
          [OPTIONS])
 -- Command: [T_NEXT, X_NEXT, X_EST] = stormer_verlet (@FUN, T, X, DT,
          [OPTIONS])

     This function can be used to integrate a Hamiltonian system with a
     given initial condition X from T to T+DT, with the Stormer-Verlet
     method using the Richardson extrapolation method to estimate the
     error.  For details about this method see [1].

     First output argument is the final integration time value.

     Second output parameter is the computed solution at time T_NEXT.

     Third output parameter is a higher order solution for the
     estimation of the error.

     First input argument is the function describing the system of ODEs
     to be integrated.

     Second input parameter is the first extreme of integration
     interval.

     Third input argument is the initial condition of the system.

     Fourth input argument is the timestep, that is the length of the
     integration interval.

     Fifth input parameter is optional and describes a set of options
     useful to adapt the computation to what is needed.  The possible
     fields are
     'Explicit'
          a switch ['YES','NO'] which tells the solver if the system to
          be solved is explicit or not,
     'HamiltonianHessFcn'
          a function_handle that represents the Hessian of the
          Hamiltonian of the system.

     References: [1] E. Hairer, C. Lubich and G. Wanner, "Geometric
     Numerical Integration: Structure-Preserving Algorithms for Ordinary
     Differential Equations."  Second Edition, Springer.

     See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a Hamiltonian system with a given
init...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
symplectic_euler


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1852
 -- Command: [T_NEXT, X_NEXT] = symplectic_euler (@FUN, T, X, DT,
          [OPTIONS])
 -- Command: [T_NEXT, X_NEXT, X_EST] = symplectic_euler (@FUN, T, X, DT,
          [OPTIONS])

     This function can be used to integrate a Hamiltonian system with a
     given initial condition X from T to T+DT, with the Symplectic Euler
     method (also known as Semi-implicit Euler) using the Richardson
     extrapolation method to estimate the error.  For details about this
     method see E. Hairer and C. Lubich and G. Wanner, "Geometric
     Numerical Integration: Structure-Preserving Algorithms for Ordinary
     Differential Equations", Springer.

     First output argument is the final integration time value.

     Second output parameter is the computed solution at time T_NEXT.

     Third output parameter is a higher order solution for the
     estimation of the error.

     First input argument is the function describing the system of ODEs
     to be integrated.

     Second input parameter is the first extreme of integration
     interval.

     Third input argument is the initial condition of the system.

     Fourth input argument is the timestep, that is the length of the
     integration interval.

     Fifth input parameter is optional and describes a set of options
     useful to adapt the computation to what is needed.  The possible
     fields are
     'Explicit'
          a switch ['YES','NO'] which tells the solver if the system to
          be solved is explicit or not,
     'HamiltonianHessFcn'
          a function_handle that represents the Hessian of the
          Hamiltonian of the system.

     References: [1] E. Hairer, C. Lubich and G. Wanner, "Geometric
     Numerical Integration: Structure-Preserving Algorithms for Ordinary
     Differential Equations."  Second Edition, Springer.

     See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a Hamiltonian system with a given
init...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
velocity_verlet


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1647
 -- Command: [T_NEXT, X_NEXT] = stormer_verlet (@FUN, T, X, DT,
          [OPTIONS])
 -- Command: [T_NEXT, X_NEXT, X_EST] = stormer_verlet (@FUN, T, X, DT,
          [OPTIONS])

     This function can be used to integrate a Hamiltonian system with a
     given initial condition X from T to T+DT, with the Stormer-Verlet
     method using the Richardson extrapolation method to estimate the
     error.  For details about this method see [1].

     First output argument is the final integration time value.

     Second output parameter is the computed solution at time T_NEXT.

     Third output parameter is a higher order solution for the
     estimation of the error.

     First input argument is the function describing the system of ODEs
     to be integrated.

     Second input parameter is the first extreme of integration
     interval.

     Third input argument is the initial condition of the system.

     Fourth input argument is the timestep, that is the length of the
     integration interval.

     Fifth input parameter is optional and describes a set of options
     useful to adapt the computation to what is needed.  The possible
     fields are
     'Explicit'
          a switch ['YES','NO'] which tells the solver if the system to
          be solved is explicit or not,
     'HamiltonianHessFcn'
          a function_handle that represents the Hessian of the
          Hamiltonian of the system.

     References: [1] E. Hairer, C. Lubich and G. Wanner, "Geometric
     Numerical Integration: Structure-Preserving Algorithms for Ordinary
     Differential Equations."  Second Edition, Springer.

     See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function can be used to integrate a Hamiltonian system with a given
init...





