# doc-cache created by Octave 7.3.0
# name: cache
# type: cell
# rows: 3
# columns: 34
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
bvp4c


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 698
 -- Function File: A = bvp4c (ODEFUN, BCFUN, SOLINIT)

     Solves the first order system of non-linear differential equations
     defined by ODEFUN with the boundary conditions defined in BCFUN.

     The structure SOLINIT defines the grid on which to compute the
     solution (SOLINIT.X), and an initial guess for the solution
     (SOLINIT.Y).  The output SOL is also a structure with the following
     fields:
        • SOL.X list of points where the solution is evaluated
        • SOL.Y solution evaluated at the points SOL.X
        • SOL.YP derivative of the solution evaluated at the points
          SOL.X
        • SOL.SOLVER = "bvp4c" for compatibility

     See also: odpkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Solves the first order system of non-linear differential equations
defined by...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
ode12


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3174
 -- Function File: [T, Y] = ode12 (FUN, TRANGE, INIT)
 -- Function File: [T, Y] = ode12 (FUN, TRANGE, INIT, ODE_OPT)
 -- Function File: [T, Y] = ode12 (..., PAR1, PAR2, ...)
 -- Function File: [T, Y, TE, YE, IE] = ode12 (...)
 -- Function File: SOLUTION = ode12 (...)

     Solve a set of non-stiff Ordinary Differential Equations (non-stiff
     ODEs) with the well known explicit Heun-Euler method of order 1.
     For the definition of this method see
     <http://en.wikipedia.org/wiki/List_of_Runge%E2%80%93Kutta_methods>.

     FUN is a function handle, inline function, or string containing the
     name of the function that defines the ODE: ‘y' = f(t,y)’.  The
     function must accept two inputs where the first is time T and the
     second is a column vector of unknowns Y.

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances using an interpolation procedure of the
     same order as the one of the solver.

     By default, ‘ode12’ uses an adaptive timestep with the
     ‘integrate_adaptive’ algorithm.  The tolerance for the timestep
     computation may be changed by using the options "RelTol" and
     "AbsTol".

     INIT contains the initial value for the unknowns.  If it is a row
     vector then the solution Y will be a matrix in which each column is
     the solution for the corresponding initial value in INIT.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘ode12’ will ignore the following options: "BDF", "InitialSlope",
     "Jacobian", "JPattern", "MassSingular", "MaxOrder", "MvPattern",
     "Vectorized".

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was computed.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.  If
     TRANGE specifies intermediate time steps, only those will be
     returned.

     The output can also be returned as a structure SOLUTION which has a
     field X containing a row vector of times where the solution was
     evaluated and a field Y containing the solution matrix such that
     each column corresponds to a time in X.  Use ‘fieldnames
     (SOLUTION)’ to see the other fields and additional information
     returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.

     Example: Solve the Van der Pol equation

          fvdp = @(T,Y) [Y(2); (1 - Y(1)^2) * Y(2) - Y(1)];
          [T,Y] = ode12 (fvdp, [0, 20], [2, 0]);

     See also: odeset, ode23, ode45, ode78.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Solve a set of non-stiff Ordinary Differential Equations (non-stiff
ODEs) wit...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4062
 -- [T, Y] = ode23d (FUN, TRANGE, INIT, LAGS, HISTORY)
 -- [T, Y] = ode23d (FUN, TRANGE, INIT, LAGS, HISTORY, ODE_OPT)
 -- [T, Y, TE, YE, IE] = ode23d (...)
 -- SOLUTION = ode23d (...)

     This function file can be used to solve a set of non–stiff delay
     differential equations (non–stiff DDEs) with a modified version of
     the well known explicit Runge–Kutta method of order 3.

     FUN is a function handle, inline function, or string containing the
     name of the function that defines the ODE: ‘y' = f(t,y)’.  The
     function must accept two inputs where the first is time T and the
     second is a column vector of unknowns Y.

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances using an interpolation procedure of the
     same order as the one of the solver.

     INIT contains the initial value for the unknowns.  If it is a row
     vector then the solution Y will be a matrix in which each column is
     the solution for the corresponding initial value in INIT.

     LAGS is a vector that describes the lags of time.

     HISTORY is a matrix and describes the history of the DDEs.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘ode23d’ will ignore the following options: "BDF", "InitialSlope",
     "Jacobian", "JPattern", "MassSingular", "MaxOrder", "MvPattern",
     "Vectorized".

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was computed.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.  If
     TRANGE specifies intermediate time steps, only those will be
     returned.

     The output can also be returned as a structure SOLUTION which has
     field X containing the time where the solution was evaluated and
     field Y containing the solution matrix for the times in X.  Use
     ‘fieldnames (SOLUTION)’ to see the other fields and additional
     information returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.

     In other words, this function will solve a problem of the form
          dy/dt = fun (t, y(t), y(t-lags(1), y(t-lags(2), ...)))
          y(slot(1)) = init
          y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), ...

     For example:
        − the following code solves an anonymous implementation of a
          chaotic behavior

               fcao = @(vt, vy, vz) [2 * vz / (1 + vz^9.65) - vy];

               vopt = odeset ("NormControl", "on", "RelTol", 1e-3);
               vsol = ode23d (fcao, [0, 100], 0.5, 2, 0.5, vopt);

               vlag = interp1 (vsol.x, vsol.y, vsol.x - 2);
               plot (vsol.y, vlag); legend ("fcao (t,y,z)");

        − to solve the following problem with two delayed state
          variables

               d y1(t)/dt = -y1(t)
               d y2(t)/dt = -y2(t) + y1(t-5)
               d y3(t)/dt = -y3(t) + y2(t-10)*y1(t-10)

          one might do the following

               function f = fun (t, y, yd)
               f(1) = -y(1);                   %% y1' = -y1(t)
               f(2) = -y(2) + yd(1,1);         %% y2' = -y2(t) + y1(t-lags(1))
               f(3) = -y(3) + yd(2,2)*yd(1,2); %% y3' = -y3(t) + y2(t-lags(2))*y1(t-lags(2))
               end
               T = [0,20]
               res = ode23d (@fun, T, [1;1;1], [5, 10], ones (3,2));

     See also: odeset, ode45d, ode78d.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3366
 -- Function File: [T, Y] = ode23s (FUN, TRANGE, INIT)
 -- Function File: [T, Y] = ode23s (FUN, TRANGE, INIT, ODE_OPT)
 -- Function File: [T, Y] = ode23s (..., PAR1, PAR2, ...)
 -- Function File: [T, Y, TE, YE, IE] = ode23s (...)
 -- Function File: SOLUTION = ode23s (...)

     Solve a set of stiff ordinary differential (stiff ODEs) equations
     with a Rosenbrock method of order (2,3).  For the definition of
     this method see "The MATLAB ode suite", L.F. Shampine, mass.W.
     Reichelt, pp.6-7

     FUN is a function handle, inline function, or string containing the
     name of the function that defines the ODE: ‘M y' = f(t,y)’.  The
     function must accept two inputs where the first is time T and the
     second is a column vector of unknowns Y.  M is a costant mass
     matrix, non-singular and possibly sparse.  Set the field MASS in
     ODEOPTS using ODESET to specify a mass matrix.

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances using an interpolation procedure of the
     same order as the one of the solver.

     By default, ‘ode23s’ uses an adaptive timestep with the
     ‘integrate_adaptive’ algorithm.  The tolerance for the timestep
     computation may be changed by using the options "RelTol" and
     "AbsTol".

     INIT contains the initial value for the unknowns.  If it is a row
     vector then the solution Y will be a matrix in which each column is
     the solution for the corresponding initial value in INIT.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘ode23s’ will ignore the following options: "BDF", "InitialSlope",
     "MassSingular", "MStateDependence", "MvPattern", "MaxOrder",
     "NonNegative".

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was computed.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.  If
     TRANGE specifies intermediate time steps, only those will be
     returned.

     The output can also be returned as a structure SOLUTION which has a
     field X containing a row vector of times where the solution was
     evaluated and a field Y containing the solution matrix such that
     each column corresponds to a time in X.  Use ‘fieldnames
     (SOLUTION)’ to see the other fields and additional information
     returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.  .  Example: Solve the stiff Van der
     Pol equation

          f = @(T,Y) [Y(2); 1000*(1 - Y(1)^2) * Y(2) - Y(1)];
          opt = odeset ('Mass', [1 0; 0 1], 'MaxStep', 1e-1);
          [vt, vy] = ode23s (f, [0 2000], [2 0], opt);

     See also: odeset, daspk, dassl.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Solve a set of stiff ordinary differential (stiff ODEs) equations with a
