--- /dev/null
+Dies ist odepkg.info, hergestellt von Makeinfo Version 4.8 aus
+odepkg.texi.
+
+\1f
+File: odepkg.info, Node: Top, Next: Beginners Guide, Prev: (dir), Up: (dir)
+
+Copyright
+*********
+
+Copyright (C) 2006-2012, Thomas Treichl
+
+ Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+ Permission is granted to copy and distribute modified versions of
+this manual under the conditions for verbatim copying, provided that
+the entire resulting derived work is distributed under the terms of a
+permission notice identical to this one.
+
+ Permission is granted to copy and distribute translations of this
+manual into another language, under the same conditions as for modified
+versions.
+
+* Menu:
+
+* Beginners Guide:: Manual for users who are completely new to OdePkg
+* Users Guide:: Manual for users who are already familiar with OdePkg
+* Programmers Guide:: Manual for users who want to make changes to OdePkg
+* Function Index:: Reference about all functions from this package
+* Index:: OdePkg Reference
+
+\1f
+File: odepkg.info, Node: Beginners Guide, Next: Users Guide, Prev: Top, Up: Top
+
+1 Beginners Guide
+*****************
+
+The "Beginners Guide" is intended for users who are new to OdePkg and
+who want to solve differential equations with the Octave language and
+the package OdePkg. In this section it will be explained what OdePkg is
+about in *Note About OdePkg:: and how OdePkg grew up from the beginning
+in *Note OdePkg history and roadmap::. In *Note Installation and
+deinstallation:: it is explained how OdePkg can be installed in Octave
+and how it can later be removed from Octave if it is not needed
+anymore. If you encounter problems while using OdePkg then have a look
+at *Note Reporting Bugs:: how these bugs can be reported. In the *Note
+The "foo" example:: a first example is explained.
+
+* Menu:
+
+* About OdePkg:: An introduction about OdePkg
+* OdePkg history and roadmap:: From the first OdePkg release to the future
+* Installation and deinstallation:: Setting up OdePkg on your system
+* Reporting Bugs:: Writing comments and bugs to the help list
+* The "foo" example:: A first example and where to go from here
+
+\1f
+File: odepkg.info, Node: About OdePkg, Next: OdePkg history and roadmap, Prev: Beginners Guide, Up: Beginners Guide
+
+1.1 About OdePkg
+================
+
+OdePkg is part of the Octave Repository (resp. the Octave-Forge
+project) that was initiated by Matthew W. Roberts and Paul Kienzle in
+the year 2000 and that is hosted at `http://octave.sourceforge.net'.
+Since then a lot of contributors joined this project and added a lot
+more packages and functions to further extend the capabilities of GNU
+Octave.
+
+ OdePkg includes commands for setting up various options, output
+functions etc. before solving a set of differential equations with the
+solver functions that are included. The package formerly was initiated
+in autumn 2006 to solve ordinary differential equations (ODEs) only but
+there are already improvements so that differential algebraic equations
+(DAEs) in explicit form and in implicit form (IDEs) and delay
+differential equations (DDEs) can also be solved. The goal of OdePkg is
+to have a package for solving differential equations that is mostly
+compatible to proprietary solver products.
+
+\1f
+File: odepkg.info, Node: OdePkg history and roadmap, Next: Installation and deinstallation, Prev: About OdePkg, Up: Beginners Guide
+
+1.2 OdePkg history and roadmap
+==============================
+
+OdePkg Version The initial release was a modification of the old
+0.0.1 "ode" package that is hosted at Octave-Forge and that
+ was written by Marc Compere somewhen between 2000 and
+ 2001. The four variable step-size Runge-Kutta
+ algorithms in three solver files and the three fixed
+ step-size solvers have been merged. It was possible
+ to set some options for these solvers. The four
+ output-functions (`odeprint', `odeplot', `odephas2'
+ and `odephas3') have been added along with other
+ examples that initially have not been there.
+OdePkg Version The major milestone along versions 0.1.x was that
+0.1.x four stable solvers have been implemented (ie.
+ `ode23', `ode45', `ode54' and `ode78') supporting all
+ options that can be set for these kind of solvers and
+ also all necessary functions for setting their
+ options (eg. `odeset', `odepkg_structure_check,
+ odepkg_event_handle'). Since version 0.1.3 there is
+ also source code available that interfaces the
+ Fortran solver `dopri5.f' (that is written by Ernst
+ Hairer and Gerhard Wanner, cf.
+ `odepkg_mexsolver_dopri5.c' and the helper files
+ `odepkgext.c' and `odepkgmex.c').
+OdePkg Version The main work along version 0.2.x was to make the
+0.2.x interface functions for the non-stiff and stiff
+ solvers from Ernst Hairer and Gerhard Wanner enough
+ stable so that they could be compiled and installed
+ by default. Wrapper functions have been added to the
+ package containing a help text and test functions
+ (eg. `ode2r', `ode5r', `oders'). Six testsuite
+ functions have been added to check the performance of
+ the different solvers (eg.
+ `odepkg_testsuite_chemakzo',
+ `odepkg_testsuite_oregonator').
+OdePkg Version Fixed some minor bugs along version 0.3.x. Thanks to
+0.3.x Jeff Cash, who released his Fortran `mebdfX' solvers
+ under the GNU GPL V2 after some discussion. The first
+ IDE solver `odebdi' appeared that is an interface
+ function for Cash's `mebdfi' Fortran core solver.
+ With version 0.3.5 of OdePkg a first new interface
+ function was created based on Octave's C++
+ `DEFUN_DLD' interface to achieve the highest
+ performance available. Added more examples and
+ testsuite functions (eg. `odepkg_equations_ilorenz',
+ `odepkg_testsuite_implrober'). Porting all at this
+ time present Mex-file solvers to Octave's C++
+ `DEFUN_DLD' interface. Ongoing work with this manual.
+OdePkg Version Added a new solver function `odekdi' for the direct
+0.4.x method (not the Krylov method) of the `daskr.f'
+ solver from the authors Peter N. Brown, Alan C.
+ Hindmarsh, Linda R. Petzold and Clement W. Ulrich
+ that is available under a modified BSD license
+ (without advertising clause). Ongoing work with this
+ manual.
+OdePkg Version Added new solver functions `ode23d', `ode45d',
+0.5.x `ode54d' and `ode78d' for solving non-stiff delay
+ differential equations (non-stiff DDEs). These
+ solvers are based on the Runge-Kutta solvers
+ `ode23'..`ode78'. Tests and demos have been included
+ for this type of solvers. Added new functions
+ `odeexamples', `odepkg_examples_ode',
+ `odepkg_examples_dae', `odepkg_examples_ide' and
+ `odepkg_examples_ide'. Ongoing work with this manual.
+OdePkg Version A lot of compatibility tests, improvements, bugfixes,
+0.6.x etc.
+(current) Version Final releases before version 1.0.0.
+0.8.x
+(future) Version Completed OdePkg release 1.0.0 with M-solvers and
+1.0.0 DLD-solvers.
+
+\1f
+File: odepkg.info, Node: Installation and deinstallation, Next: Reporting Bugs, Prev: OdePkg history and roadmap, Up: Beginners Guide
+
+1.3 Installation and deinstallation
+===================================
+
+OdePkg can be installed easily using the `pkg' command in Octave. To
+install OdePkg download the latest release of OdePkg from the
+Octave-Forge download site, then get into that directory where the
+downloaded release of OdePkg has been saved, start Octave and type
+ pkg install odepkg-x.x.x.tar.gz
+ where `x.x.x' in the name of the `*.tar.gz' file is the current
+release number of OdePkg that is available. If you want to deinstall
+resp. remove OdePkg then simply type
+ pkg uninstall odepkg
+ and make sure that OdePkg has been removed completely and does not
+appear in the list of installed packages anymore with the following
+command
+ pkg list
+
+\1f
+File: odepkg.info, Node: Reporting Bugs, Next: The "foo" example, Prev: Installation and deinstallation, Up: Beginners Guide
+
+1.4 Reporting Bugs
+==================
+
+If you encounter problems during the installation process of OdePkg
+with the `pkg' command or if you have an OdePkg that seems to be broken
+or if you encounter problems while using OdePkg or if you find bugs in
+the source codes then please report all of that via email at the
+Octave-Forge mailing-list using the email address
+<octave-dev@lists.sourceforge.net>. Not only bugs are welcome but also
+any kind of comments are welcome (eg. if you think that OdePkg is
+absolutely useful or even unnecessary).
+
+\1f
+File: odepkg.info, Node: The "foo" example, Prev: Reporting Bugs, Up: Beginners Guide
+
+1.5 The "foo" example
+=====================
+
+Have a look at the first ordinary differential equation with the name
+"`foo'". The `foo' equation of second order may be of the form y"(t) +
+C_1 y'(t) + C_2 y(t) = C_3. With the substitutions y_1(t) = y(t) and
+y_2(t) = y'(t) this differential equation of second order can be split
+into two differential equations of first order, ie. y'_1(t) = y_2(t)
+and y'_2(t) = - C_1 y_2(t) - C_2 y_1(t) + C_3. Next the numerical
+values for the constants need to be defined, ie. C_1 = 2.0, C_2 = 5.0,
+C_3 = 10.0. This set of ordinary differential equations can then be
+written as an Octave M-file function like
+ function vdy = foo (vt, vy, varargin)
+ vdy(1,1) = vy(2);
+ vdy(2,1) = - 2.0 * vy(2) - 5.0 * vy(1) + 10.0;
+ endfunction
+ It can be seen that this ODEs do not depend on time, nevertheless
+the first input argument of this function needs to be defined as the
+time argument VT followed by a solution array argument `vy' as the
+second input argument and a variable size input argument `varargin'
+that can be used to set up user defined constants or control variables.
+
+ As it is known that `foo' is a set of ordinary differential
+equations we can choose one of the four Runge-Kutta solvers (cf. *Note
+Solver families::). It is also known that the time period of interest
+may be between t_0 = 0.0 and t_e = 5.0 as well as that the initial
+values of the ODEs are y_1(t=0) = 0.0 and y_2(t=0) = 0.0. Solving this
+set of ODEs can be done by typing the following commands in Octave
+ ode45 (@foo, [0 5], [0 0]);
+ A figure window opens and it can be seen how this ODEs are solved
+over time. For some of the solvers that come with OdePkg it is possible
+to define exact time stamps for which an solution is required. Then the
+example can be called eg.
+ ode45 (@foo, [0:0.1:5], [0 0]);
+ If it is not wanted that a figure window is opened while solving
+then output arguments have to be used to catch the results of the
+solving process and to not pass the results to the figure window, eg.
+ [t, y] = ode45 (@foo, [0 5], [0 0]);
+ Results can also be obtained in form of an Octave structure if one
+output argument is used like in the following example. Then the results
+are stored in the fields `S.x' and `S.y'.
+ S = ode45 (@foo, [0 5], [0 0]);
+ As noticed before, a function for the ordinary differential
+equations must not be rewritten all the time if some of the parameters
+are going to change. That's what the input argument `varargin' can be
+used for. So rewrite the function `foo' into `newfoo' the following way
+ function vdy = newfoo (vt, vy, varargin)
+ vdy(1,1) = vy(2);
+ vdy(2,1) = -varargin{1}*vy(2)-varargin{2}*vy(1)+varargin{3};
+ endfunction
+ There is nothing said anymore about the constant values but if using
+the following caller routine in the Octave window then the same results
+can be obtained with the new function `newfoo' as before with the
+function `foo' (ie. the parameters are directly feed through from the
+caller routine `ode45' to the function `newfoo')
+ ode45 (@newfoo, [0 5], [0 0], 2.0, 5.0, 10.0);
+ OdePkg can do much more while solving differential equations, eg.
+setting up other output functions instead of the function `odeplot' or
+setting up other tolerances for the solving process etc. As a last
+example in this beginning chapter it is shown how this can be done, ie.
+with the command `odeset'
+ A = odeset ('OutputFcn', @odeprint);
+ ode45 (@newfoo, [0 5], [0 0], A, 2.0, 5.0, 10.0);
+ or
+ A = odeset ('OutputFcn', @odeprint, 'AbsTol', 1e-5, \
+ 'RelTol', 1e-5, 'NormControl', 'on');
+ ode45 (@newfoo, [0 5], [0 0], A, 2.0, 5.0, 10.0);
+ The options structure `A' that can be set up with with the command
+`odeset' must always be the fourth input argument when using the ODE
+solvers and the DAE solvers but if you are using an IDE solver then `A'
+must be the fifth input argument (cf. *Note Solver families::). The
+various options that can be set with the command `odeset' are described
+in *Note ODE/DAE/IDE/DDE options::.
+
+ Further examples have also been implemented. These example files and
+functions are of the form `odepkg_examples_*'. Different testsuite
+examples have been added that are stored in files with filenames
+`odepkg_testsuite_*'. Before reading the next chapter note that nearly
+every function that comes with OdePkg has its own help text and its own
+examples. Look for yourself how the different functions, options and
+combinations can be used. If you want to have a look at the help
+description of a special function then type
+ help fcnname
+ in the Octave window where `fcnname' is the name of the function for
+the help text to be viewed. Type
+ demo fcnname
+ in the Octave window where `fcnname' is the name of the function for
+the demo to run. Finally write
+ doc odepkg
+ for opening this manual in the texinfo reader of the Octave window.
+
+\1f
+File: odepkg.info, Node: Users Guide, Next: Programmers Guide, Prev: Beginners Guide, Up: Top
+
+2 Users Guide
+*************
+
+The "Users Guide" is intended for trained users who already know in
+principal how to solve differential equations with the Octave language
+and OdePkg. In this chapter it will be explained which equations can be
+solved with OdePkg in *Note Differential Equations::. It will be
+explained which solvers can be used for the different kind of equations
+in *Note Solver families:: and which options can be set for the
+optimization of the solving process in *Note ODE/DAE/IDE/DDE options::.
+The help text of all M-file functions and all Oct-file functions have
+been extracted and are displayed in the sections *Note M-File Function
+Reference:: and *Note Oct-File Function Reference::.
+
+* Menu:
+
+* Differential Equations:: The different kind of problems that can be solved with OdePkg
+* Solver families:: The different kind of solvers within OdePkg
+* ODE/DAE/IDE/DDE options:: The options that can be set for a solving process
+* M-File Function Reference:: The description about all `*.m'-file functions
+* Oct-File Function Reference:: The description about all DLD-functions from `*.oct'-files
+
+\1f
+File: odepkg.info, Node: Differential Equations, Next: Solver families, Prev: Users Guide, Up: Users Guide
+
+2.1 Differential Equations
+==========================
+
+In this section the different kind of differential equations that can
+be solved with OdePkg are explained. The formulation of ordinary
+differential equations is described in section *Note ODE equations::
+followed by the description of explicetly formulated differential
+algebraic equations in section *Note DAE equations::, implicetely
+formulated differential algebraic equations in section *Note IDE
+equations:: and delay differential algebraic equations in section *Note
+DDE equations::.
+
+* Menu:
+
+* ODE equations:: Ordinary differential equations
+* DAE equations:: Differential algebraic equations in explicit form
+* IDE equations:: Differential algebraic equations in implicit form
+* DDE equations:: Delay differential equations
+
+\1f
+File: odepkg.info, Node: ODE equations, Next: DAE equations, Prev: Differential Equations, Up: Differential Equations
+
+2.1.1 ODE equations
+-------------------
+
+ODE equations in general are of the form y'(t) = f(t,y) where y'(t) may
+be a scalar or vector of derivatives. The variable t always is a scalar
+describing one point of time and the variable y(t) is a scalar or
+vector of solutions from the last time step of the set of ordinary
+differential equations. If the equation is non-stiff then the *Note
+Runge-Kutta solvers:: can be used to solve such kind of differential
+equations but if the equation is stiff then it is recommended to use
+the *Note Hairer-Wanner solvers::. An ODE equation definition in Octave
+must look like
+ function [dy] = ODEequation (t, y, varargin)
+
+\1f
+File: odepkg.info, Node: DAE equations, Next: IDE equations, Prev: ODE equations, Up: Differential Equations
+
+2.1.2 DAE equations
+-------------------
+
+DAE equations in general are of the form M(t,y) \cdot y'(t) = f(t,y)
+where y'(t) may be a scalar or vector of derivatives. The variable t
+always is a scalar describing one point of time and the variable y(t)
+is a scalar or vector of solutions from the set of differential
+algebraic equations. The variable M(t,y) is the squared singular mass
+matrix that may depend on y and t. If M(t,y) is not singular then the
+set of equations from above can normally also be written as an ODE
+equation. If it does not depend on time then it can be defined as a
+constant matrix or a function. If it does depend on time then it must
+be defined as a function. Use the command `odeset' to pass the mass
+matrix information to the solver function (cf. *Note ODE/DAE/IDE/DDE
+options::). If the equation is non-stiff then the *Note Runge-Kutta
+solvers:: can be used to solve such kind of differential equations but
+if the equation is stiff then it is recommended to use the *Note
+Hairer-Wanner solvers::. A DAE equation definition in Octave must look
+like
+ function [dy] = DAEequation (t, y, varargin)
+ and the mass matrix definition can either be a constant mass matrix
+or a valid function handle to a mass matrix calculation function that
+can be set with the command `odeset' (cf. option `Mass' of section
+*Note ODE/DAE/IDE/DDE options::).
+
+\1f
+File: odepkg.info, Node: IDE equations, Next: DDE equations, Prev: DAE equations, Up: Differential Equations
+
+2.1.3 IDE equations
+-------------------
+
+IDE equations in general are of the form y'(t) + f(t,y) = 0 where y'(t)
+may be a scalar or vector of derivatives. The variable t always is a
+scalar describing one point of time and the variable y(t) is a scalar
+or vector of solutions from the set of implicit differential equations.
+Only IDE solvers from section *Note Cash modified BDF solvers:: or
+section *Note DDaskr direct method solver:: can be used to solve such
+kind of differential equations. A DAE equation definition in Octave
+must look like
+ function [residual] = IDEequation (t, y, dy, varargin)
+
+\1f
+File: odepkg.info, Node: DDE equations, Prev: IDE equations, Up: Differential Equations
+
+2.1.4 DDE equations
+-------------------
+
+DDE equations in general are of the form y'(t) =
+f(t,y(t),y(t-\tau_1),...,y(t-\tau_n)) where y'(t) may be a scalar or
+vector of derivatives. The variable t always is a scalar describing one
+point of time and the variables y(t-\tau_i) are scalars or vectors from
+the past. Only DDE solvers from section *Note Modified Runge-Kutta
+solvers:: can be used to solve such kind of differential equations. A
+DDE equation definition in Octave must look like
+ function [dy] = DDEequation (t, y, z, varargin)
+ NOTE: Only DDEs with constant delays y(t-\tau_i) can be solved with
+OdePkg.
+
+\1f
+File: odepkg.info, Node: Solver families, Next: ODE/DAE/IDE/DDE options, Prev: Differential Equations, Up: Users Guide
+
+2.2 Solver families
+===================
+
+In this section the different kind of solvers are introduced that have
+been implemented in OdePkg. This section starts with the basic
+Runge-Kutta solvers in section *Note Runge-Kutta solvers:: and is
+continued with the Mex-file Hairer-Wanner solvers in section *Note
+Hairer-Wanner solvers::. Performance tests have also been added to the
+OdePkg. Some of these performance results have been added to section
+*Note ODE solver performances::.
+
+* Menu:
+
+* Runge-Kutta solvers:: ODE solvers written as `*.m' files
+* Hairer-Wanner solvers:: DAE solvers interfaced by `*.cc' files
+* Cash modified BDF solvers:: A DAE and an IDE solver interfaced by `*.cc' files
+* DDaskr direct method solver:: An IDE solver interfaced by a `*.cc' file
+* Modified Runge-Kutta solvers:: DDE solvers written as `*.m' files
+* ODE solver performances:: Cross math-engine performance tests
+
+\1f
+File: odepkg.info, Node: Runge-Kutta solvers, Next: Hairer-Wanner solvers, Prev: Solver families, Up: Solver families
+
+2.2.1 Runge-Kutta solvers
+-------------------------
+
+The Runge-Kutta solvers are written in the Octave language and that are
+saved as `m'-files. There have been implemented four different solvers
+with a very similiar structure, ie. `ode23', `ode45', `ode54' and
+`ode78'(1). The Runge-Kutta solvers have been added to the OdePkg to
+solve non-stiff ODEs and DAEs, stiff equations of that form cannot be
+solved with these solvers.
+
+ The order of all of the following Runge-Kutta methods is the order
+of the local truncation error, which is the principle error term in the
+portion of the Taylor series expansion that gets dropped, or
+intentionally truncated. This is different from the local error which
+is the difference between the estimated solution and the actual, or
+true solution. The local error is used in stepsize selection and may be
+approximated by the difference between two estimates of different order,
+l(h) = x(O(h+1)) - x(O(h)). With this definition, the local error will
+be as large as the error in the lower order method. The local
+truncation error is within the group of terms that gets multipled by h
+when solving for a solution from the general Runge-Kutta method.
+Therefore, the order-p solution created by the Runge-Kunge method will
+be roughly accurate to O(h^(p+1)) since the local truncation error
+shows up in the solution as e = h\cdot d which is h-times an
+O(h^p)-term, or rather O(h^(p+1)).
+
+`ode23'Integrates a system of non-stiff ordinary differential equations
+ (non-stiff ODEs and DAEs) using second and third order Runge-Kutta
+ formulas. This particular third order method reduces to Simpson's
+ 1/3 rule and uses the third order estimation for the output
+ solutions. Third order accurate Runge-Kutta methods have local and
+ global errors of O(h^4) and O(h^3) respectively and yield exact
+ results when the solution is a cubic (the variable h is the step
+ size from one integration step to another integration step). This
+ solver requires three function evaluations per integration step.
+`ode45'Integrates a system of non-stiff ordinary differential equations
+ (non-stiff ODEs and DAEs) using fourth and fifth order embedded
+ formulas from Fehlberg. This is a fourth-order accurate integrator
+ therefore the local error normally expected is O(h^5). However,
+ because this particular implementation uses the fifth-order
+ estimate for x_out (ie. local extrapolation) moving forward with
+ the fifth-order estimate should yield local error of O(h^6). This
+ solver requires six function evaluations per integration step.
+`ode54'Integrates a system of non-stiff ordinary differential equations
+ (non-stiff ODEs and DAEs) using fifth and fourth order Runge-Kutta
+ formulas. The Fehlberg 4(5) of the `ode45' pair is established and
+ works well, however, the Dormand-Prince 5(4) pair minimizes the
+ local truncation error in the fifth-order estimate which is what
+ is used to step forward (local extrapolation). Generally it
+ produces more accurate results and costs roughly the same
+ computationally. This solver requires seven function evaluations
+ per integration step.
+`ode78'Integrates a system of non-stiff ordinary differential equations
+ (non-stiff ODEs and DAEs) using seventh and eighth order
+ Runge-Kutta formulas. This is a seventh-order accurate integrator
+ therefore the local error normally expected is O(h^8). However,
+ because this particular implementation uses the eighth-order
+ estimate for x_out moving forward with the eighth-order estimate
+ will yield errors on the order of O(h^9). This solver requires
+ thirteen function evaluations per integration step.
+
+ ---------- Footnotes ----------
+
+ (1) The descriptions for these Runge-Kutta solvers have been taken
+from the help texts of the initial Runge-Kutta solvers that were
+written by Marc Compere, he also pointed out that "a relevant
+discussion on step size choice can be found on page 90ff in U.M.
+Ascher, L.R. Petzold, Computer Methods for Ordinary Differential
+Equations and Differential-Agebraic Equations, Society for Industrial
+and Applied Mathematics (SIAM), Philadelphia, 1998".
+
+\1f
+File: odepkg.info, Node: Hairer-Wanner solvers, Next: Cash modified BDF solvers, Prev: Runge-Kutta solvers, Up: Solver families
+
+2.2.2 Hairer-Wanner solvers
+---------------------------
+
+The Hairer-Wanner solvers have been written by Ernst Hairer and Gerhard
+Wanner. They are written in the Fortran language (hosted at
+`http://www.unige.ch/~hairer') and that have been added to the OdePkg
+as a compressed file with the name `hairer.tgz'. Papers and other
+details about these solvers can be found at the adress given before.
+The licence of these solvers is a modified BSD license (without
+advertising clause and therefore are GPL compatible) and can be found
+as `licence.txt' file in the `hairer.tgz' package. The Hairer-Wanner
+solvers have been added to the OdePkg to solve non-stiff and stiff ODEs
+and DAEs that cannot be solved with any of the Runge-Kutta solvers.
+
+ Interface functions for these solvers have been created and have
+been added to the OdePkg. Their names are `odepkg_octsolver_XXX.cc'
+where `XXX' is the name of the Fortran file that is interfaced. The
+file `dldsolver.oct' is created automatically when installing OdePkg
+with the command `pkg', but developers can also build each solver
+manually with the instructions given as a preamble of every
+`odepkg_octsolver_XXX.cc' file.
+
+ To provide a short name and to circumvent from the syntax of the
+original solver function wrapper functions have been added, eg. the
+command `ode2r' calls the solver `radau' from the Fortran file
+`radau.f'. The other wrapper functions for the Hairer-Wanner solvers
+are `ode5r' for the `radau5' solver, `oders' for the `rodas' solver and
+`odesx' for the `seulex' solver. The help text of all these solver
+functions can be diaplyed by calling `help wrapper' where wrapper is
+one of `ode2r', `ode5r', `oders' or `odesx'.
+
+\1f
+File: odepkg.info, Node: Cash modified BDF solvers, Next: DDaskr direct method solver, Prev: Hairer-Wanner solvers, Up: Solver families
+
+2.2.3 Cash modified BDF solvers
+-------------------------------
+
+The backward differentiation algorithm solvers have been written by
+Jeff Cash in the Fortran language and that are hosted at
+`http://pitagora.dm.uniba.it/~testset'. They have been added to the
+OdePkg as a compressed file with the name `cash.tgz'. The license of
+these solvers is a General Public License V2 that can be found as a
+preamble of each Fortran solver source file. Papers and other details
+about these solvers can be found at the host adress given before and
+also at Jeff Cash's homepage at `http://www.ma.ic.ac.uk/~jcash'. Jeff
+Cash's modified BDF solvers have been added to the OdePkg to solve
+non-stiff and stiff ODEs and DAEs and also IDEs that cannot be solved
+with any of the Runge-Kutta solvers.
+
+ Interface functions for these solvers have been created and have
+been added to the OdePkg. Their names are `odepkg_octsolver_XXX.cc'
+where `XXX' is the name of the Fortran file that is interfaced. The
+file `dldsolver.oct' is created automatically when installing OdePkg
+with the command `pkg', but developers can also build each solver
+manually with the instructions given as a preamble of every
+`odepkg_octsolver_XXX.cc' file.
+
+ To provide a short name and to circumvent from the syntax of the
+original solver function wrapper functions have been added. The command
+`odebda' calls the solver `mebdfdae' from the Fortran file `mebdf.f'
+and the `odebdi' calls the solver `mebdfi' from the Fortran file
+`mebdfi.f'.
+
+\1f
+File: odepkg.info, Node: DDaskr direct method solver, Next: Modified Runge-Kutta solvers, Prev: Cash modified BDF solvers, Up: Solver families
+
+2.2.4 DDaskr direct method solver
+---------------------------------
+
+The direct method from the Krylov solver file `ddaskr.f' has been
+written by Peter N. Brown, Alan C. Hindmarsh, Linda R. Petzold and
+Clement W. Ulrich in the Fortran language and that is hosted at
+`http://www.netlib.org'. The Krylov method has not been implemented
+within OdePkg, only the direct method has been implemented. The solver
+and further files for the interface have been added to the OdePkg as a
+compressed package with the name `ddaskr.tgz'. The license of these
+solvers is a modfied BSD license (without advertising clause) that can
+be found inside of the compressed package. Other details about this
+solver can be found as a preamble in the source file `ddaskr.f'. The
+direct method solver of the file `ddaskr.f' has been added to the
+OdePkg to solve non-stiff and stiff IDEs.
+
+ An interface function for this solver has been created and has been
+added to the OdePkg. The source file name is
+`odepkg_octsolver_ddaskr.cc'. The binary function can be found in the
+file `dldsolver.oct' that is created automatically when installing
+OdePkg with the command `pkg', but developers can also build the solver
+wrapper manually with the instructions given as a preamble of the
+`odepkg_octsolver_ddaskr.cc' file.
+
+ To provide a short name and to circumvent from the syntax of the
+original solver function a wrapper function has been added. The command
+`odekdi' calls the direct method of the solver `ddaskr' from the
+Fortran file `ddaskr.f'.
+
+\1f
+File: odepkg.info, Node: Modified Runge-Kutta solvers, Next: ODE solver performances, Prev: DDaskr direct method solver, Up: Solver families
+
+2.2.5 Modified Runge-Kutta solvers
+----------------------------------
+
+The modified Runge-Kutta solvers are written in the Octave language and
+that are saved as m-files. There have been implemented four different
+solvers that do have a very similiar structure to that solvers found in
+section *Note Runge-Kutta solvers::. Their names are `ode23d',
+`ode45d', `ode54d' and `ode78d'. The modified Runge-Kutta solvers have
+been added to the OdePkg to solve non-stiff DDEs with constant delays
+only, stiff equations of that form cannot be solved with these solvers.
+For further information about the error estimation of these solvers cf.
+section *Note Runge-Kutta solvers::.
+
+ Note: The four DDE solvers of OdePkg are not syntax compatible to
+propietary solvers. The reason is that the input arguments of the
+propietary DDE-solvers are completely mixed up in comparison to ODE,
+DAE and IDE propietary solvers. The DDE solvers of OdePkg have been
+implemented in form of a syntax compatible way to the other family
+solvers, eg. propietary solver calls look like
+
+ ode23 (@fode, vt, vy) %# for solving an ODE
+ ode15i (@fide, vt, vy, vdy) %# for solving an IDE
+ dde23 (@fdde, vlag, vhist, vt) %# for solving a DDE
+ whereas in OdePkg the same examples would look like
+ ode23 (@fode, vt, vy) %# for solving an ODE
+ odebdi (@fide, vt, vy, vdy) %# for solving an IDE
+ ode23d (@fdde, vt, vy, vlag, vhist) %# for solving a DDE
+
+ Further, the commands `ddeset' and `ddeget' have not been
+implemented in OdePkg. Use the functions `odeset' and `odeget' for
+setting and returning DDE options instead.
+
+\1f
+File: odepkg.info, Node: ODE solver performances, Prev: Modified Runge-Kutta solvers, Up: Solver families
+
+2.2.6 ODE solver performances
+-----------------------------
+
+The following tables give an overview about the performance of the
+OdePkg ODE/DAE solvers in comparison to propietary solvers when running
+the HIRES function from the OdePkg testsuite (non-stiff ODE test).
+
+ >> odepkg ('odepkg_performance_mathires');
+ -----------------------------------------------------------------------------------------
+ Solver RelTol AbsTol Init Mescd Scd Steps Accept FEval JEval LUdec Time
+ -----------------------------------------------------------------------------------------
+ ode113 1e-007 1e-007 1e-009 7.57 5.37 24317 21442 45760 11.697
+ ode23 1e-007 1e-007 1e-009 7.23 5.03 13876 13862 41629 2.634
+ ode45 1e-007 1e-007 1e-009 7.91 5.70 11017 10412 66103 2.994
+ ode15s 1e-007 1e-007 1e-009 7.15 4.95 290 273 534 8 59 0.070
+ ode23s 1e-007 1e-007 1e-009 6.24 4.03 702 702 2107 702 702 0.161
+ ode23t 1e-007 1e-007 1e-009 6.00 3.79 892 886 1103 5 72 0.180
+ ode23tb 1e-007 1e-007 1e-009 5.85 3.65 735 731 2011 5 66 0.230
+ -----------------------------------------------------------------------------------------
+
+ octave:1> odepkg ('odepkg_performance_octavehires');
+ -----------------------------------------------------------------------------------------
+ Solver RelTol AbsTol Init Mescd Scd Steps Accept FEval JEval LUdec Time
+ -----------------------------------------------------------------------------------------
+ ode23 1e-07 1e-07 1e-09 7.86 5.44 17112 13369 51333 138.071
+ ode45 1e-07 1e-07 1e-09 8.05 5.63 9397 9393 56376 92.065
+ ode54 1e-07 1e-07 1e-09 8.25 5.83 9300 7758 65093 84.319
+ ode78 1e-07 1e-07 1e-09 8.54 6.12 7290 6615 94757 97.746
+ ode2r 1e-07 1e-07 1e-09 7.69 5.27 50 50 849 50 59 0.624
+ ode5r 1e-07 1e-07 1e-09 7.55 5.13 71 71 671 71 81 0.447
+ oders 1e-07 1e-07 1e-09 7.08 4.66 138 138 828 138 138 0.661
+ odesx 1e-07 1e-07 1e-09 6.56 4.13 30 26 1808 26 205 1.057
+ odebda 1e-07 1e-07 1e-09 6.53 4.11 401 400 582 42 42 0.378
+ -----------------------------------------------------------------------------------------
+
+ The following tables give an overview about the performance of the
+OdePkg ODE/DAE solvers in comparison to propietary solvers when running
+the chemical AKZO-NOBEL function from the OdePkg testsuite (non-stiff
+ODE test).
+
+ >> odepkg ('odepkg_performance_matchemakzo');
+ -----------------------------------------------------------------------------------------
+ Solver RelTol AbsTol Init Mescd Scd Steps Accept FEval JEval LUdec Time
+ -----------------------------------------------------------------------------------------
+ ode113 1e-007 1e-007 1e-007 NaN Inf - - - - - -
+ ode23 1e-007 1e-007 1e-007 NaN Inf 15 15 47 0.431
+ ode45 1e-007 1e-007 1e-007 NaN Inf 15 15 92 0.170
+ ode15s 1e-007 1e-007 1e-007 7.04 6.20 161 154 4 35 0.521
+ ode23s 1e-007 1e-007 1e-007 7.61 6.77 1676 1676 5029 1676 1677 2.704
+ ode23t 1e-007 1e-007 1e-007 5.95 5.11 406 404 3 39 0.611
+ ode23tb 1e-007 1e-007 1e-007 NaN Inf 607 3036 1 608 6.730
+ -----------------------------------------------------------------------------------------
+
+ octave:1> odepkg ('odepkg_performance_octavechemakzo');
+ -----------------------------------------------------------------------------------------
+ Solver RelTol AbsTol Init Mescd Scd Steps Accept FEval JEval LUdec Time
+ -----------------------------------------------------------------------------------------
+ ode23 1e-07 1e-07 1e-07 2.95 2.06 424 385 1269 1.270
+ ode45 1e-07 1e-07 1e-07 2.95 2.06 256 218 1530 1.281
+ ode54 1e-07 1e-07 1e-07 2.95 2.06 197 195 1372 1.094
+ ode78 1e-07 1e-07 1e-07 2.95 2.06 184 156 2379 1.933
+ ode2r 1e-07 1e-07 1e-07 8.50 7.57 39 39 372 39 43 0.280
+ ode5r 1e-07 1e-07 1e-07 8.50 7.57 39 39 372 39 43 0.238
+ oders 1e-07 1e-07 1e-07 7.92 7.04 67 66 401 66 67 0.336
+ odesx 1e-07 1e-07 1e-07 7.19 6.26 19 19 457 19 82 0.248
+ odebda 1e-07 1e-07 1e-07 7.47 6.54 203 203 307 25 25 0.182
+ -----------------------------------------------------------------------------------------
+
+ Other testsuite functions have been added to the OdePkg that can be
+taken for further performance tests and syntax checks on your own
+hardware. These functions all have a name `odepkg_testsuite_XXX.m' with
+`XXX' being the name of the testsuite equation that has been
+implemented.
+
+\1f
+File: odepkg.info, Node: ODE/DAE/IDE/DDE options, Next: M-File Function Reference, Prev: Solver families, Up: Users Guide
+
+2.3 ODE/DAE/IDE/DDE options
+===========================
+
+The default values of an OdePkg options structure can be displayed with
+the command `odeset'. If `odeset' is called without any input argument
+and one output argument then a OdePkg options structure with default
+values is created, eg.
+ A = odeset ();
+ disp (A);
+ There also is an command `odeget' which extracts one or more options
+from an OdePkg options structure. Other values than default values can
+also be set with the command `odeset'. The function description of the
+commands `odeset' and `odeget' can be found in the *Note M-File
+Function Reference::. The values that can be set with the `odeset'
+command are
+
+`RelTol'
+ The option `RelTol' is used to set the relative error tolerance
+ for the error estimation of the solver that is used while solving.
+ It can either be a positive scalar or a vector with every element
+ of the vector being a positive scalar (this depends on the solver
+ that is used if both variants are supported). The definite error
+ estimation equation also depends on the solver that is used but
+ generalized (eg. for the solvers `ode23', `ode45', `ode54' and
+ `ode78') it may be a form like e(t) = max (r_tol^T y(t), a_tol).
+ Run the following example to illustrate the effect if this option
+ is used
+ function yd = fvanderpol (vt, vy, varargin)
+ mu = 1; ## Set mu > 10 for higher stiffness
+ yd = [vy(2); mu * (1 - vy(1)^2) * vy(2) - vy(1)];
+ endfunction
+
+ A = odeset ("RelTol", 1, "OutputFcn", @odeplot);
+ ode78 (@fvanderpol, [0 20], [2 0], A);
+ B = odeset (A, "RelTol", 1e-10);
+ ode78 (@fvanderpol, [0 20], [2 0], B);
+
+`AbsTol'
+ The option `AbsTol' is used to set the absolute error tolerance
+ for the error estimation of the solver that is used while solving.
+ It can either be a positive scalar or a vector with every element
+ of the vector being a positive scalar (it depends on the solver
+ that is used if both variants are supported). The definite error
+ estimation equation also depends on the solver that is used but
+ generalized (eg. for the solvers `ode23', `ode45', `ode54' and
+ `ode78') it may be a form like e(t) = max (r_tol^T y(t), a_tol).
+ Run the following example to illustrate the effect if this option
+ is used
+ ## An anonymous implementation of the Van der Pol equation
+ fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
+
+ A = odeset ("AbsTol", 1e-3, "OutputFcn", @odeplot);
+ ode54 (fvdb, [0 10], [2 0], A);
+ B = odeset (A, "AbsTol", 1e-10);
+ ode54 (fvdb, [0 10], [2 0], B);
+
+`NormControl'
+ The option `NormControl' is used to set the type of error
+ tolerance calculation of the solver that is used while solving. It
+ can either be the string `"on"' or `"off"'. At the time the solver
+ starts solving a warning message may be displayed if the solver
+ will ignore the `"on"' setting of this option because of an
+ unhandled resp. missing implementation. If set `"on"' then the
+ definite error estimation equation also depends on the solver that
+ is used but generalized (eg. for the solvers `ode23', `ode45',
+ `ode54' and `ode78') it may be a form like e(t) = max (r_tol^T max
+ (norm (y(t), \infty)), a_tol). Run the following example to
+ illustrate the effect if this option is used
+ function yd = fvanderpol (vt, vy, varargin)
+ mu = 1; ## Set mu > 10 for higher stiffness
+ yd = [vy(2); mu * (1 - vy(1)^2) * vy(2) - vy(1)];
+ endfunction
+
+ A = odeset ("NormControl", "on", "OutputFcn", @odeplot);
+ ode78 (@fvanderpol, [0 20], [2 0], A);
+ B = odeset (A, "NormControl", "off");
+ ode78 (@fvanderpol, [0 20], [2 0], B);
+
+`MaxStep'
+ The option `MaxStep' is used to set the maximum step size for the
+ solver that is used while solving. It can only be a positive
+ scalar. By default this value is set internally by every solver
+ and also may differ when using different solvers. Run the
+ following example to illustrate the effect if this option is used
+ function yd = fvanderpol (vt, vy, varargin)
+ mu = 1; ## Set mu > 10 for higher stiffness
+ yd = [vy(2); mu * (1 - vy(1)^2) * vy(2) - vy(1)];
+ endfunction
+
+ A = odeset ("MaxStep", 10, "OutputFcn", @odeprint);
+ ode78 (@fvanderpol, [0 20], [2 0], A);
+ B = odeset (A, "MaxStep", 1e-1);
+ ode78 (@fvanderpol, [0 20], [2 0], B);
+
+`InitialStep'
+ The option `InitialStep' is used to set the initial first step
+ size for the solver. It can only be a positive scalar. By default
+ this value is set internally by every solver and also may be
+ different when using different solvers. Run the following example
+ to illustrate the effect if this option is used
+ function yd = fvanderpol (vt, vy, varargin)
+ mu = 1; ## Set mu > 10 for higher stiffness
+ yd = [vy(2); mu * (1 - vy(1)^2) * vy(2) - vy(1)];
+ endfunction
+
+ A = odeset ("InitialStep", 1, "OutputFcn", @odeprint);
+ ode78 (@fvanderpol, [0 1], [2 0], A);
+ B = odeset (A, "InitialStep", 1e-5);
+ ode78 (@fvanderpol, [0 1], [2 0], B);
+
+`InitialSlope'
+ The option `InitialSlope' is not handled by any of the solvers by
+ now.
+`OutputFcn'
+ The option `OutputFcn' can be used to set up an output function
+ for displaying the results of the solver while solving. It must be
+ a function handle to a valid function. There are four predefined
+ output functions available with OdePkg. `odeprint' prints the
+ actual time values and results in the Octave window while solving,
+ `odeplot' plots the results over time in a new figure window while
+ solving, `odephas2' plots the first result over the second result
+ as a two-dimensional plot while solving and `odephas3' plots the
+ first result over the second result over the third result as a
+ three-dimensional plot while solving. Run the following example to
+ illustrate the effect if this option is used
+ function yd = fvanderpol (vt, vy, varargin)
+ mu = 1; ## Set mu > 10 for higher stiffness
+ yd = [vy(2); mu * (1 - vy(1)^2) * vy(2) - vy(1)];
+ endfunction
+
+ A = odeset ("OutputFcn", @odeprint);
+ ode78 (@fvanderpol, [0 2], [2 0], A);
+ User defined output functions can also be used. A typical
+ framework for a self-made output function may then be of the form
+ function [vret] = odeoutput (vt, vy, vdeci, varargin)
+ switch vdeci
+ case "init"
+ ## Do everything needed to intialize output function
+ case "calc"
+ ## Do everything needed to create output
+ case "done"
+ ## Do everything needed to clean up output function
+ endswitch
+ endfunction
+ The output function `odeplot' is also set automatically if the
+ solver calculation routine is called without any output argument.
+ Run the following example to illustrate the effect if this option
+ is not used and no output argument is given
+ ## An anonymous implementation of the Van der Pol equation
+ fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
+
+ ode78 (fvdb, [0 20], [2 0]);
+
+`Refine'
+ The option `Refine' is used to set the interpolation factor that
+ is used to increase the quality for the output values if an output
+ function is also set with the option `OutputFcn'. It can only be a
+ integer value 0<=`Refine'<=5. Run the following example to
+ illustrate the effect if this option is used
+ function yd = fvanderpol (vt, vy, varargin)
+ mu = 1; ## Set mu > 10 for higher stiffness
+ yd = [vy(2); mu * (1 - vy(1)^2) * vy(2) - vy(1)];
+ endfunction
+
+ A = odeset ("Refine", 0, "OutputFcn", @odeplot);
+ ode78 (@fvanderpol, [0 20], [2 0], A);
+ B = odeset (A, "Refine", 3);
+ ode78 (@fvanderpol, [0 20], [2 0], B);
+
+`OutputSel'
+ The option `OutputSel' is used to set the components for which
+ output has to be performed if an output function is also set with
+ the option `OutputFcn'. It can only be a vector of integer values.
+ Run the following example to illustrate the effect if this option
+ is used
+ function yd = fvanderpol (vt, vy, varargin)
+ mu = 1; ## Set mu > 10 for higher stiffness
+ yd = [vy(2); mu * (1 - vy(1)^2) * vy(2) - vy(1)];
+ endfunction
+
+ A = odeset ("OutputSel", [1, 2], "OutputFcn", @odeplot);
+ ode78 (@fvanderpol, [0 20], [2 0], A);
+ B = odeset (A, "OutputSel", [2]);
+ ode78 (@fvanderpol, [0 20], [2 0], B);
+
+`Stats'
+ The option `Stats' is used to print cost statistics about the
+ solving process after solving has been finished. It can either be
+ the string `"on"' or `"off"'. Run the following example to
+ illustrate the effect if this option is used
+ function yd = fvanderpol (vt, vy, varargin)
+ mu = 1; ## Set mu > 10 for higher stiffness
+ yd = [vy(2); mu * (1 - vy(1)^2) * vy(2) - vy(1)];
+ endfunction
+
+ A = odeset ("Stats", "off");
+ [a, b] = ode78 (@fvanderpol, [0 2], [2 0], A);
+ B = odeset ("Stats", "on");
+ [c, d] = ode78 (@fvanderpol, [0 2], [2 0], B);
+ The cost statistics can also be obtained if the solver calculation
+ routine is called with one output argument. The cost statistics
+ then are in the field `stats' of the output arguemnt structure.
+ Run the following example to illustrate the effect if this option
+ is used
+ S = ode78 (@fvanderpol, [0 2], [2 0], B);
+ disp (S);
+
+`Jacobian'
+ The option `Jacobian' can be used to set up an external Jacobian
+ function or Jacobian matrix for DAE solvers to achieve faster and
+ better results (ODE Runge-Kutta solvers do not need to handle a
+ Jacobian function handle or Jacobian matrix). It must either be a
+ function handle to a valid function or a full constant matrix of
+ size squared the dimension of the set of differential equations.
+ User defined Jacobian functions must have the form `function
+ [vjac] = fjac (vt, vy, varargin)'. Run the following example to
+ illustrate the effect if this option is used
+ function vdy = fpol (vt, vy, varargin)
+ vdy = [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
+ endfunction
+
+ function vr = fjac (vt, vy, varargin)
+ vr = [0, 1; ...
+ -1-2*vy(1)*vy(2), 1-vy(1)^2];
+ endfunction
+
+ A = odeset ("Stats", "on");
+ B = ode5r (@fpol, [0 20], [2 0], A);
+ C = odeset (A, "Jacobian", @fjac);
+ D = ode5r (@fpol, [0 20], [2 0], C);
+ Note: The function definition for Jacobian calculations of IDE
+ equations must have the form `function [vjac, vdjc] = fjac (vt,
+ vy, vyd, varargin)'. Run the following example to illustrate the
+ effect if this option is used
+ function [vres] = fvanderpol (vt, vy, vyd, varargin)
+ vres = [vy(2) - vyd(1);
+ (1 - vy(1)^2) * vy(2) - vy(1) - vyd(2)];
+ endfunction
+
+ function [vjac, vdjc] = fjacobian (vt, vy, vyd, varargin)
+ vjac = [0, 1; -1 - 2 * vy(1) * vy(2), 1 - vy(1)^2];
+ vdjc = [-1, 0; 0, -1];
+ endfunction
+
+ vopt = odeset ("Jacobian", @fjacobian, "Stats", "on");
+ vsol = odebdi (@fvanderpol, [0, 20], [2; 0], [0; -2], vopt, 10);
+
+`JPattern'
+ The option `JPattern' is not handled by any of the solvers by now.
+`Vectorized'
+ The option `Vectorized' is not handled by any of the solvers by
+ now.
+`Mass'
+ The option `Mass' can be used to set up an external Mass function
+ or Mass matrix for solving DAE equations. It depends on the solver
+ that is used if `Mass' is supported or not. It must either be a
+ function handle to a valid function or a full constant matrix of
+ size squared the dimension of the set of differential equations.
+ User defined Jacobian functions must have the form `function vmas
+ = fmas (vt, vy, varargin)'. Run the following example to
+ illustrate the effect if this option is used
+ function vdy = frob (t, y, varargin)
+ vdy(1,1) = -0.04*y(1)+1e4*y(2)*y(3);
+ vdy(2,1) = 0.04*y(1)-1e4*y(2)*y(3)-3e7*y(2)^2;
+ vdy(3,1) = y(1)+y(2)+y(3)-1;
+ endfunction
+
+ function vmas = fmas (vt, vy, varargin)
+ vmas = [1, 0, 0; 0, 1, 0; 0, 0, 0];
+ endfunction
+
+ A = odeset ("Mass", @fmas);
+ B = ode5r (@frob, [0 1e8], [1 0 0], A);
+ Note: The function definition for Mass calculations of DDE
+ equations must have the form `function vmas = fmas (vt, vy, vz,
+ varargin)'.
+`MStateDependence'
+ The option `MStateDependence' can be used to set up the type of
+ the external Mass function for solving DAE equations if a Mass
+ function handle is set with the option `Mass'. It depends on the
+ solver that is used if `MStateDependence' is supported or not. It
+ must be a string of the form `"none"', `"weak"' or `"strong"'. Run
+ the following example to illustrate the effect if this option is
+ used
+ function vdy = frob (vt, vy, varargin)
+ vdy(1,1) = -0.04*vy(1)+1e4*vy(2)*vy(3);
+ vdy(2,1) = 0.04*vy(1)-1e4*vy(2)*vy(3)-3e7*vy(2)^2;
+ vdy(3,1) = vy(1)+vy(2)+vy(3)-1;
+ endfunction
+
+ function vmas = fmas (vt, varargin)
+ vmas = [1, 0, 0; 0, 1, 0; 0, 0, 0];
+ endfunction
+
+ A = odeset ("Mass", @fmas, "MStateDependence", "none");
+ B = ode5r (@frob, [0 1e8], [1 0 0], A);
+ User defined Mass functions must have the form as described before
+ (ie. `function vmas = fmas (vt, varargin)' if the option
+ `MStateDependence' was set to `"none"', otherwise the user defined
+ Mass function must have the form `function vmas = fmas (vt, vy,
+ varargin)' if the option `MStateDependence' was set to either
+ `"weak"' or `"strong"'.
+`MvPattern'
+ The option `MvPattern' is not handled by any of the solvers by now.
+`MassSingular'
+ The option `MassSingular' is not handled by any of the solvers by
+ now.
+`NonNegative'
+ The option `NonNegative' can be used to set solution variables to
+ zero even if their real solution would be a negative value. It
+ must be a vector describing the positions in the solution vector
+ for which the option `NonNegative' should be used. Run the
+ following example to illustrate the effect if this option is used
+ vfun = @(vt,vy) -abs(vy);
+ vopt = odeset ("NonNegative", [1]);
+
+ [vt1, vy1] = ode78 (vfun, [0 100], [1]);
+ [vt2, vy2] = ode78 (vfun, [0 100], [1], vopt);
+
+ subplot (2,1,1); plot (vt1, vy1);
+ subplot (2,1,2); plot (vt2, vy2);
+
+`Events'
+ The option `Events' can be used to set up an Event function, ie.
+ the Event function can be used to find zero crossings in one of
+ the results. It must either be a function handle to a valid
+ function. Run the following example to illustrate the effect if
+ this option is used
+ function vdy = fbal (vt, vy, varargin)
+ vdy(1,1) = vy(2);
+ vdy(2,1) = -9.81; ## m/s²
+ endfunction
+
+ function [veve, vterm, vdir] = feve (vt, vy, varargin)
+ veve = vy(1); ## Which event component should be tread
+ vterm = 1; ## Terminate if an event is found
+ vdir = -1; ## In which direction, -1 for falling
+ endfunction
+
+ A = odeset ("Events", @feve);
+ B = ode78 (@fbal, [0 1.5], [1 3], A);
+ plot (B.x, B.y(:,1));
+ Note: The function definition for Events calculations of DDE
+ equations must have the form `function [veve, vterm, vdir] = feve
+ (vt, vy, vz, varargin)' and the function definition for Events
+ calculations of IDE equations must have the form `function [veve,
+ vterm, vdir] = feve (vt, vy, vyd, varargin)'.
+`MaxOrder'
+ The option `MaxOrder' can be used to set the maximum order of the
+ backward differentiation algorithm of the `odebdi' and `odebda'
+ solvers. It must be a scalar integer value between 1 and 7. Run
+ the following example to illustrate the effect if this option is
+ used
+ function res = fwei (t, y, yp, varargin)
+ res = t*y^2*yp^3 - y^3*yp^2 + t*yp*(t^2 + 1) - t^2*y;
+ endfunction
+
+ function [dy, dyp] = fjac (t, y, yp, varargin)
+ dy = 2*t*y*yp^3 - 3*y^2*yp^2 - t^2;
+ dyp = 3*t*y^2*yp^2 - 2*y^3*yp + t*(t^2 + 1);
+ endfunction
+
+ A = odeset ("AbsTol", 1e-6, "RelTol", 1e-6, "Jacobian", @fjac, ...
+ "Stats", "on", "MaxOrder", 1, "BDF", "on")
+ B = odeset (A, "MaxOrder", 5)
+ C = odebdi (@fwei, [1 10], 1.2257, 0.8165, A);
+ D = odebdi (@fwei, [1 10], 1.2257, 0.8165, B);
+ plot (C.x, C.y, "bo-", D.x, D.y, "rx:");
+
+`BDF'
+ The option `BDF' is only supported by the `odebdi' and `odebda'
+ solvers. Using these solvers the option `BDF' will automatically
+ be set `"on"' (even if it was set `"off"' before) because the
+ `odebdi' and `odebda' solvers all use the backward differentiation
+ algorithm to solve the different kind of equations.
+
+`NewtonTol'
+ TODO
+
+`MaxNewtonIterations'
+ TODO
+
+\1f
+File: odepkg.info, Node: M-File Function Reference, Next: Oct-File Function Reference, Prev: ODE/DAE/IDE/DDE options, Up: Users Guide
+
+2.4 M-File Function Reference
+=============================
+
+The help texts of this section are autogenerated and refer to commands
+that all can be found in the files `*.m'. All commands that are listed
+below are loaded automatically everytime you launch Octave.
+ -- Function File: [] = ode23 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,
+ ...])
+ -- Command: [SOL] = ode23 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = ode23 (@FUN, SLOT, INIT, [OPT],
+ [PAR1, PAR2, ...])
+ This function file can be used to 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 (2,3).
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ ODEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, OPT can optionally be a
+ structure array that keeps the options created with the command
+ `odeset' and PAR1, PAR2, ... can optionally be other input
+ arguments of any type that have to be passed to the function
+ defined by @FUN.
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ ODEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ For example, solve an anonymous implementation of the Van der Pol
+ equation
+
+ fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
+
+ vopt = odeset ("RelTol", 1e-3, "AbsTol", 1e-3, \
+ "NormControl", "on", "OutputFcn", @odeplot);
+ ode23 (fvdb, [0 20], [2 0], vopt);
+
+ -- Function File: [] = ode23d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
+ [PAR1, PAR2, ...])
+ -- Command: [SOL] = ode23d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
+ [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = ode23d (@FUN, SLOT, INIT, LAGS,
+ HIST, [OPT], [PAR1, PAR2, ...])
+ 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 (2,3).
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ DDEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, LAGS is a double vector that
+ describes the lags of time, HIST is a double matrix and describes
+ the history of the DDEs, OPT can optionally be a structure array
+ that keeps the options created with the command `odeset' and PAR1,
+ PAR2, ... can optionally be other input arguments of any type that
+ have to be passed to the function defined by @FUN.
+
+ 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), ...
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ DDEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ 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))
+ endfunction
+ T = [0,20]
+ res = ode23d (@fun, T, [1;1;1], [5, 10], ones (3,2));
+
+
+ -- Function File: [] = ode45 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,
+ ...])
+ -- Command: [SOL] = ode45 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = ode45 (@FUN, SLOT, INIT, [OPT],
+ [PAR1, PAR2, ...])
+ This function file can be used to 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 (4,5).
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ ODEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, OPT can optionally be a
+ structure array that keeps the options created with the command
+ `odeset' and PAR1, PAR2, ... can optionally be other input
+ arguments of any type that have to be passed to the function
+ defined by @FUN.
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ ODEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ For example, solve an anonymous implementation of the Van der Pol
+ equation
+
+ fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
+
+ vopt = odeset ("RelTol", 1e-3, "AbsTol", 1e-3, \
+ "NormControl", "on", "OutputFcn", @odeplot);
+ ode45 (fvdb, [0 20], [2 0], vopt);
+
+ -- Function File: [] = ode45d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
+ [PAR1, PAR2, ...])
+ -- Command: [SOL] = ode45d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
+ [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = ode45d (@FUN, SLOT, INIT, LAGS,
+ HIST, [OPT], [PAR1, PAR2, ...])
+ 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 (4,5).
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ DDEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, LAGS is a double vector that
+ describes the lags of time, HIST is a double matrix and describes
+ the history of the DDEs, OPT can optionally be a structure array
+ that keeps the options created with the command `odeset' and PAR1,
+ PAR2, ... can optionally be other input arguments of any type that
+ have to be passed to the function defined by @FUN.
+
+ 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), ...
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ DDEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ 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))
+ endfunction
+ T = [0,20]
+ res = ode45d (@fun, T, [1;1;1], [5, 10], ones (3,2));
+
+
+ -- Function File: [] = ode54 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,
+ ...])
+ -- Command: [SOL] = ode54 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = ode54 (@FUN, SLOT, INIT, [OPT],
+ [PAR1, PAR2, ...])
+ This function file can be used to 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 (5,4).
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ ODEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, OPT can optionally be a
+ structure array that keeps the options created with the command
+ `odeset' and PAR1, PAR2, ... can optionally be other input
+ arguments of any type that have to be passed to the function
+ defined by @FUN.
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ ODEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ For example, solve an anonymous implementation of the Van der Pol
+ equation
+
+ fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
+
+ vopt = odeset ("RelTol", 1e-3, "AbsTol", 1e-3, \
+ "NormControl", "on", "OutputFcn", @odeplot);
+ ode54 (fvdb, [0 20], [2 0], vopt);
+
+ -- Function File: [] = ode54d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
+ [PAR1, PAR2, ...])
+ -- Command: [SOL] = ode54d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
+ [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = ode54d (@FUN, SLOT, INIT, LAGS,
+ HIST, [OPT], [PAR1, PAR2, ...])
+ 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 (2,3).
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ DDEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, LAGS is a double vector that
+ describes the lags of time, HIST is a double matrix and describes
+ the history of the DDEs, OPT can optionally be a structure array
+ that keeps the options created with the command `odeset' and PAR1,
+ PAR2, ... can optionally be other input arguments of any type that
+ have to be passed to the function defined by @FUN.
+
+ 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), ...
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ DDEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ 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 = ode54d (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))
+ endfunction
+ T = [0,20]
+ res = ode54d (@fun, T, [1;1;1], [5, 10], ones (3,2));
+
+
+ -- Function File: [] = ode78 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,
+ ...])
+ -- Command: [SOL] = ode78 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = ode78 (@FUN, SLOT, INIT, [OPT],
+ [PAR1, PAR2, ...])
+ This function file can be used to 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,8).
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ ODEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, OPT can optionally be a
+ structure array that keeps the options created with the command
+ `odeset' and PAR1, PAR2, ... can optionally be other input
+ arguments of any type that have to be passed to the function
+ defined by @FUN.
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ ODEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ For example, solve an anonymous implementation of the Van der Pol
+ equation
+
+ fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
+
+ vopt = odeset ("RelTol", 1e-3, "AbsTol", 1e-3, \
+ "NormControl", "on", "OutputFcn", @odeplot);
+ ode78 (fvdb, [0 20], [2 0], vopt);
+
+ -- Function File: [] = ode78d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
+ [PAR1, PAR2, ...])
+ -- Command: [SOL] = ode78d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
+ [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = ode78d (@FUN, SLOT, INIT, LAGS,
+ HIST, [OPT], [PAR1, PAR2, ...])
+ 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 (7,8).
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ DDEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, LAGS is a double vector that
+ describes the lags of time, HIST is a double matrix and describes
+ the history of the DDEs, OPT can optionally be a structure array
+ that keeps the options created with the command `odeset' and PAR1,
+ PAR2, ... can optionally be other input arguments of any type that
+ have to be passed to the function defined by @FUN.
+
+ 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), ...
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ DDEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ 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))
+ endfunction
+ T = [0,20]
+ res = ode78d (@fun, T, [1;1;1], [5, 10], ones (3,2));
+
+
+ -- Function File: [] = odebwe (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,
+ ...])
+ -- Command: [SOL] = odebwe (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = odebwe (@FUN, SLOT, INIT, [OPT],
+ [PAR1, PAR2, ...])
+ This function file can be used to solve a set of stiff ordinary
+ differential equations (stiff ODEs) or stiff differential
+ algebraic equations (stiff DAEs) with the Backward Euler method.
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ ODEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, OPT can optionally be a
+ structure array that keeps the options created with the command
+ `odeset' and PAR1, PAR2, ... can optionally be other input
+ arguments of any type that have to be passed to the function
+ defined by @FUN.
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ ODEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ For example, solve an anonymous implementation of the Van der Pol
+ equation
+
+ fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
+ vjac = @(vt,vy) [0, 1; -1 - 2 * vy(1) * vy(2), 1 - vy(1)^2];
+ vopt = odeset ("RelTol", 1e-3, "AbsTol", 1e-3, \
+ "NormControl", "on", "OutputFcn", @odeplot, \
+ "Jacobian",vjac);
+ odebwe (fvdb, [0 20], [2 0], vopt);
+
+ -- Function File: [] = odeexamples ()
+ Open the differential equations examples menu and allow the user
+ to select a submenu of ODE, DAE, IDE or DDE examples.
+
+ -- Function File: [VALUE] = odeget (ODESTRUCT, OPTION, [DEFAULT])
+ -- Command: [VALUES] = odeget (ODESTRUCT, {OPT1, OPT2, ...}, [{DEF1,
+ DEF2, ...}])
+ If this function is called with two input arguments and the first
+ input argument ODESTRUCT is of type structure array and the second
+ input argument OPTION is of type string then return the option
+ value VALUE that is specified by the option name OPTION in the
+ OdePkg option structure ODESTRUCT. Optionally if this function is
+ called with a third input argument then return the default value
+ DEFAULT if OPTION is not set in the structure ODESTRUCT.
+
+ If this function is called with two input arguments and the first
+ input argument ODESTRUCT is of type structure array and the second
+ input argument OPTION is of type cell array of strings then return
+ the option values VALUES that are specified by the option names
+ OPT1, OPT2, ... in the OdePkg option structure ODESTRUCT.
+ Optionally if this function is called with a third input argument
+ of type cell array then return the default value DEF1 if OPT1 is
+ not set in the structure ODESTRUCT, DEF2 if OPT2 is not set in the
+ structure ODESTRUCT, ...
+
+ Run examples with the command
+ demo odeget
+
+ -- 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.
+
+ For example, solve an anonymous implementation of 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);
+
+ -- 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.
+
+ For example, solve the "Lorenz attractor" 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)];
+ endfunction
+
+ vopt = odeset ('OutputFcn', @odephas3);
+ vsol = ode23 (@florenz, [0:0.01:7.5], [3 15 1], vopt);
+
+ -- 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
+
+ -- Function File: [SOL] = odepkg_event_handle (@FUN, TIME, Y, FLAG,
+ [PAR1, PAR2, ...])
+ Return the solution of the event function that is specified as the
+ first input argument @FUN in form of a function handle. The second
+ input argument TIME is of type double scalar and specifies the
+ time of the event evaluation, the third input argument Y either is
+ of type double column vector (for ODEs and DAEs) and specifies the
+ solutions or is of type cell array (for IDEs and DDEs) and
+ specifies the derivatives or the history values, the third input
+ argument FLAG is of type string and can be of the form
+ ``"init"''
+ then initialize internal persistent variables of the function
+ `odepkg_event_handle' and return an empty cell array of size
+ 4,
+
+ ``"calc"''
+ then do the evaluation of the event function and return the
+ solution SOL as type cell array of size 4,
+
+ ``"done"''
+ then cleanup internal variables of the function
+ `odepkg_event_handle' and return an empty cell array of size
+ 4.
+ Optionally if further input arguments PAR1, PAR2, ... of any type
+ are given then pass these parameters through `odepkg_event_handle'
+ to the event function.
+
+ 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.
+
+ -- Function File: [] = odepkg_examples_dae ()
+ Open the DAE examples menu and allow the user to select a demo
+ that will be evaluated.
+
+ -- Function File: [] = odepkg_examples_dde ()
+ Open the DDE examples menu and allow the user to select a demo
+ that will be evaluated.
+
+ -- Function File: [] = odepkg_examples_ide ()
+ Open the IDE examples menu and allow the user to select a demo
+ that will be evaluated.
+
+ -- Function File: [] = odepkg_examples_ode ()
+ Open the ODE examples menu and allow the user to select a demo
+ that will be evaluated.
+
+ -- Function File: [NEWSTRUCT] = odepkg_structure_check (OLDSTRUCT,
+ ["SOLVER"])
+ If this function is called with one input argument of type
+ structure array then check the field names and the field values of
+ the OdePkg structure OLDSTRUCT and return the structure as
+ NEWSTRUCT if no error is found. Optionally if this function is
+ called with a second input argument "SOLVER" of type string taht
+ specifies the name of a valid OdePkg solver then a higher level
+ error detection is performed. The function does not modify any of
+ the field names or field values but terminates with an error if an
+ invalid option or value is found.
+
+ 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.
+
+ Run examples with the command
+ demo odepkg_structure_check
+
+ -- 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.
+
+ -- 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.
+
+ -- 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.
+
+ -- 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.
+
+ -- 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.
+
+ -- 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.
+
+ -- 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.
+
+ -- 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.
+
+ -- 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.
+
+ -- 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.
+
+ -- Function File: [RET] = odeplot (T, Y, FLAG)
+ Open a new figure window and plot the results from the variable Y
+ of type column vector over time 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.
+
+ For example, solve an anonymous implementation of the "Van der
+ Pol" equation and display the results while solving
+ fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
+
+ vopt = odeset ('OutputFcn', @odeplot, 'RelTol', 1e-6);
+ vsol = ode45 (fvdb, [0 20], [2 0], vopt);
+
+ -- 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 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.
+
+ For example, solve an anonymous implementation of 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);
+
+ -- Function File: [ODESTRUCT] = odeset ()
+ -- Command: [ODESTRUCT] = odeset ("FIELD1", VALUE1, "FIELD2", VALUE2,
+ ...)
+ -- Command: [ODESTRUCT] = odeset (OLDSTRUCT, "FIELD1", VALUE1,
+ "FIELD2", VALUE2, ...)
+ -- Command: [ODESTRUCT] = odeset (OLDSTRUCT, NEWSTRUCT)
+ If this function is called without an input argument then return a
+ new OdePkg options structure array that contains all the necessary
+ fields and sets the values of all fields to default values.
+
+ If this function is called with string input arguments "FIELD1",
+ "FIELD2", ... identifying valid OdePkg options then return a new
+ OdePkg options structure with all necessary fields and set the
+ values of the fields "FIELD1", "FIELD2", ... to the values VALUE1,
+ VALUE2, ...
+
+ If this function is called with a first input argument OLDSTRUCT
+ of type structure array then overwrite all values of the options
+ "FIELD1", "FIELD2", ... of the structure OLDSTRUCT with new values
+ VALUE1, VALUE2, ... and return the modified structure array.
+
+ If this function is called with two input argumnets OLDSTRUCT and
+ NEWSTRUCT of type structure array then overwrite all values in the
+ fields from the structure OLDSTRUCT with new values of the fields
+ from the structure NEWSTRUCT. Empty values of NEWSTRUCT will not
+ overwrite values in OLDSTRUCT.
+
+ For a detailed explanation about valid fields and field values in
+ an OdePkg structure aaray have a look at the `odepkg.pdf', Section
+ 'ODE/DAE/IDE/DDE options' or run the command `doc odepkg' to open
+ the tutorial.
+
+ Run examples with the command
+ demo odeset
+
+\1f
+File: odepkg.info, Node: Oct-File Function Reference, Prev: M-File Function Reference, Up: Users Guide
+
+2.5 Oct-File Function Reference
+===============================
+
+The help texts of this section are autogenerated and refer to commands
+that all can be found in the file `dldsolver.oct'. The file
+`dldsolver.oct' is generated automatically if you install OdePkg with
+the command `pkg'. All commands that are listed below are loaded
+automatically everytime you launch Octave.
+ -- Command: [] = odebda (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [SOL] = odebda (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = odebda (@FUN, SLOT, INIT, [OPT],
+ [PAR1, PAR2, ...])
+ This function file can be used to solve a set of non-stiff or
+ stiff ordinary differential equations (ODEs) and non-stiff or
+ stiff differential algebraic equations (DAEs). This function file
+ is a wrapper file that uses Jeff Cash's Fortran solver
+ `mebdfdae.f'.
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ ODEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, OPT can optionally be a
+ structure array that keeps the options created with the command
+ `odeset' and PAR1, PAR2, ... can optionally be other input
+ arguments of any type that have to be passed to the function
+ defined by @FUN.
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ ODEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ For example,
+ function y = odepkg_equations_lorenz (t, x)
+ y = [10 * (x(2) - x(1));
+ x(1) * (28 - x(3));
+ x(1) * x(2) - 8/3 * x(3)];
+ endfunction
+
+ vopt = odeset ("InitialStep", 1e-3, "MaxStep", 1e-1, \\
+ "OutputFcn", @odephas3, "Refine", 5);
+ odebda (@odepkg_equations_lorenz, [0, 25], [3 15 1], vopt);
+
+ -- Command: [] = odebdi (@FUN, SLOT, Y0, DY0, [OPT], [P1, P2, ...])
+ -- Command: [SOL] = odebdi (@FUN, SLOT, Y0, DY0, [OPT], [P1, P2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = odebdi (@FUN, SLOT, Y0, DY0, [OPT],
+ [P1, P2, ...])
+ This function file can be used to solve a set of non-stiff and
+ stiff implicit differential equations (IDEs). This function file
+ is a wrapper file that uses Jeff Cash's Fortran solver `mebdfi.f'.
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ IDEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, Y0 is a double vector that defines the
+ initial values of the states, DY0 is a double vector that defines
+ the initial values of the derivatives, OPT can optionally be a
+ structure array that keeps the options created with the command
+ `odeset' and PAR1, PAR2, ... can optionally be other input
+ arguments of any type that have to be passed to the function
+ defined by @FUN.
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ IDEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ For example,
+ function res = odepkg_equations_ilorenz (t, y, yd)
+ res = [10 * (y(2) - y(1)) - yd(1);
+ y(1) * (28 - y(3)) - yd(2);
+ y(1) * y(2) - 8/3 * y(3) - yd(3)];
+ endfunction
+
+ vopt = odeset ("InitialStep", 1e-3, "MaxStep", 1e-1, \\
+ "OutputFcn", @odephas3, "Refine", 5);
+ odebdi (@odepkg_equations_ilorenz, [0, 25], [3 15 1], \\
+ [120 81 42.333333], vopt);
+
+ -- Command: [] = odekdi (@FUN, SLOT, Y0, DY0, [OPT], [P1, P2, ...])
+ -- Command: [SOL] = odekdi (@FUN, SLOT, Y0, DY0, [OPT], [P1, P2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = odekdi (@FUN, SLOT, Y0, DY0, [OPT],
+ [P1, P2, ...])
+ This function file can be used to solve a set of non-stiff or
+ stiff implicit differential equations (IDEs). This function file
+ is a wrapper file that uses the direct method (not the Krylov
+ method) of Petzold's, Brown's, Hindmarsh's and Ulrich's Fortran
+ solver `ddaskr.f'.
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ IDEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, Y0 is a double vector that defines the
+ initial values of the states, DY0 is a double vector that defines
+ the initial values of the derivatives, OPT can optionally be a
+ structure array that keeps the options created with the command
+ `odeset' and PAR1, PAR2, ... can optionally be other input
+ arguments of any type that have to be passed to the function
+ defined by @FUN.
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ IDEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ For example,
+ function res = odepkg_equations_ilorenz (t, y, yd)
+ res = [10 * (y(2) - y(1)) - yd(1);
+ y(1) * (28 - y(3)) - yd(2);
+ y(1) * y(2) - 8/3 * y(3) - yd(3)];
+ endfunction
+
+ vopt = odeset ("InitialStep", 1e-3, "MaxStep", 1e-1, \\
+ "OutputFcn", @odephas3, "Refine", 5);
+ odekdi (@odepkg_equations_ilorenz, [0, 25], [3 15 1], \\
+ [120 81 42.333333], vopt);
+
+ -- Command: [] = ode2r (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [SOL] = ode2r (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = ode2r (@FUN, SLOT, INIT, [OPT],
+ [PAR1, PAR2, ...])
+ This function file can be used to solve a set of non-stiff or
+ stiff ordinary differential equations (ODEs) and non-stiff or
+ stiff differential algebraic equations (DAEs). This function file
+ is a wrapper to Hairer's and Wanner's Fortran solver `radau.f'.
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ ODEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, OPT can optionally be a
+ structure array that keeps the options created with the command
+ `odeset' and PAR1, PAR2, ... can optionally be other input
+ arguments of any type that have to be passed to the function
+ defined by @FUN.
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ ODEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ For example,
+ function y = odepkg_equations_lorenz (t, x)
+ y = [10 * (x(2) - x(1));
+ x(1) * (28 - x(3));
+ x(1) * x(2) - 8/3 * x(3)];
+ endfunction
+
+ vopt = odeset ("InitialStep", 1e-3, "MaxStep", 1e-1, \\
+ "OutputFcn", @odephas3, "Refine", 5);
+ ode2r (@odepkg_equations_lorenz, [0, 25], [3 15 1], vopt);
+
+ -- Command: [] = ode5r (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [SOL] = ode5r (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = ode5r (@FUN, SLOT, INIT, [OPT],
+ [PAR1, PAR2, ...])
+ This function file can be used to solve a set of non-stiff or
+ stiff ordinary differential equations (ODEs) and non-stiff or
+ stiff differential algebraic equations (DAEs). This function file
+ is a wrapper to Hairer's and Wanner's Fortran solver `radau5.f'.
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ ODEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, OPT can optionally be a
+ structure array that keeps the options created with the command
+ `odeset' and PAR1, PAR2, ... can optionally be other input
+ arguments of any type that have to be passed to the function
+ defined by @FUN.
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ ODEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ For example,
+ function y = odepkg_equations_lorenz (t, x)
+ y = [10 * (x(2) - x(1));
+ x(1) * (28 - x(3));
+ x(1) * x(2) - 8/3 * x(3)];
+ endfunction
+
+ vopt = odeset ("InitialStep", 1e-3, "MaxStep", 1e-1, \\
+ "OutputFcn", @odephas3, "Refine", 5);
+ ode5r (@odepkg_equations_lorenz, [0, 25], [3 15 1], vopt);
+
+ -- Function File: [] = oders (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,
+ ...])
+ -- Command: [SOL] = oders (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = oders (@FUN, SLOT, INIT, [OPT],
+ [PAR1, PAR2, ...])
+ This function file can be used to solve a set of non-stiff or
+ stiff ordinary differential equations (ODEs) and non-stiff or
+ stiff differential algebraic equations (DAEs). This function file
+ is a wrapper to Hairer's and Wanner's Fortran solver `rodas.f'.
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ ODEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, OPT can optionally be a
+ structure array that keeps the options created with the command
+ `odeset' and PAR1, PAR2, ... can optionally be other input
+ arguments of any type that have to be passed to the function
+ defined by @FUN.
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ ODEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ For example,
+ function y = odepkg_equations_lorenz (t, x)
+ y = [10 * (x(2) - x(1));
+ x(1) * (28 - x(3));
+ x(1) * x(2) - 8/3 * x(3)];
+ endfunction
+
+ vopt = odeset ("InitialStep", 1e-3, "MaxStep", 1e-1, \\
+ "OutputFcn", @odephas3, "Refine", 5);
+ oders (@odepkg_equations_lorenz, [0, 25], [3 15 1], vopt);
+
+ -- Command: [] = odesx (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [SOL] = odesx (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
+ -- Command: [T, Y, [XE, YE, IE]] = odesx (@FUN, SLOT, INIT, [OPT],
+ [PAR1, PAR2, ...])
+ This function file can be used to solve a set of stiff or
+ non-stiff ordinary differential equations (ODEs) and non-stiff or
+ stiff differential algebraic equations (DAEs). This function file
+ is a wrapper to Hairer's and Wanner's Fortran solver `seulex.f'.
+
+ If this function is called with no return argument then plot the
+ solution over time in a figure window while solving the set of
+ ODEs that are defined in a function and specified by the function
+ handle @FUN. The second input argument SLOT is a double vector
+ that defines the time slot, INIT is a double vector that defines
+ the initial values of the states, OPT can optionally be a
+ structure array that keeps the options created with the command
+ `odeset' and PAR1, PAR2, ... can optionally be other input
+ arguments of any type that have to be passed to the function
+ defined by @FUN.
+
+ If this function is called with one return argument then return
+ the solution SOL of type structure array after solving the set of
+ ODEs. The solution SOL has the fields X of type double column
+ vector for the steps chosen by the solver, Y of type double column
+ vector for the solutions at each time step of X, SOLVER of type
+ string for the solver name and optionally the extended time stamp
+ information XE, the extended solution information YE and the
+ extended index information IE all of type double column vector
+ that keep the informations of the event function if an event
+ function handle is set in the option argument OPT.
+
+ If this function is called with more than one return argument then
+ return the time stamps T, the solution values Y and optionally the
+ extended time stamp information XE, the extended solution
+ information YE and the extended index information IE all of type
+ double column vector.
+
+ For example,
+ function y = odepkg_equations_lorenz (t, x)
+ y = [10 * (x(2) - x(1));
+ x(1) * (28 - x(3));
+ x(1) * x(2) - 8/3 * x(3)];
+ endfunction
+
+ vopt = odeset ("InitialStep", 1e-3, "MaxStep", 1e-1, \\
+ "OutputFcn", @odephas3, "Refine", 5);
+ odesx (@odepkg_equations_lorenz, [0, 25], [3 15 1], vopt);
+
+\1f
+File: odepkg.info, Node: Programmers Guide, Next: Function Index, Prev: Users Guide, Up: Top
+
+3 Programmers Guide
+*******************
+
+* Menu:
+
+* Missing features:: The TODO-list for missing features
+
+\1f
+File: odepkg.info, Node: Missing features, Prev: Programmers Guide, Up: Programmers Guide
+
+3.1 Missing features
+====================
+
+If somebody want to help improving OdePkg then please contact the
+Octave-Forge developer team sending your modifications via the
+mailing-list <octave-dev@lists.sourceforge.net>. Here is a TODO-list
+about missing features:
+ * Partial Derivative equations (PDEs) and Boundary Value Equations
+ (BVPs) cannot be solved with the solvers of the OdePkg. The wish
+ for solving PDEs and BVPs definitely is there (maybe you'd like to
+ create another package and call that package PdePkg, which is just
+ an idea).
+
+ * Some options that can be set with propietary solver products are
+ not available within OdePkg. Have a look at section *Note
+ ODE/DAE/IDE/DDE options:: about which options can be set and which
+ options are not supported and help improving the command `odeset',
+ `odepkg_structure_check' and the solvers that have to deal with
+ these options.
+
+ * OdePkg currently is missing the command `decic' which computes an
+ initial constraint for IDEs before solving. The command `deval'
+ also is missing that interpolates the results that can be obtained
+ from the solvers after solving and then plots the results in a new
+ figure. However, instead of using `deval' any of the commands
+ `interpX'.
+
+ * If you want to include your own solver within OdePkg then either
+ code in `*.m' or `*.cc'. Solvers in `*.m' are preferred. Choose a
+ GPL compatible license for your solver and send your solver file
+ to the mailing list.
+
+ * Before interfacing other solvers make sure that the core solver
+ file is available under a GPL-compatible license (if you'd like to
+ redistribute your wrapper with OdePkg). There can be found a lot
+ of solver files at `http://www.netlib.org' but most of them are
+ not GPL-compatible. Here is a list about authors and their solvers
+ that do have a GPL compatible license so that their codes can be
+ redistributed with OdePkg:
+
+ * Cecilia Magherini and Luigi Brugnano from the University of
+ Bari created the BIMD solver that is available at
+ `http://pitagora.dm.uniba.it/~testset/solvers/bimd.php'. This
+ solver can be used to solve stiff DAE equations. The
+ Fortran77 file has been released under the GNU GPL V2.
+
+ * Francesca Mazzia and Felice Iavernaro from the University of
+ Bari created the GAMD solver that is available at
+ `http://pitagora.dm.uniba.it/~testset/solvers/gamd.php'. This
+ solver can be used to solve stiff DAE equations. The
+ Fortran90 file has been released under the GNU GPL V2 but for
+ OdePkg a Fortran77 implementation would be preferred.
+
+ * Ernst Hairer and Gerhard Wanner have been written more
+ solvers that are released under a modified BSD license than
+ have been interfaced by OdePkg. Notable solvers that can be
+ found at `http://www.unige.ch/~hairer/software.html' are
+ explicit Runge-Kutta methods `dopri5' and `dop853' and
+ extrapolation methods `odex' and `odex2' for solving ODEs,
+ `retard' and `radar5' for solving DDEs.
+
+ * Jeff Cash has released some more Fortran77 solvers for
+ different kinds of differential equation problems than are
+ interfaced by OdePkg, check his website at
+ `http://www.ma.ic.ac.uk/~jcash'.
+
+
+\1f
+File: odepkg.info, Node: Function Index, Next: Index, Prev: Programmers Guide, Up: Top
+
+Function Index
+**************
+
+\0\b[index\0\b]
+* Menu:
+
+* ode23: M-File Function Reference.
+ (line 14)
+* ode23d: M-File Function Reference.
+ (line 60)
+* ode2r: Oct-File Function Reference.
+ (line 164)
+* ode45: M-File Function Reference.
+ (line 133)
+* ode45d: M-File Function Reference.
+ (line 181)
+* ode54: M-File Function Reference.
+ (line 254)
+* ode54d: M-File Function Reference.
+ (line 300)
+* ode5r: Oct-File Function Reference.
+ (line 210)
+* ode78: M-File Function Reference.
+ (line 375)
+* ode78d: M-File Function Reference.
+ (line 423)
+* odebda: Oct-File Function Reference.
+ (line 12)
+* odebdi: Oct-File Function Reference.
+ (line 62)
+* odebwe: M-File Function Reference.
+ (line 496)
+* odeexamples: M-File Function Reference.
+ (line 541)
+* odeget: M-File Function Reference.
+ (line 545)
+* odekdi: Oct-File Function Reference.
+ (line 113)
+* odephas2: M-File Function Reference.
+ (line 569)
+* odephas3: M-File Function Reference.
+ (line 603)
+* odepkg: M-File Function Reference.
+ (line 642)
+* odepkg_event_handle: M-File Function Reference.
+ (line 658)
+* odepkg_examples_dae: M-File Function Reference.
+ (line 689)
+* odepkg_examples_dde: M-File Function Reference.
+ (line 693)
+* odepkg_examples_ide: M-File Function Reference.
+ (line 697)
+* odepkg_examples_ode: M-File Function Reference.
+ (line 701)
+* odepkg_structure_check: M-File Function Reference.
+ (line 706)
+* odepkg_testsuite_calcmescd: M-File Function Reference.
+ (line 726)
+* odepkg_testsuite_calcscd: M-File Function Reference.
+ (line 743)
+* odepkg_testsuite_chemakzo: M-File Function Reference.
+ (line 760)
+* odepkg_testsuite_hires: M-File Function Reference.
+ (line 776)
+* odepkg_testsuite_implakzo: M-File Function Reference.
+ (line 792)
+* odepkg_testsuite_implrober: M-File Function Reference.
+ (line 809)
+* odepkg_testsuite_oregonator: M-File Function Reference.
+ (line 826)
+* odepkg_testsuite_pollution: M-File Function Reference.
+ (line 843)
+* odepkg_testsuite_robertson: M-File Function Reference.
+ (line 860)
+* odepkg_testsuite_transistor: M-File Function Reference.
+ (line 877)
+* odeplot: M-File Function Reference.
+ (line 893)
+* odeprint: M-File Function Reference.
+ (line 926)
+* oders: Oct-File Function Reference.
+ (line 259)
+* odeset: M-File Function Reference.
+ (line 966)
+* odesx: Oct-File Function Reference.
+ (line 306)
+
+\1f
+File: odepkg.info, Node: Index, Prev: Function Index, Up: Top
+
+Index
+*****
+
+\0\b[index\0\b]
+* Menu:
+
+* About OdePkg: About OdePkg. (line 6)
+* AbsTol option: ODE/DAE/IDE/DDE options.
+ (line 41)
+* BDF option: ODE/DAE/IDE/DDE options.
+ (line 373)
+* BDF solver: Cash modified BDF solvers.
+ (line 6)
+* Beginners guide: Beginners Guide. (line 6)
+* bugs: Reporting Bugs. (line 6)
+* Cash modified BDF: Cash modified BDF solvers.
+ (line 6)
+* dae equations: DAE equations. (line 6)
+* dae options: ODE/DAE/IDE/DDE options.
+ (line 6)
+* ddaskr solver: DDaskr direct method solver.
+ (line 6)
+* dde equations: DDE equations. (line 6)
+* dde options: ODE/DAE/IDE/DDE options.
+ (line 6)
+* decic: Missing features. (line 28)
+* deinstallation: Installation and deinstallation.
+ (line 6)
+* deval: Missing features. (line 28)
+* differential equations: Differential Equations.
+ (line 6)
+* Events option: ODE/DAE/IDE/DDE options.
+ (line 326)
+* foo example: The "foo" example. (line 6)
+* Hairer-Wanner: Hairer-Wanner solvers.
+ (line 6)
+* history: OdePkg history and roadmap.
+ (line 6)
+* ide equations: IDE equations. (line 6)
+* ide options: ODE/DAE/IDE/DDE options.
+ (line 6)
+* InitialSlope option: ODE/DAE/IDE/DDE options.
+ (line 114)
+* InitialStep option: ODE/DAE/IDE/DDE options.
+ (line 98)
+* installation: Installation and deinstallation.
+ (line 6)
+* Jacobian option: ODE/DAE/IDE/DDE options.
+ (line 211)
+* JPattern option: ODE/DAE/IDE/DDE options.
+ (line 251)
+* m-file reference: M-File Function Reference.
+ (line 6)
+* Mass option: ODE/DAE/IDE/DDE options.
+ (line 256)
+* MassSingular option: ODE/DAE/IDE/DDE options.
+ (line 308)
+* MaxNewtonIterations option: ODE/DAE/IDE/DDE options.
+ (line 383)
+* MaxOrder option: ODE/DAE/IDE/DDE options.
+ (line 351)
+* MaxStep option: ODE/DAE/IDE/DDE options.
+ (line 82)
+* missing features: Missing features. (line 6)
+* MStateDependence option: ODE/DAE/IDE/DDE options.
+ (line 280)
+* MvPattern option: ODE/DAE/IDE/DDE options.
+ (line 306)
+* NewtonTol option: ODE/DAE/IDE/DDE options.
+ (line 380)
+* NonNegative option: ODE/DAE/IDE/DDE options.
+ (line 311)
+* NormControl option: ODE/DAE/IDE/DDE options.
+ (line 60)
+* oct-file reference: Oct-File Function Reference.
+ (line 6)
+* ode equations: ODE equations. (line 6)
+* ode options: ODE/DAE/IDE/DDE options.
+ (line 6)
+* OutputFcn option: ODE/DAE/IDE/DDE options.
+ (line 117)
+* OutputSel option: ODE/DAE/IDE/DDE options.
+ (line 173)
+* performance: ODE solver performances.
+ (line 6)
+* Programmers guide: Programmers Guide. (line 6)
+* Refine option: ODE/DAE/IDE/DDE options.
+ (line 157)
+* RelTol option: ODE/DAE/IDE/DDE options.
+ (line 20)
+* roadmap: OdePkg history and roadmap.
+ (line 6)
+* Runge-Kutta: Runge-Kutta solvers. (line 6)
+* Runge-Kutta modified: Modified Runge-Kutta solvers.
+ (line 6)
+* solver families: Solver families. (line 6)
+* Stats option: ODE/DAE/IDE/DDE options.
+ (line 189)
+* Users guide: Users Guide. (line 6)
+* Vectorized option: ODE/DAE/IDE/DDE options.
+ (line 253)
+
+
+\1f
+Tag Table:
+Node: Top\7f77
+Node: Beginners Guide\7f1175
+Node: About OdePkg\7f2340
+Node: OdePkg history and roadmap\7f3448
+Node: Installation and deinstallation\7f8050
+Node: Reporting Bugs\7f8926
+Node: The "foo" example\7f9602
+Node: Users Guide\7f14647
+Node: Differential Equations\7f15889
+Node: ODE equations\7f16848
+Node: DAE equations\7f17635
+Node: IDE equations\7f19119
+Node: DDE equations\7f19840
+Node: Solver families\7f20556
+Node: Runge-Kutta solvers\7f21606
+Ref: Runge-Kutta solvers-Footnote-1\7f25521
+Node: Hairer-Wanner solvers\7f25973
+Node: Cash modified BDF solvers\7f27800
+Node: DDaskr direct method solver\7f29441
+Node: Modified Runge-Kutta solvers\7f31110
+Node: ODE solver performances\7f32910
+Node: ODE/DAE/IDE/DDE options\7f38580
+Node: M-File Function Reference\7f56436
+Node: Oct-File Function Reference\7f105239
+Node: Programmers Guide\7f123795
+Node: Missing features\7f124013
+Node: Function Index\7f127528
+Node: Index\7f133329
+\1f
+End Tag Table
git://git.creatis.insa-lyon.fr / CreaPhase.git / blobdiff