Rose...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4032
 -- [T, Y] = ode45d (FUN, TRANGE, INIT, LAGS, HISTORY)
 -- [T, Y] = ode45d (FUN, TRANGE, INIT, LAGS, HISTORY, ODE_OPT)
 -- [T, Y, TE, YE, IE] = ode45d (...)
 -- SOLUTION = ode45d (...)

     Solve a set of non–stiff delay differential equations (non–stiff
     DDEs) with a modified version of the well known explicit
     Runge–Kutta method of order (4,5).

     FUN is a function handle, inline function, or string containing the
     name of the function that defines the ODE: ‘y' = f(t,y)’.  The
     function must accept two inputs where the first is time T and the
     second is a column vector of unknowns Y.

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances using an interpolation procedure of the
     same order as the one of the solver.

     INIT contains the initial value for the unknowns.  If it is a row
     vector then the solution Y will be a matrix in which each column is
     the solution for the corresponding initial value in INIT.

     LAGS is a vector that describes the lags of time.

     HISTORY is a matrix and describes the history of the DDEs.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘ode45d’ will ignore the following options: "BDF", "InitialSlope",
     "Jacobian", "JPattern", "MassSingular", "MaxOrder", "MvPattern",
     "Vectorized".

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was computed.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.  If
     TRANGE specifies intermediate time steps, only those will be
     returned.

     The output can also be returned as a structure SOLUTION which has
     field X containing the time where the solution was evaluated and
     field Y containing the solution matrix for the times in X.  Use
     ‘fieldnames (SOLUTION)’ to see the other fields and additional
     information returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.

     In other words, this function will solve a problem of the form
          dy/dt = fun (t, y(t), y(t-lags(1), y(t-lags(2), ...)))
          y(slot(1)) = init
          y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), ...

     For example:
        − the following code solves an anonymous implementation of a
          chaotic behavior

               fcao = @(vt, vy, vz) [2 * vz / (1 + vz^9.65) - vy];

               vopt = odeset ("NormControl", "on", "RelTol", 1e-3);
               vsol = ode45d (fcao, [0, 100], 0.5, 2, 0.5, vopt);

               vlag = interp1 (vsol.x, vsol.y, vsol.x - 2);
               plot (vsol.y, vlag); legend ("fcao (t,y,z)");

        − to solve the following problem with two delayed state
          variables

               d y1(t)/dt = -y1(t)
               d y2(t)/dt = -y2(t) + y1(t-5)
               d y3(t)/dt = -y3(t) + y2(t-10)*y1(t-10)

          one might do the following

               function f = fun (t, y, yd)
               f(1) = -y(1);                   %% y1' = -y1(t)
               f(2) = -y(2) + yd(1,1);         %% y2' = -y2(t) + y1(t-lags(1))
               f(3) = -y(3) + yd(2,2)*yd(1,2); %% y3' = -y3(t) + y2(t-lags(2))*y1(t-lags(2))
               end
               T = [0,20]
               res = ode45d (@fun, T, [1;1;1], [5, 10], ones (3,2));

     See also: odeset, ode23d, ode78d.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Solve a set of non–stiff delay differential equations (non–stiff DDEs)
wi...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
ode78


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3108
 -- Function File: [T, Y] = ode78 (FUN, TRANGE, INIT)
 -- Function File: [T, Y] = ode78 (FUN, TRANGE, INIT, ODE_OPT)
 -- Function File: [T, Y] = ode78 (..., PAR1, PAR2, ...)
 -- Function File: [T, Y, TE, YE, IE] = ode78 (...)
 -- Function File: SOLUTION = ode78 (...)

     Solve a set of non-stiff Ordinary Differential Equations (non-stiff
     ODEs) or non–stiff differential algebraic equations (non–stiff
     DAEs) with the well known explicit Runge–Kutta method of order 7.

     FUN is a function handle, inline function, or string containing the
     name of the function that defines the ODE: ‘y' = f(t,y)’.  The
     function must accept two inputs where the first is time T and the
     second is a column vector of unknowns Y.

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances using a Hermite interpolation procedure
     of order 3.

     By default, ‘ode78’ uses an adaptive timestep with the
     ‘integrate_adaptive’ algorithm.  The tolerance for the timestep
     computation may be changed by using the options "RelTol" and
     "AbsTol".

     INIT contains the initial value for the unknowns.  If it is a row
     vector then the solution Y will be a matrix in which each column is
     the solution for the corresponding initial value in INIT.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘ode78’ will ignore the following options: "BDF", "InitialSlope",
     "Jacobian", "JPattern", "MassSingular", "MaxOrder", "MvPattern",
     "Vectorized".

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was computed.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.  If
     TRANGE specifies intermediate time steps, only those will be
     returned.

     The output can also be returned as a structure SOLUTION which has a
     field X containing a row vector of times where the solution was
     evaluated and a field Y containing the solution matrix such that
     each column corresponds to a time in X.  Use ‘fieldnames
     (SOLUTION)’ to see the other fields and additional information
     returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.

     Example: Solve the Van der Pol equation

          fvdp = @(T,Y) [Y(2); (1 - Y(1)^2) * Y(2) - Y(1)];
          [T,Y] = ode78 (fvdp, [0, 20], [2, 0]);

     See also: odeset, ode78, ode23, ode78.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Solve a set of non-stiff Ordinary Differential Equations (non-stiff
ODEs) or ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3997
 -- [T, Y] = ode78d (FUN, TRANGE, INIT, LAGS, HISTORY)
 -- [T, Y] = ode78d (FUN, TRANGE, INIT, LAGS, HISTORY, ODE_OPT)
 -- [T, Y, TE, YE, IE] = ode78d (...)
 -- SOLUTION = ode78d (...)

     Solve a set of non–stiff delay differential equations (non–stiff
     DDEs) with a modified version of the well known explicit
     Runge–Kutta method of order (7,8).

     FUN is a function handle, inline function, or string containing the
     name of the function that defines the ODE: ‘y' = f(t,y)’.  The
     function must accept two inputs where the first is time T and the
     second is a column vector of unknowns Y.

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances using a Hermite interpolation of order
     3.

     INIT contains the initial value for the unknowns.  If it is a row
     vector then the solution Y will be a matrix in which each column is
     the solution for the corresponding initial value in INIT.

     LAGS is a vector that describes the lags of time.

     HISTORY is a matrix and describes the history of the DDEs.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘ode78d’ will ignore the following options: "BDF", "InitialSlope",
     "Jacobian", "JPattern", "MassSingular", "MaxOrder", "MvPattern",
     "Vectorized".

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was computed.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.  If
     TRANGE specifies intermediate time steps, only those will be
     returned.

     The output can also be returned as a structure SOLUTION which has
     field X containing the time where the solution was evaluated and
     field Y containing the solution matrix for the times in X.  Use
     ‘fieldnames (SOLUTION)’ to see the other fields and additional
     information returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.

     In other words, this function will solve a problem of the form
          dy/dt = fun (t, y(t), y(t-lags(1), y(t-lags(2), ...)))
          y(slot(1)) = init
          y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), ...

     For example:
        − the following code solves an anonymous implementation of a
          chaotic behavior

               fcao = @(vt, vy, vz) [2 * vz / (1 + vz^9.65) - vy];

               vopt = odeset ("NormControl", "on", "RelTol", 1e-3);
               vsol = ode78d (fcao, [0, 100], 0.5, 2, 0.5, vopt);

               vlag = interp1 (vsol.x, vsol.y, vsol.x - 2);
               plot (vsol.y, vlag); legend ("fcao (t,y,z)");

        − to solve the following problem with two delayed state
          variables

               d y1(t)/dt = -y1(t)
               d y2(t)/dt = -y2(t) + y1(t-5)
               d y3(t)/dt = -y3(t) + y2(t-10)*y1(t-10)

          one might do the following

               function f = fun (t, y, yd)
               f(1) = -y(1);                   %% y1' = -y1(t)
               f(2) = -y(2) + yd(1,1);         %% y2' = -y2(t) + y1(t-lags(1))
               f(3) = -y(3) + yd(2,2)*yd(1,2); %% y3' = -y3(t) + y2(t-lags(2))*y1(t-lags(2))
               end
               T = [0,20]
               res = ode78d (@fun, T, [1;1;1], [5, 10], ones (3,2));

     See also: odeset, ode23d, ode45d.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Solve a set of non–stiff delay differential equations (non–stiff DDEs)
wi...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
odeRATTLE


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5940
 -- Function File: [T, Y] = odeRATTLE (FUN, CONSTR, TRANGE, INIT)
 -- Function File: [T, Y] = odeRATTLE (FUN, CONSTR, TRANGE, INIT,
          ODE_OPT)
 -- Function File: [T, Y] = odeRATTLE (..., PAR1, PAR2, ...)
 -- Function File: [T, Y, TE, YE, IE] = odeRATTLE (...)
 -- Function File: SOLUTION = odeRATTLE (...)

     This function is a geometric integrator for constrained Hamilton’s
     equations of motion that uses the RATTLE method of order 2 to find
     the new solution, step by step.

     FUN is a function_handle or an inline function that defines the
     system q' = dH/dp (t,[q;p]) p' = -dH/dq (t,[q;p]), where H(t,[q;p])
     is the Hamiltonian of the problem, q are generalized coordinates
     and p are generalized momenta.  This function must take two input
     arguments: the time and the unknowns.  It must return a vector or a
     cell (if the Hamiltonian Hessian is passed to speedup computations)
     containing as first element the Hamilton’s equations of motion (the
     previous system of equations) and as second element the Hessian of
     the Hamiltonian.

     CONSTR is a function_handle or an inline function that defines the
     constraints of the problem g(q)=0.  This function must take one
     input argument and must return a vector or a cell (if the
     constraint gradient and constraint Hessian are passed) containing
     as first element the equations defining the holonomic constraints
     and as second and third elements respectively the gradient and the
     Hessian of this constraints function (this is not mandatory but it
     can speedup the computation and improve accuracy).

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances using linear interpolation.

     By default, ‘odeRATTLE’ uses an adaptive timestep with the
     ‘integrate_adaptive’ algorithm.  The tolerance for the timestep
     computation may be changed by using the options "RelTol" and
     "AbsTol".

     INIT contains the initial value for the unknowns.  It is a row or
     column vector containing the generalized coordinates in its first
     half and the generalized momenta in the second half.  Each momentum
     correspond to the coordinate with the same relative position inside
     the vector of initial conditions.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘ode12’ will ignore the following options: "BDF", "InitialSlope",
     "Jacobian", "JPattern", "MassSingular", "MaxOrder", "MvPattern",
     "Vectorized".  The user can set extra options by adding fields to
     the structure.  ‘odeRATTLE’ allows for:

     NewtonTol
          the tolerance for the Newton algorithm [Default = 1e-7].

     MaxNewtonIterations
          maximum number of Newton iterations [Default = 100].

     InexactSolver
          the Newton solver.  It can be set to either
          ["newton_raphson"], "inexact_newton" or "fsolve".

     ConstraintFcn
          function_handle representing the constraints of the system.

     ConstraintGradFcn
          function_handle representing the gradient of the constraints
          of the system.

     ConstraintHessFcn
          function_handle representing the Hessian of the Hamiltonian of
          the system,

     ConstraintsNb
          positive integer equal to the number of constraints of the
          system.

     HamiltonianHessFcn
          function_handle representing the Hessian of the Hamiltonian of
          the system.

     If the "inexact_newton" solver is set, a further set of options can
     be provided:

     UseJacobian
          It can be set to either "yes" or ["no].  In the first case,
          the Hamiltonian Hessian, the constraint gradient and the
          constraint Hessian will be used.  If they are not provided,
          they will be approximated by the utility functions
          ‘approx_Hamilt_Hess’, ‘approx_Constr_grad’ and
          ‘approx_Constr_Hess’.

     Eta
          initial forcing term (must be in the interval [0,1)).  The
          dafault value is set to 0.5.  For details see [1].

     Choice
          select the forcing term.  It can be 1 (Default) or 2.  For
          details see [1].

     Algorithm
          iterative method to solve the linearized system.  It can be
          ["gmres"], "pcg" or "bicgstab".

     Restart
          restart parameter for the GMRES solver (ignored for other
          solvers).  [Default = 20].

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was found.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.

     The output can also be returned as a structure SOLUTION which has
     field X containing the time where the solution was evaluated and
     field Y containing the solution matrix for the times in X.  Use
     ‘fieldnames (SOLUTION)’ to see the other fields and additional
     information returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.

     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: odeset, odeSE, odeSPVI, odeSV, odeVV.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function is a geometric integrator for constrained Hamilton’s
equation...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
odeSE


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4957
 -- Function File: [T, Y] = odeSE (FUN, TRANGE, INIT)
 -- Function File: [T, Y] = odeSE (FUN, TRANGE, INIT, ODE_OPT)
 -- Function File: [T, Y] = odeSE (..., PAR1, PAR2, ...)
 -- Function File: [T, Y, TE, YE, IE] = odeSE (...)
 -- Function File: SOLUTION = odeSE (...)

     This function is a geometric integrator for Hamilton’s equations of
     motion that uses the Symplectic-Euler method of order 1 (also known
     as Semi-implicit Euler method) to find the new solution, step by
     step.

     FUN is a function_handle or an inline function that defines the
     system q' = dH/dp (t,[q;p]) p' = -dH/dq (t,[q;p]), where H(t,[q;p])
     is the Hamiltonian of the problem, q are generalized coordinates
     and p are generalized momenta.  This function must take two input
     arguments: the time and the unknowns.  It must return a vector or a
     cell (if the Hamiltonian Hessian is passed to speedup computations)
     containing as first element the Hamilton’s equations of motion (the
     previous system of equations) and as second element the Hessian of
     the Hamiltonian.

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances using linear interpolation.

     By default, ‘odeSE’ uses an adaptive timestep with the
     ‘integrate_adaptive’ algorithm.  The tolerance for the timestep
     computation may be changed by using the options "RelTol" and
     "AbsTol".

     INIT contains the initial value for the unknowns.  It is a row or
     column vector containing the generalized coordinates in its first
     half and the generalized momenta in the second half.  Each momentum
     correspond to the coordinate with the same relative position inside
     the vector of initial conditions.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘ode12’ will ignore the following options: "BDF", "InitialSlope",
     "Jacobian", "JPattern", "MassSingular", "MaxOrder", "MvPattern",
     "Vectorized".  The user can set extra options by adding fields to
     the structure.  ‘odeSE’ allows for:

     NewtonTol
          the tolerance for the Newton algorithm [Default = 1e-7].

     MaxNewtonIterations
          maximum number of Newton iterations [Default = 100].

     InexactSolver
          the Newton solver.  It can be set to either
          ["newton_raphson"], "inexact_newton" or "fsolve".

     Explicit
          It can be set to either "yes" or ["no].  If the system is
          explicit, the computation will be faster

     If the "inexact_newton" solver is set, a further set of options can
     be provided:

     UseJacobian
          It can be set to either "yes" or ["no].  In the first case,
          the Hamiltonian Hessian, the constraint gradient and the
          constraint Hessian will be used.  If they are not provided,
          they will be approximated by the utility functions
          ‘approx_Hamilt_Hess’, ‘approx_Constr_grad’ and
          ‘approx_Constr_Hess’.

     Eta
          initial forcing term (must be in the interval [0,1)).  The
          dafault value is set to 0.5.  For details see [1].

     Choice
          select the forcing term.  It can be 1 (Default) or 2.  For
          details see [1].

     Algorithm
          iterative method to solve the linearized system.  It can be
          ["gmres"], "pcg" or "bicgstab".

     Restart
          restart parameter for the GMRES solver (ignored for other
          solvers).  [Default = 20].

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was found.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.

     The output can also be returned as a structure SOLUTION which has
     field X containing the time where the solution was evaluated and
     field Y containing the solution matrix for the times in X.  Use
     ‘fieldnames (SOLUTION)’ to see the other fields and additional
     information returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.

     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: odeset, odefwe, inexact_newton.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function is a geometric integrator for Hamilton’s equations of
motion ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
odeSPVI


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5172
 -- Command: [SOL] = odeSPVI (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,
          ...])
 -- Command: [T, Y, [XE, YE, IE]] = odeSPVI (@FUN, SLOT, INIT, [OPT],
          [PAR1, PAR2, ...])

     This function is a geometric integrator for Hamilton’s equations of
     motion that uses the spectral variational integrators method to
     find the new solution, step by step.

     This function can be called with two output arguments: T and Y.
     Variable T is a column vector and contains the time stamps, instead
     Y is a matrix in which each column refers to a different unknown of
     the problem and the rows number is the same of T rows number so
     that each row of Y contains the values of all unknowns at the time
     value contained in the corresponding row in T.

     FUN is a function_handle or an inline function that defines the
     system q' = dH/dp (t,[q;p]) p' = -dH/dq (t,[q;p]), where H(t,[q;p])
     is the Hamiltonian of the problem, q are generalized coordinates
     and p are generalized momenta.  This function must take two input
     arguments: the time and the unknowns.  It must return a vector or a
     cell (if the Hamiltonian Hessian is passed to speedup computations)
     containing as first element the Hamilton’s equations of motion (the
     previous system of equations) and as second element the Hessian of
     the Hamiltonian.

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances through interpolation

     By default, ‘odeSPVI’ uses an adaptive timestep with the
     ‘integrate_adaptive’ algorithm.  The tolerance for the timestep
     computation may be changed by using the options "RelTol" and
     "AbsTol".

     INIT contains the initial value for the unknowns.  It is a row or
     column vector containing the generalized coordinates in its first
     half and the generalized momenta in the second half.  Each momentum
     correspond to the coordinate with the same relative position inside
     the vector of initial conditions.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘ode12’ will ignore the following options: "BDF", "InitialSlope",
     "Jacobian", "JPattern", "MassSingular", "MaxOrder", "MvPattern",
     "Vectorized".  The user can set extra options by adding fields to
     the structure.  ‘odeSPVI’ allows for:

     NewtonTol
          the tolerance for the Newton algorithm [Default = 1e-7].

     MaxNewtonIterations
          maximum number of Newton iterations [Default = 100].

     InexactSolver
          the Newton solver.  It can be set to either
          ["newton_raphson"], "inexact_newton" or "fsolve".

     PolynomialDegree
          The polynomial degree [Default = 1].

     If the "inexact_newton" solver is set, a further set of options can
     be provided:

     UseJacobian
          It can be set to either "yes" or ["no].  In the first case,
          the Hamiltonian Hessian, the constraint gradient and the
          constraint Hessian will be used.  If they are not provided,
          they will be approximated by the utility functions
          ‘approx_Hamilt_Hess’, ‘approx_Constr_grad’ and
          ‘approx_Constr_Hess’.

     Eta
          initial forcing term (must be in the interval [0,1)).  The
          dafault value is set to 0.5.  For details see [1].

     Choice
          select the forcing term.  It can be 1 (Default) or 2.  For
          details see [1].

     Algorithm
          iterative method to solve the linearized system.  It can be
          ["gmres"], "pcg" or "bicgstab".

     Restart
          restart parameter for the GMRES solver (ignored for other
          solvers).  [Default = 20].

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was found.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.

     The output can also be returned as a structure SOLUTION which has
     field X containing the time where the solution was evaluated and
     field Y containing the solution matrix for the times in X.  Use
     ‘fieldnames (SOLUTION)’ to see the other fields and additional
     information returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.

     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: odeset, odefwe, inexact_newton.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function is a geometric integrator for Hamilton’s equations of
motion ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
odeSV


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4876
 -- Function File: [T, Y] = odeSV (FUN, TRANGE, INIT)
 -- Function File: [T, Y] = odeSV (FUN, TRANGE, INIT, ODE_OPT)
 -- Function File: [T, Y] = odeSV (..., PAR1, PAR2, ...)
 -- Function File: [T, Y, TE, YE, IE] = odeSV (...)
 -- Function File: SOLUTION = odeSV (...)

     This function is a geometric integrator for Hamilton’s equations of
     motion that uses the Stormer-Verlet method of order 2.

     FUN is a function_handle or an inline function that defines the
     system q' = dH/dp (t,[q;p]) p' = -dH/dq (t,[q;p]), where H(t,[q;p])
     is the Hamiltonian of the problem, q are generalized coordinates
     and p are generalized momenta.  This function must take two input
     arguments: the time and the unknowns.  It must return a vector or a
     cell (if the Hamiltonian Hessian is passed to speedup computations)
     containing as first element the Hamilton’s equations of motion (the
     previous system of equations) and as second element the Hessian of
     the Hamiltonian.

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances using quadratic interpolation.

     By default, ‘odeSE’ uses an adaptive timestep with the
     ‘integrate_adaptive’ algorithm.  The tolerance for the timestep
     computation may be changed by using the options "RelTol" and
     "AbsTol".

     INIT contains the initial value for the unknowns.  It is a row or
     column vector containing the generalized coordinates in its first
     half and the generalized momenta in the second half.  Each momentum
     correspond to the coordinate with the same relative position inside
     the vector of initial conditions.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘ode12’ will ignore the following options: "BDF", "InitialSlope",
     "Jacobian", "JPattern", "MassSingular", "MaxOrder", "MvPattern",
     "Vectorized".  The user can set extra options by adding fields to
     the structure.  ‘odeSV’ allows for:

     NewtonTol
          the tolerance for the Newton algorithm [Default = 1e-7].

     MaxNewtonIterations
          maximum number of Newton iterations [Default = 100].

     InexactSolver
          the Newton solver.  It can be set to either
          ["newton_raphson"], "inexact_newton" or "fsolve".

     Explicit
          It can be set to either "yes" or ["no].  If the system is
          explicit, the computation will be faster

     If the "inexact_newton" solver is set, a further set of options can
     be provided:

     UseJacobian
          It can be set to either "yes" or ["no].  In the first case,
          the Hamiltonian Hessian, the constraint gradient and the
          constraint Hessian will be used.  If they are not provided,
          they will be approximated by the utility functions
          ‘approx_Hamilt_Hess’, ‘approx_Constr_grad’ and
          ‘approx_Constr_Hess’.

     Eta
          initial forcing term (must be in the interval [0,1)).  The
          dafault value is set to 0.5.  For details see [1].

     Choice
          select the forcing term.  It can be 1 (Default) or 2.  For
          details see [1].

     Algorithm
          iterative method to solve the linearized system.  It can be
          ["gmres"], "pcg" or "bicgstab".

     Restart
          restart parameter for the GMRES solver (ignored for other
          solvers).  [Default = 20].

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was found.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.

     The output can also be returned as a structure SOLUTION which has
     field X containing the time where the solution was evaluated and
     field Y containing the solution matrix for the times in X.  Use
     ‘fieldnames (SOLUTION)’ to see the other fields and additional
     information returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.

     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: odeset, odeRATTLE, odeSE, odeSPVI, odeVV.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function is a geometric integrator for Hamilton’s equations of
motion ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
odeVV


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4790
 -- Command: [SOL] = odeVV (@FUN, TRANGE, INIT, [OPT], [PAR1, PAR2,
          ...])
 -- Command: [T, Y, [XE, YE, IE]] = odeVV (@FUN, TRANGE, INIT, [OPT],
          [PAR1, PAR2, ...])

     This function is a geometric integrator for Newton’s equations of
     motion that uses the Velocity-Verlet method of order 2.

     FUN is a function_handle or an inline function that defines the
     system q' = dH/dp (t,[q;p]) p' = -dH/dq (t,[q;p]), where H(t,[q;p])
     is the Hamiltonian of the problem, q are generalized coordinates
     and p are generalized momenta.  This function must take two input
     arguments: the time and the unknowns.  It must return a vector or a
     cell (if the Hamiltonian Hessian is passed to speedup computations)
     containing as first element the Hamilton’s equations of motion (the
     previous system of equations) and as second element the Hessian of
     the Hamiltonian.

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances using quadratic interpolation.

     By default, ‘odeVV’ uses an adaptive timestep with the
     ‘integrate_adaptive’ algorithm.  The tolerance for the timestep
     computation may be changed by using the options "RelTol" and
     "AbsTol".

     INIT contains the initial value for the unknowns.  It is a row or
     column vector containing the generalized coordinates in its first
     half and the generalized momenta in the second half.  Each momentum
     correspond to the coordinate with the same relative position inside
     the vector of initial conditions.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘ode12’ will ignore the following options: "BDF", "InitialSlope",
     "Jacobian", "JPattern", "MassSingular", "MaxOrder", "MvPattern",
     "Vectorized".  The user can set extra options by adding fields to
     the structure.  ‘odeSV’ allows for:

     NewtonTol
          the tolerance for the Newton algorithm [Default = 1e-7].

     MaxNewtonIterations
          maximum number of Newton iterations [Default = 100].

     InexactSolver
          the Newton solver.  It can be set to either
          ["newton_raphson"], "inexact_newton" or "fsolve".

     Explicit
          It can be set to either "yes" or ["no].  If the system is
          explicit, the computation will be faster

     If the "inexact_newton" solver is set, a further set of options can
     be provided:

     UseJacobian
          It can be set to either "yes" or ["no].  In the first case,
          the Hamiltonian Hessian, the constraint gradient and the
          constraint Hessian will be used.  If they are not provided,
          they will be approximated by the utility functions
          ‘approx_Hamilt_Hess’, ‘approx_Constr_grad’ and
          ‘approx_Constr_Hess’.

     Eta
          initial forcing term (must be in the interval [0,1)).  The
          dafault value is set to 0.5.  For details see [1].

     Choice
          select the forcing term.  It can be 1 (Default) or 2.  For
          details see [1].

     Algorithm
          iterative method to solve the linearized system.  It can be
          ["gmres"], "pcg" or "bicgstab".

     Restart
          restart parameter for the GMRES solver (ignored for other
          solvers).  [Default = 20].

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was found.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.

     The output can also be returned as a structure SOLUTION which has
     field X containing the time where the solution was evaluated and
     field Y containing the solution matrix for the times in X.  Use
     ‘fieldnames (SOLUTION)’ to see the other fields and additional
     information returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.

     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: odeset, odeRATTLE, odeSE, odeSPVI, odeSV.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function is a geometric integrator for Newton’s equations of motion
th...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4034
 -- Function File: [T, Y] = odebwe (FUN, TRANGE, INIT)
 -- Function File: [T, Y] = odebwe (FUN, TRANGE, INIT, ODE_OPT)
 -- Function File: [T, Y] = odebwe (..., PAR1, PAR2, ...)
 -- Function File: [T, Y, TE, YE, IE] = odebwe (...)
 -- Function File: SOLUTION = odebwe (...)

     Solve a set of Ordinary Differential Equations with the well known
     implicit Backward-Euler method of order 1.  The method is indicated
     both for stiff and non–stiff problems.

     FUN is a function handle, inline function, or string containing the
     name of the function that defines the ODE: ‘y' = f(t,y)’.  The
     function must accept two inputs where the first is time T and the
     second is a column vector of unknowns Y.

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances using linear interpolation.

     INIT contains the initial value for the unknowns.  If it is a row
     vector then the solution Y will be a matrix in which each column is
     the solution for the corresponding initial value in INIT.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘odebwe’ will ignore the following options: "BDF", "InitialSlope",
     "MassSingular", "MaxOrder", "MvPattern", "NonNegative".  The user
     can set extra options by adding fields to the structure.  ‘odebwe’
     allows for:

     NewtonTol
          the tolerance for the Newton algorithm [Default = 1e-7].

     MaxNewtonIterations
          maximum number of Newton iterations [Default = 100].

     InexactSolver
          the Newton solver.  It can be set to either
          ["newton_raphson"], "inexact_newton" or "fsolve".

     If the "inexact_newton" solver is set, a further set of options can
     be provided:

     UseJacobian
          specify if the Jacobian information should be used.  It can be
          set to either "yes" or ["no].

     Eta
          initial forcing term (must be in the interval [0,1)).  The
          dafault value is set to 0.5.  For details see [1].

     Choice
          select the forcing term.  It can be 1 (Default) or 2.  For
          details see [1].

     Algorithm
          iterative method to solve the linearized system.  It can be
          ["gmres"], "pcg" or "bicgstab".

     Restart
          restart parameter for the GMRES solver (ignored for other
          solvers).  [Default = 20].

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was found.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.

     The output can also be returned as a structure SOLUTION which has
     field X containing the time where the solution was evaluated and
     field Y containing the solution matrix for the times in X.  Use
     ‘fieldnames (SOLUTION)’ to see the other fields and additional
     information returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.

     For example, solve an anonymous implementation of the Van der Pol
     equation

          fvdp = @(T,Y) [Y(2); (1 - Y(1)^2) * Y(2) - Y(1)];
          [T,Y] = odebwe (fvdp, [0, 2], [2, 0]);

     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: odeset, odefwe, inexact_newton.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Solve a set of Ordinary Differential Equations with the well known
implicit B...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
odeexamples


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 168
 -- Function File: [] = odeexamples ()

     Open the differential equations examples menu and allow the user to
     select a submenu of ODE, DAE, IDE or DDE examples.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Open the differential equations examples menu and allow the user to
select a ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3054
 -- Function File: [T, Y] = odefwe (FUN, TRANGE, INIT)
 -- Function File: [T, Y] = odefwe (FUN, TRANGE, INIT, ODE_OPT)
 -- Function File: [T, Y] = odefwe (..., PAR1, PAR2, ...)
 -- Function File: [T, Y, TE, YE, IE] = odefwe (...)
 -- Function File: SOLUTION = odefwe (...)

     Solve a set of non-stiff Ordinary Differential Equations (non-stiff
     ODEs) with the well known explicit Forward-Euler method of order 1.

     FUN is a function handle, inline function, or string containing the
     name of the function that defines the ODE: ‘y' = f(t,y)’.  The
     function must accept two inputs where the first is time T and the
     second is a column vector of unknowns Y.

     TRANGE specifies the time interval over which the ODE will be
     evaluated.  Typically, it is a two-element vector specifying the
     initial and final times (‘[tinit, tfinal]’).  If there are more
     than two elements then the solution will also be evaluated at these
     intermediate time instances using an interpolation procedure of the
     same order as the one of the solver.

     By default, ‘odefwe’ uses an adaptive timestep with the
     ‘integrate_adaptive’ algorithm.  The tolerance for the timestep
     computation may be changed by using the options "RelTol" and
     "AbsTol".

     INIT contains the initial value for the unknowns.  If it is a row
     vector then the solution Y will be a matrix in which each column is
     the solution for the corresponding initial value in INIT.

     The optional fourth argument ODE_OPT specifies non-default options
     to the ODE solver.  It is a structure generated by ‘odeset’.
     ‘odefwe’ will ignore the following options: "BDF", "InitialSlope",
     "Jacobian", "JPattern", "MassSingular", "MaxOrder", "MvPattern",
     "Vectorized".

     The function typically returns two outputs.  Variable T is a column
     vector and contains the times where the solution was computed.  The
     output Y is a matrix in which each column refers to a different
     unknown of the problem and each row corresponds to a time in T.  If
     TRANGE specifies intermediate time steps, only those will be
     returned.

     The output can also be returned as a structure SOLUTION which has a
     field X containing a row vector of times where the solution was
     evaluated and a field Y containing the solution matrix such that
     each column corresponds to a time in X.  Use ‘fieldnames
     (SOLUTION)’ to see the other fields and additional information
     returned.

     If using the "Events" option then three additional outputs may be
     returned.  TE holds the time when an Event function returned a
     zero.  YE holds the value of the solution at time TE.  IE contains
     an index indicating which Event function was triggered in the case
     of multiple Event functions.

     Example: Solve the Van der Pol equation

          fvdp = @(T,Y) [Y(2); (1 - Y(1)^2) * Y(2) - Y(1)];
          [T,Y] = odefwe (fvdp, [0 20], [2 0]);

     See also: odeset, odebwe.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Solve a set of non-stiff Ordinary Differential Equations (non-stiff
ODEs) wit...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1631
 -- Function File: [RET] = odephas2 (T, Y, FLAG)

     Open a new figure window and plot the first result from the
     variable Y that is of type double column vector over the second
     result from the variable Y while solving.  The types and the values
     of the input parameter T and the output parameter RET depend on the
     input value FLAG that is of type string.  If FLAG is

     ‘"init"’
          then T must be a double column vector of length 2 with the
          first and the last time step and nothing is returned from this
          function.

     ‘""’
          then T must be a double scalar specifying the actual time step
          and the return value is false (resp.  value 0) for ’not stop
          solving’.

     ‘"done"’
          then T must be a double scalar specifying the last time step
          and nothing is returned from this function.

     This function is called by a OdePkg solver function if it was
     specified in an OdePkg options structure with the ‘odeset’.  This
     function is an OdePkg internal helper function therefore it should
     never be necessary that this function is called directly by a user.
     There is only little error detection implemented in this function
     file to achieve the highest performance.

     Example: Solve the Van der Pol equation and display the results
     while solving in a 2D plane
          fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];

          vopt = odeset ('OutputFcn', @odephas2, 'RelTol', 1e-6);
          vsol = ode45 (fvdb, [0 20], [2 0], vopt);

     See also: odeset, odeplot, odephas3.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Open a new figure window and plot the first result from the variable Y
that i...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1763
 -- Function File: [RET] = odephas3 (T, Y, FLAG)

     Open a new figure window and plot the first result from the
     variable Y that is of type double column vector over the second and
     the third result from the variable Y while solving.  The types and
     the values of the input parameter T and the output parameter RET
     depend on the input value FLAG that is of type string.  If FLAG is

     ‘"init"’
          then T must be a double column vector of length 2 with the
          first and the last time step and nothing is returned from this
          function.

     ‘""’
          then T must be a double scalar specifying the actual time step
          and the return value is false (resp.  value 0) for ’not stop
          solving’.

     ‘"done"’
          then T must be a double scalar specifying the last time step
          and nothing is returned from this function.

     This function is called by a OdePkg solver function if it was
     specified in an OdePkg options structure with the ‘odeset’.  This
     function is an OdePkg internal helper function therefore it should
     never be necessary that this function is called directly by a user.
     There is only little error detection implemented in this function
     file to achieve the highest performance.

     Example: Solve the Van der Pol equation and display the results
     while solving in a 3D plane
          function vyd = florenz (vt, vx)
            vyd = [10 * (vx(2) - vx(1));
                   vx(1) * (28 - vx(3));
                   vx(1) * vx(2) - 8/3 * vx(3)];
          end

          vopt = odeset ('OutputFcn', @odephas3);
          vsol = ode23 (@florenz, [0:0.01:7.5], [3 15 1], vopt);

     See also: odeset, odeplot, odephas2.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Open a new figure window and plot the first result from the variable Y
that i...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 669
 -- Function File: [] = odepkg ()

     OdePkg is part of the GNU Octave Repository (the Octave–Forge
     project).  The package includes commands for setting up various
     options, output functions etc.  before solving a set of
     differential equations with the solver functions that are also
     included.  At this time OdePkg is under development with the main
     target to make a package that is mostly compatible to proprietary
     solver products.

     If this function is called without any input argument then open the
     OdePkg tutorial in the Octave window.  The tutorial can also be
     opened with the following command

          doc odepkg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
OdePkg is part of the GNU Octave Repository (the Octave–Forge project).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
odepkg_examples_dae


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 143
 -- Function File: [] = odepkg_examples_dae ()
     Open the DAE examples menu and allow the user to select a demo that
     will be evaluated.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Open the DAE examples menu and allow the user to select a demo that will
be e...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
odepkg_examples_dde


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 143
 -- Function File: [] = odepkg_examples_dde ()
     Open the DDE examples menu and allow the user to select a demo that
     will be evaluated.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Open the DDE examples menu and allow the user to select a demo that will
be e...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
odepkg_examples_ide


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 143
 -- Function File: [] = odepkg_examples_ide ()
     Open the IDE examples menu and allow the user to select a demo that
     will be evaluated.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Open the IDE examples menu and allow the user to select a demo that will
be e...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
odepkg_examples_ode


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 143
 -- Function File: [] = odepkg_examples_ode ()
     Open the ODE examples menu and allow the user to select a demo that
     will be evaluated.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Open the ODE examples menu and allow the user to select a demo that will
be e...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
odepkg_testsuite_calcmescd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 888
 -- Function File: [MESCD] = odepkg_testsuite_calcmescd (SOLUTION,
          REFERENCE, ABSTOL, RELTOL)

     If this function is called with four input arguments of type double
     scalar or column vector then return a normalized value for the
     minimum number of correct digits MESCD that is calculated from the
     solution at the end of an integration interval SOLUTION and a set
     of reference values REFERENCE.  The input arguments ABSTOL and
     RELTOL are used to calculate a reference solution that depends on
     the relative and absolute error tolerances.

     Run examples with the command
          demo odepkg_testsuite_calcmescd

     This function has been ported from the "Test Set for IVP solvers"
     which is developed by the INdAM Bari unit project group "Codes and
     Test Problems for Differential Equations", coordinator F. Mazzia.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
If this function is called with four input arguments of type double
scalar or...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
odepkg_testsuite_calcscd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 875
 -- Function File: [SCD] = odepkg_testsuite_calcscd (SOLUTION,
          REFERENCE, ABSTOL, RELTOL)

     If this function is called with four input arguments of type double
     scalar or column vector then return a normalized value for the
     minimum number of correct digits SCD that is calculated from the
     solution at the end of an integration interval SOLUTION and a set
     of reference values REFERENCE.  The input arguments ABSTOL and
     RELTOL are unused but present because of compatibility to the
     function ‘odepkg_testsuite_calcmescd’.

     Run examples with the command
          demo odepkg_testsuite_calcscd

     This function has been ported from the "Test Set for IVP solvers"
     which is developed by the INdAM Bari unit project group "Codes and
     Test Problems for Differential Equations", coordinator F. Mazzia.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
If this function is called with four input arguments of type double
scalar or...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
odepkg_testsuite_chemakzo


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 834
 -- Function File: [SOLUTION] = odepkg_testsuite_chemakzo (@SOLVER,
          RELTOL)

     If this function is called with two input arguments and the first
     input argument @SOLVER is a function handle describing an OdePkg
     solver and the second input argument RELTOL is a double scalar
     describing the relative error tolerance then return a cell array
     SOLUTION with performance informations about the chemical AKZO
     Nobel testsuite of differential algebraic equations after solving
     (DAE–test).

     Run examples with the command
          demo odepkg_testsuite_chemakzo

     This function has been ported from the "Test Set for IVP solvers"
     which is developed by the INdAM Bari unit project group "Codes and
     Test Problems for Differential Equations", coordinator F. Mazzia.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
If this function is called with two input arguments and the first input
argum...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
odepkg_testsuite_hires


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 798
 -- Function File: [SOLUTION] = odepkg_testsuite_hires (@SOLVER, RELTOL)

     If this function is called with two input arguments and the first
     input argument @SOLVER is a function handle describing an OdePkg
     solver and the second input argument RELTOL is a double scalar
     describing the relative error tolerance then return a cell array
     SOLUTION with performance informations about the HIRES testsuite of
     ordinary differential equations after solving (ODE–test).

     Run examples with the command
          demo odepkg_testsuite_hires

     This function has been ported from the "Test Set for IVP solvers"
     which is developed by the INdAM Bari unit project group "Codes and
     Test Problems for Differential Equations", coordinator F. Mazzia.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
If this function is called with two input arguments and the first input
argum...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
odepkg_testsuite_implakzo


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 843
 -- Function File: [SOLUTION] = odepkg_testsuite_implakzo (@SOLVER,
          RELTOL)

     If this function is called with two input arguments and the first
     input argument @SOLVER is a function handle describing an OdePkg
     solver and the second input argument RELTOL is a double scalar
     describing the relative error tolerance then return a cell array
     SOLUTION with performance informations about the chemical AKZO
     Nobel testsuite of implicit differential algebraic equations after
     solving (IDE–test).

     Run examples with the command
          demo odepkg_testsuite_implakzo

     This function has been ported from the "Test Set for IVP solvers"
     which is developed by the INdAM Bari unit project group "Codes and
     Test Problems for Differential Equations", coordinator F. Mazzia.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
If this function is called with two input arguments and the first input
argum...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
odepkg_testsuite_implrober


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 865
 -- Function File: [SOLUTION] = odepkg_testsuite_implrober (@SOLVER,
          RELTOL)

     If this function is called with two input arguments and the first
     input argument @SOLVER is a function handle describing an OdePkg
     solver and the second input argument RELTOL is a double scalar
     describing the relative error tolerance then return a cell array
     SOLUTION with performance informations about the implicit form of
     the modified ROBERTSON testsuite of implicit differential algebraic
     equations after solving (IDE–test).

     Run examples with the command
          demo odepkg_testsuite_implrober

     This function has been ported from the "Test Set for IVP solvers"
     which is developed by the INdAM Bari unit project group "Codes and
     Test Problems for Differential Equations", coordinator F. Mazzia.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
If this function is called with two input arguments and the first input
argum...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
odepkg_testsuite_impltrans


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 838
 -- Function File: [SOLUTION] = odepkg_testsuite_impltrans (@SOLVER,
          RELTOL)

     If this function is called with two input arguments and the first
     input argument @SOLVER is a function handle describing an OdePkg
     solver and the second input argument RELTOL is a double scalar
     describing the relative error tolerance then return the cell array
     SOLUTION with performance informations about the TRANSISTOR
     testsuite of implicit differential algebraic equations after
     solving (IDE–test).

     Run examples with the command
          demo odepkg_testsuite_impltrans

     This function has been ported from the "Test Set for IVP solvers"
     which is developed by the INdAM Bari unit project group "Codes and
     Test Problems for Differential Equations", coordinator F. Mazzia.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
If this function is called with two input arguments and the first input
argum...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
odepkg_testsuite_oregonator


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 828
 -- Function File: [SOLUTION] = odepkg_testsuite_oregonator (@SOLVER,
          RELTOL)

     If this function is called with two input arguments and the first
     input argument @SOLVER is a function handle describing an OdePkg
     solver and the second input argument RELTOL is a double scalar
     describing the relative error tolerance then return a cell array
     SOLUTION with performance informations about the OREGONATOR
     testsuite of ordinary differential equations after solving
     (ODE–test).

     Run examples with the command
          demo odepkg_testsuite_oregonator

     This function has been ported from the "Test Set for IVP solvers"
     which is developed by the INdAM Bari unit project group "Codes and
     Test Problems for Differential Equations", coordinator F. Mazzia.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
If this function is called with two input arguments and the first input
argum...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
odepkg_testsuite_pollution


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 827
 -- Function File: [SOLUTION] = odepkg_testsuite_pollution (@SOLVER,
          RELTOL)

     If this function is called with two input arguments and the first
     input argument @SOLVER is a function handle describing an OdePkg
     solver and the second input argument RELTOL is a double scalar
     describing the relative error tolerance then return the cell array
     SOLUTION with performance informations about the POLLUTION
     testsuite of ordinary differential equations after solving
     (ODE–test).

     Run examples with the command
          demo odepkg_testsuite_pollution

     This function has been ported from the "Test Set for IVP solvers"
     which is developed by the INdAM Bari unit project group "Codes and
     Test Problems for Differential Equations", coordinator F. Mazzia.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
If this function is called with two input arguments and the first input
argum...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
odepkg_testsuite_robertson


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 835
 -- Function File: [SOLUTION] = odepkg_testsuite_robertson (@SOLVER,
          RELTOL)

     If this function is called with two input arguments and the first
     input argument @SOLVER is a function handle describing an OdePkg
     solver and the second input argument RELTOL is a double scalar
     describing the relative error tolerance then return a cell array
     SOLUTION with performance informations about the modified ROBERTSON
     testsuite of differential algebraic equations after solving
     (DAE–test).

     Run examples with the command
          demo odepkg_testsuite_robertson

     This function has been ported from the "Test Set for IVP solvers"
     which is developed by the INdAM Bari unit project group "Codes and
     Test Problems for Differential Equations", coordinator F. Mazzia.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
If this function is called with two input arguments and the first input
argum...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
odepkg_testsuite_transistor


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 831
 -- Function File: [SOLUTION] = odepkg_testsuite_transistor (@SOLVER,
          RELTOL)

     If this function is called with two input arguments and the first
     input argument @SOLVER is a function handle describing an OdePkg
     solver and the second input argument RELTOL is a double scalar
     describing the relative error tolerance then return the cell array
     SOLUTION with performance informations about the TRANSISTOR
     testsuite of differential algebraic equations after solving
     (DAE–test).

     Run examples with the command
          demo odepkg_testsuite_transistor

     This function has been ported from the "Test Set for IVP solvers"
     which is developed by the INdAM Bari unit project group "Codes and
     Test Problems for Differential Equations", coordinator F. Mazzia.

See also: odepkg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
If this function is called with two input arguments and the first input
argum...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1723
 -- Function File: [RET] = odeprint (T, Y, FLAG)

     Display the results of the set of differential equations in the
     Octave window while solving.  The first column of the screen output
     shows the actual time stamp that is given with the input arguemtn
     T, the following columns show the results from the function
     evaluation that are given by the column vector Y.  The types and
     the values of the input parameter T and the output parameter RET
     depend on the input value FLAG that is of type string.  If FLAG is

     ‘"init" then T must be a double column vector of length 2’
          with the first and thelast time step and nothing is returned
          from this function,

     ‘""’
          then T must be a double scalar specifying the actual time step
          and the return value is false (resp.  value 0) for ’not stop
          solving’,

     ‘"done" then T must be a double scalar specifying the’
          last time step and nothing is returned from this function.

     This function is called by a OdePkg solver function if it was
     specified in an OdePkg options structure with the ‘odeset’.  This
     function is an OdePkg internal helper function therefore it should
     never be necessary that this function is called directly by a user.
     There is only little error detection implemented in this function
     file to achieve the highest performance.

     Example: Solve the Van der Pol equation and print the results while
     solving

          fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
          vopt = odeset ('OutputFcn', @odeprint, 'RelTol', 1e-6);
          vsol = ode45 (fvdb, [0 20], [2 0], vopt);

See also: odeplot.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Display the results of the set of differential equations in the Octave
window...





