# HG changeset patch
# User Rafael Laboissiere <rafael@laboissiere.net>
# Date 1430511221 10800
#      Fri May 01 17:13:41 2015 -0300
# Node ID ab9f6b20c8be3c8c88415efa427f0186cdcdf703
# Parent  14b798b40e4f7003d09d13fdbb9b607cd40c9955
Fix spelling error "informations" -> "information"

The word "information", in the senses used in the code, is uncountable
and therefore takes no plural form.

diff -r 14b798b40e4f -r ab9f6b20c8be doc/dldfunref.texi
--- a/doc/dldfunref.texi	Thu Apr 16 18:45:23 2015 +0200
+++ b/doc/dldfunref.texi	Fri May 01 17:13:41 2015 -0300
@@ -6,7 +6,7 @@
 
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
@@ -32,7 +32,7 @@
 
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{y0} is a double vector that defines the initial values of the states, @var{dy0} is a double vector that defines the initial values of the derivatives, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of IDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of IDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
@@ -59,7 +59,7 @@
 
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{y0} is a double vector that defines the initial values of the states, @var{dy0} is a double vector that defines the initial values of the derivatives, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of IDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of IDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
@@ -86,7 +86,7 @@
 
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
@@ -112,7 +112,7 @@
 
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
@@ -138,7 +138,7 @@
 
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
@@ -164,7 +164,7 @@
 
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
diff -r 14b798b40e4f -r ab9f6b20c8be doc/mfunref.texi
--- a/doc/mfunref.texi	Thu Apr 16 18:45:23 2015 +0200
+++ b/doc/mfunref.texi	Fri May 01 17:13:41 2015 -0300
@@ -7,7 +7,7 @@
 
 The first input argument must be a function_handle or an inline function that defines the set of ODEs: @code{y' = f(t,y)}. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must have just one output argument that should be a vector.
 
-The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has not empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has not empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 
 The third input argument must contain the initial value for the unknown. If this is a vector then the solution @var{y} will be a matrix in which each column is the solution for the corresponding initial value in @var{init}.
 
@@ -29,7 +29,7 @@
 
 The first input argument must be a function_handle or an inline function that defines the set of ODE: @code{y' = f(t,y)}. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must have just one output argument that should be a vector.
 
-The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 
 The third input argument must contain the initial value for the unknown. If this is a vector then the solution @var{y} will be a matrix in which each column is the solution for the corresponding initial value in @var{init}.
 
@@ -57,7 +57,7 @@
 y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), @dots{} 
 @end example
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
@@ -109,7 +109,7 @@
 
 The first input argument must be a function_handle or an inline function that defines the set of ODE: @code{y' = f(t,y)}. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must have just one output argument.
 
-The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 
 The third input argument must contain the initial value for the unknown. If this is a vector then the solution @var{y} will be a matrix in which each column is the solution for the corresponding initial value in @var{init}.
 
@@ -137,7 +137,7 @@
 y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), @dots{} 
 @end example
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
@@ -188,7 +188,7 @@
 
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
@@ -218,7 +218,7 @@
 y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), @dots{} 
 @end example
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
@@ -269,7 +269,7 @@
 
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
@@ -299,7 +299,7 @@
 y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), @dots{} 
 @end example
 
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 
@@ -353,7 +353,7 @@
  
 As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must have just one output argument that should be a vector.
 
-The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 
 The third input argument must contain the initial value for the unknown. If this is a vector then the solution @var{y} will be a matrix in which each column is the solution for the corresponding initial value in @var{init}.
 
@@ -379,7 +379,7 @@
 
 The first input argument must be a function_handle or an inline function that defines the set of ODE: @code{y' = f(t,y)}. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must have just one output argument that should be a vector.
 
-The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 
 The third input argument must contain the initial value for the unknown. If this is a vector then the solution @var{y} will be a matrix in which each column is the solution for the corresponding initial value in @var{init}.
 
@@ -535,7 +535,7 @@
 
 @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_chemakzo (@var{@@solver}, @var{reltol})
 
-If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance informations about the chemical AKZO Nobel testsuite of differential algebraic equations after solving (DAE--test).
+If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance information about the chemical AKZO Nobel testsuite of differential algebraic equations after solving (DAE--test).
 
 Run examples with the command
 @example
@@ -547,7 +547,7 @@
 
 @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_hires (@var{@@solver}, @var{reltol})
 
-If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance informations about the HIRES testsuite of ordinary differential equations after solving (ODE--test).
+If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance information about the HIRES testsuite of ordinary differential equations after solving (ODE--test).
 
 Run examples with the command
 @example
@@ -559,7 +559,7 @@
 
 @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_implakzo (@var{@@solver}, @var{reltol})
 
-If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance informations about the chemical AKZO Nobel testsuite of implicit differential algebraic equations after solving (IDE--test).
+If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance information about the chemical AKZO Nobel testsuite of implicit differential algebraic equations after solving (IDE--test).
 
 Run examples with the command
 @example
@@ -571,7 +571,7 @@
 
 @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_implrober (@var{@@solver}, @var{reltol})
 
-If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance informations about the implicit form of the modified ROBERTSON testsuite of implicit differential algebraic equations after solving (IDE--test).
+If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance information about the implicit form of the modified ROBERTSON testsuite of implicit differential algebraic equations after solving (IDE--test).
 
 Run examples with the command
 @example
@@ -583,7 +583,7 @@
 
 @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_oregonator (@var{@@solver}, @var{reltol})
 
-If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance informations about the OREGONATOR testsuite of ordinary differential equations after solving (ODE--test).
+If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance information about the OREGONATOR testsuite of ordinary differential equations after solving (ODE--test).
 
 Run examples with the command
 @example
@@ -595,7 +595,7 @@
 
 @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_pollution (@var{@@solver}, @var{reltol})
 
-If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return the cell array @var{solution} with performance informations about the POLLUTION testsuite of ordinary differential equations after solving (ODE--test).
+If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return the cell array @var{solution} with performance information about the POLLUTION testsuite of ordinary differential equations after solving (ODE--test).
 
 Run examples with the command
 @example
@@ -607,7 +607,7 @@
 
 @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_robertson (@var{@@solver}, @var{reltol})
 
-If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance informations about the modified ROBERTSON testsuite of differential algebraic equations after solving (DAE--test).
+If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance information about the modified ROBERTSON testsuite of differential algebraic equations after solving (DAE--test).
 
 Run examples with the command
 @example
@@ -619,7 +619,7 @@
 
 @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_transistor (@var{@@solver}, @var{reltol})
 
-If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return the cell array @var{solution} with performance informations about the TRANSISTOR testsuite of differential algebraic equations after solving (DAE--test).
+If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return the cell array @var{solution} with performance information about the TRANSISTOR testsuite of differential algebraic equations after solving (DAE--test).
 
 Run examples with the command
 @example
@@ -697,7 +697,7 @@
 
 The second input argument must be a function_handle or an inline function that defines the constraints of the problem @math{g(q)=0}. So that this function must take one input argument and must return a vector or (if you want to give also the constraint gradient and constraint Hessian) cell containing as first element the equations defining the holonomic constraints and as second and third elements respectively the gradient and the Hessian of this constraints function (this is not mandatory but it can speedup the computation and results will be more accurated).
 
-The third input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+The third input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 
 The fourth input argument must contain the initial value for the unknown. This must be a row or column vector containing the generalized  coordinates in its first half and the generalized momenta in the second half. Each momentum correspond to the coordinate with the same  relative position inside the vector of initial conditions.
 
@@ -724,7 +724,7 @@
 @end ifnothtml
 where @math{H(t,[q;p])} is the Hamiltonian of the problem, @math{q} are generalized coordinates and @math{p} are generalized momenta. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must return a vector or (if you want to pass also the Hamiltonian Hessian) a cell containing as first element the Hamilton's equations of motion (the previous system of equations) and as second element the Hessian of the Hamiltonian (this is not mandatory but it can speedup the computation).
 
-The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 
 The third input argument must contain the initial value for the unknown. This must contain the generalized coordinates in its first half and the generalized momenta in the second half. Each momentum correspond to the coordinate with the same relative position inside the vector of initial conditions.
 
@@ -751,7 +751,7 @@
 @end ifnothtml
 where @math{H(t,[q;p])} is the Hamiltonian of the problem, @math{q} are generalized coordinates and @math{p} are generalized momenta. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must return a vector or (if you want to pass also the Hamiltonian Hessian) a cell containing as first element the Hamilton's equations of motion (the previous system of equations) and as second element the Hessian of the Hamiltonian (this is not mandatory but it can speedup the computation).
 
-The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 
 The third input argument must contain the initial value for the unknown. This must contain the generalized coordinates in its first half and the generalized momenta in the second half. Each momentum correspond to the coordinate with the same relative position inside the vector of initial conditions.
 
@@ -778,7 +778,7 @@
 @end ifnothtml
 where @math{H(t,[q;p])} is the Hamiltonian of the problem, @math{q} are generalized coordinates and @math{p} are generalized momenta. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must return a vector or (if you want to pass also the Hamiltonian Hessian) a cell containing as first element the Hamilton's equations of motion (the previous system of equations) and as second element the Hessian of the Hamiltonian (this is not mandatory but it can speedup the computation).
 
-The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 
 The third input argument must contain the initial value for the unknown. This must contain the generalized coordinates in its first half and the generalized momenta in the second half. Each momentum correspond to the coordinate with the same relative position inside the vector of initial conditions.
 
@@ -805,7 +805,7 @@
 @end ifnothtml
 where @math{a(t,q)} is the acceleration of the system, @math{q} are the generalized coordinates and @math{v} are the generalized velocities. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must return a cell or a vector containing the equations of the previous system.
 
-The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 
 The third input argument must contain the initial value for the unknown. This must contain the generalized coordinates in its first half and the generalized momenta in the second half. Each momentum correspond to the coordinate with the same relative position inside the vector of initial conditions.
 
diff -r 14b798b40e4f -r ab9f6b20c8be inst/ode12.m
--- a/inst/ode12.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/ode12.m	Fri May 01 17:13:41 2015 -0300
@@ -25,7 +25,7 @@
 %# 
 %# The first input argument must be a function_handle or an inline function that defines the set of ODEs: @code{y' = f(t,y)}. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must have just one output argument that should be a vector.
 %# 
-%# The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has not empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+%# The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has not empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 %# 
 %# The third input argument must contain the initial value for the unknown. If this is a vector then the solution @var{y} will be a matrix in which each column is the solution for the corresponding initial value in @var{init}.
 %# 
diff -r 14b798b40e4f -r ab9f6b20c8be inst/ode23.m
--- a/inst/ode23.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/ode23.m	Fri May 01 17:13:41 2015 -0300
@@ -26,7 +26,7 @@
 %# 
 %# The first input argument must be a function_handle or an inline function that defines the set of ODE: @code{y' = f(t,y)}. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must have just one output argument that should be a vector.
 %# 
-%# The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+%# The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 %# 
 %# The third input argument must contain the initial value for the unknown. If this is a vector then the solution @var{y} will be a matrix in which each column is the solution for the corresponding initial value in @var{init}.
 %# 
diff -r 14b798b40e4f -r ab9f6b20c8be inst/ode23d.m
--- a/inst/ode23d.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/ode23d.m	Fri May 01 17:13:41 2015 -0300
@@ -30,7 +30,7 @@
 %# y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), @dots{} 
 %# @end example
 %#
-%# If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+%# If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 %#
 %# If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 %#
diff -r 14b798b40e4f -r ab9f6b20c8be inst/ode45.m
--- a/inst/ode45.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/ode45.m	Fri May 01 17:13:41 2015 -0300
@@ -26,7 +26,7 @@
 %# 
 %# The first input argument must be a function_handle or an inline function that defines the set of ODE: @code{y' = f(t,y)}. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must have just one output argument.
 %# 
-%# The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+%# The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 %# 
 %# The third input argument must contain the initial value for the unknown. If this is a vector then the solution @var{y} will be a matrix in which each column is the solution for the corresponding initial value in @var{init}.
 %# 
diff -r 14b798b40e4f -r ab9f6b20c8be inst/ode45d.m
--- a/inst/ode45d.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/ode45d.m	Fri May 01 17:13:41 2015 -0300
@@ -36,7 +36,7 @@
 %# If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of 
 %# type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name 
 %# and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+%# information of the event function if an event function handle is set in the option argument @var{opt}.
 %#
 %# If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the 
 %# extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
diff -r 14b798b40e4f -r ab9f6b20c8be inst/ode54.m
--- a/inst/ode54.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/ode54.m	Fri May 01 17:13:41 2015 -0300
@@ -26,7 +26,7 @@
 %#
 %# The first input argument must be a function_handle or an inline function that defines the set of ODE: @code{y' = f(t,y)}. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must have just one output argument.
 %#
-%# The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+%# The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 %#
 %# The third input argument must contain the initial value for the unknown. If this is a vector then the solution @var{y} will be a matrix in which each column is the solution for the corresponding initial value in @var{init}.
 %#
diff -r 14b798b40e4f -r ab9f6b20c8be inst/ode54d.m
--- a/inst/ode54d.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/ode54d.m	Fri May 01 17:13:41 2015 -0300
@@ -30,7 +30,7 @@
 %# y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), @dots{} 
 %# @end example
 %#
-%# If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+%# If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 %#
 %# If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 %#
diff -r 14b798b40e4f -r ab9f6b20c8be inst/ode78.m
--- a/inst/ode78.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/ode78.m	Fri May 01 17:13:41 2015 -0300
@@ -23,7 +23,7 @@
 %#
 %# 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.
 %#
-%# If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+%# If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 %#
 %# If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 %#
diff -r 14b798b40e4f -r ab9f6b20c8be inst/ode78d.m
--- a/inst/ode78d.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/ode78d.m	Fri May 01 17:13:41 2015 -0300
@@ -30,7 +30,7 @@
 %# y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), @dots{} 
 %# @end example
 %#
-%# If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.
+%# If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of DDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.
 %#
 %# If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.
 %#
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odeRATTLE.m
--- a/inst/odeRATTLE.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odeRATTLE.m	Fri May 01 17:13:41 2015 -0300
@@ -38,7 +38,7 @@
 %# 
 %# The second input argument must be a function_handle or an inline function that defines the constraints of the problem @math{g(q)=0}. So that this function must take one input argument and must return a vector or (if you want to give also the constraint gradient and constraint Hessian) cell containing as first element the equations defining the holonomic constraints and as second and third elements respectively the gradient and the Hessian of this constraints function (this is not mandatory but it can speedup the computation and results will be more accurated).
 %# 
-%# The third input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+%# The third input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 %# 
 %# The fourth input argument must contain the initial value for the unknown. This must be a row or column vector containing the generalized  coordinates in its first half and the generalized momenta in the second half. Each momentum correspond to the coordinate with the same  relative position inside the vector of initial conditions.
 %# 
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odeSE.m
--- a/inst/odeSE.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odeSE.m	Fri May 01 17:13:41 2015 -0300
@@ -36,7 +36,7 @@
 %# @end ifnothtml
 %# where @math{H(t,[q;p])} is the Hamiltonian of the problem, @math{q} are generalized coordinates and @math{p} are generalized momenta. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must return a vector or (if you want to pass also the Hamiltonian Hessian) a cell containing as first element the Hamilton's equations of motion (the previous system of equations) and as second element the Hessian of the Hamiltonian (this is not mandatory but it can speedup the computation).
 %# 
-%# The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+%# The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 %# 
 %# The third input argument must contain the initial value for the unknown. This must contain the generalized coordinates in its first half and the generalized momenta in the second half. Each momentum correspond to the coordinate with the same relative position inside the vector of initial conditions.
 %# 
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odeSPVI.m
--- a/inst/odeSPVI.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odeSPVI.m	Fri May 01 17:13:41 2015 -0300
@@ -36,7 +36,7 @@
 %# @end ifnothtml
 %# where @math{H(t,[q;p])} is the Hamiltonian of the problem, @math{q} are generalized coordinates and @math{p} are generalized momenta. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must return a vector or (if you want to pass also the Hamiltonian Hessian) a cell containing as first element the Hamilton's equations of motion (the previous system of equations) and as second element the Hessian of the Hamiltonian (this is not mandatory but it can speedup the computation).
 %# 
-%# The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+%# The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 %# 
 %# The third input argument must contain the initial value for the unknown. This must contain the generalized coordinates in its first half and the generalized momenta in the second half. Each momentum correspond to the coordinate with the same relative position inside the vector of initial conditions.
 %# 
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odeSV.m
--- a/inst/odeSV.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odeSV.m	Fri May 01 17:13:41 2015 -0300
@@ -36,7 +36,7 @@
 %# @end ifnothtml
 %# where @math{H(t,[q;p])} is the Hamiltonian of the problem, @math{q} are generalized coordinates and @math{p} are generalized momenta. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must return a vector or (if you want to pass also the Hamiltonian Hessian) a cell containing as first element the Hamilton's equations of motion (the previous system of equations) and as second element the Hessian of the Hamiltonian (this is not mandatory but it can speedup the computation).
 %# 
-%# The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+%# The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 %# 
 %# The third input argument must contain the initial value for the unknown. This must contain the generalized coordinates in its first half and the generalized momenta in the second half. Each momentum correspond to the coordinate with the same relative position inside the vector of initial conditions.
 %# 
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odeVV.m
--- a/inst/odeVV.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odeVV.m	Fri May 01 17:13:41 2015 -0300
@@ -36,7 +36,7 @@
 %# @end ifnothtml
 %# where @math{a(t,q)} is the acceleration of the system, @math{q} are the generalized coordinates and @math{v} are the generalized velocities. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must return a cell or a vector containing the equations of the previous system.
 %# 
-%# The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+%# The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 %# 
 %# The third input argument must contain the initial value for the unknown. This must contain the generalized coordinates in its first half and the generalized momenta in the second half. Each momentum correspond to the coordinate with the same relative position inside the vector of initial conditions.
 %# 
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odebwe.m
--- a/inst/odebwe.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odebwe.m	Fri May 01 17:13:41 2015 -0300
@@ -28,7 +28,7 @@
 %#  
 %# As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must have just one output argument that should be a vector.
 %# 
-%# The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+%# The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 %# 
 %# The third input argument must contain the initial value for the unknown. If this is a vector then the solution @var{y} will be a matrix in which each column is the solution for the corresponding initial value in @var{init}.
 %# 
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odefwe.m
--- a/inst/odefwe.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odefwe.m	Fri May 01 17:13:41 2015 -0300
@@ -25,7 +25,7 @@
 %# 
 %# The first input argument must be a function_handle or an inline function that defines the set of ODE: @code{y' = f(t,y)}. As described above, this function must take two input arguments, where the first is the time and the second the unknowns, and must have just one output argument that should be a vector.
 %# 
-%# The second input argument must contain time informations. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
+%# The second input argument must contain time information. Usually it should be a vector with at least two elements which define the initial and the final time instants; if the elements are more than two, then the solution will be evaluated also at these intermediate time instants unless the integrate function called is the @command{integrate_n_steps}. If there is only one time value, then it will give an error unless the options structure has no empty fields named @var{"TimeStepNumber"} and @var{"TimeStepSize"}. If the option @var{"TimeStepSize"} is not empty, then the stepper called will be @command{integrate_const}, if also @var{"TimeStepNumber"} is not empty it will be called the integrate function @command{integrate_n_steps}, otherwise it will be called @command{integrate_adaptive}. For this last possibility the user can set the tolerance for the timestep computation by setting a value to the option @var{"Tau"}, that as default value has @math{1.e-6}.
 %# 
 %# The third input argument must contain the initial value for the unknown. If this is a vector then the solution @var{y} will be a matrix in which each column is the solution for the corresponding initial value in @var{init}.
 %# 
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odepkg_testsuite_chemakzo.m
--- a/inst/odepkg_testsuite_chemakzo.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odepkg_testsuite_chemakzo.m	Fri May 01 17:13:41 2015 -0300
@@ -17,7 +17,7 @@
 %# -*- texinfo -*-
 %# @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_chemakzo (@var{@@solver}, @var{reltol})
 %#
-%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance informations about the chemical AKZO Nobel testsuite of differential algebraic equations after solving (DAE--test).
+%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance information about the chemical AKZO Nobel testsuite of differential algebraic equations after solving (DAE--test).
 %#
 %# Run examples with the command
 %# @example
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odepkg_testsuite_hires.m
--- a/inst/odepkg_testsuite_hires.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odepkg_testsuite_hires.m	Fri May 01 17:13:41 2015 -0300
@@ -17,7 +17,7 @@
 %# -*- texinfo -*-
 %# @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_hires (@var{@@solver}, @var{reltol})
 %#
-%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance informations about the HIRES testsuite of ordinary differential equations after solving (ODE--test).
+%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance information about the HIRES testsuite of ordinary differential equations after solving (ODE--test).
 %#
 %# Run examples with the command
 %# @example
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odepkg_testsuite_implakzo.m
--- a/inst/odepkg_testsuite_implakzo.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odepkg_testsuite_implakzo.m	Fri May 01 17:13:41 2015 -0300
@@ -17,7 +17,7 @@
 %# -*- texinfo -*-
 %# @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_implakzo (@var{@@solver}, @var{reltol})
 %#
-%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance informations about the chemical AKZO Nobel testsuite of implicit differential algebraic equations after solving (IDE--test).
+%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance information about the chemical AKZO Nobel testsuite of implicit differential algebraic equations after solving (IDE--test).
 %#
 %# Run examples with the command
 %# @example
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odepkg_testsuite_implrober.m
--- a/inst/odepkg_testsuite_implrober.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odepkg_testsuite_implrober.m	Fri May 01 17:13:41 2015 -0300
@@ -17,7 +17,7 @@
 %# -*- texinfo -*-
 %# @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_implrober (@var{@@solver}, @var{reltol})
 %#
-%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance informations about the implicit form of the modified ROBERTSON testsuite of implicit differential algebraic equations after solving (IDE--test).
+%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance information about the implicit form of the modified ROBERTSON testsuite of implicit differential algebraic equations after solving (IDE--test).
 %#
 %# Run examples with the command
 %# @example
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odepkg_testsuite_impltrans.m
--- a/inst/odepkg_testsuite_impltrans.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odepkg_testsuite_impltrans.m	Fri May 01 17:13:41 2015 -0300
@@ -17,7 +17,7 @@
 %# -*- texinfo -*-
 %# @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_impltrans (@var{@@solver}, @var{reltol})
 %#
-%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return the cell array @var{solution} with performance informations about the TRANSISTOR testsuite of implicit differential algebraic equations after solving (IDE--test).
+%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return the cell array @var{solution} with performance information about the TRANSISTOR testsuite of implicit differential algebraic equations after solving (IDE--test).
 %#
 %# Run examples with the command
 %# @example
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odepkg_testsuite_oregonator.m
--- a/inst/odepkg_testsuite_oregonator.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odepkg_testsuite_oregonator.m	Fri May 01 17:13:41 2015 -0300
@@ -17,7 +17,7 @@
 %# -*- texinfo -*-
 %# @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_oregonator (@var{@@solver}, @var{reltol})
 %#
-%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance informations about the OREGONATOR testsuite of ordinary differential equations after solving (ODE--test).
+%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance information about the OREGONATOR testsuite of ordinary differential equations after solving (ODE--test).
 %#
 %# Run examples with the command
 %# @example
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odepkg_testsuite_pollution.m
--- a/inst/odepkg_testsuite_pollution.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odepkg_testsuite_pollution.m	Fri May 01 17:13:41 2015 -0300
@@ -17,7 +17,7 @@
 %# -*- texinfo -*-
 %# @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_pollution (@var{@@solver}, @var{reltol})
 %#
-%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return the cell array @var{solution} with performance informations about the POLLUTION testsuite of ordinary differential equations after solving (ODE--test).
+%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return the cell array @var{solution} with performance information about the POLLUTION testsuite of ordinary differential equations after solving (ODE--test).
 %#
 %# Run examples with the command
 %# @example
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odepkg_testsuite_robertson.m
--- a/inst/odepkg_testsuite_robertson.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odepkg_testsuite_robertson.m	Fri May 01 17:13:41 2015 -0300
@@ -17,7 +17,7 @@
 %# -*- texinfo -*-
 %# @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_robertson (@var{@@solver}, @var{reltol})
 %#
-%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance informations about the modified ROBERTSON testsuite of differential algebraic equations after solving (DAE--test).
+%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return a cell array @var{solution} with performance information about the modified ROBERTSON testsuite of differential algebraic equations after solving (DAE--test).
 %#
 %# Run examples with the command
 %# @example
diff -r 14b798b40e4f -r ab9f6b20c8be inst/odepkg_testsuite_transistor.m
--- a/inst/odepkg_testsuite_transistor.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/odepkg_testsuite_transistor.m	Fri May 01 17:13:41 2015 -0300
@@ -17,7 +17,7 @@
 %# -*- texinfo -*-
 %# @deftypefn {Function File} {[@var{solution}] =} odepkg_testsuite_transistor (@var{@@solver}, @var{reltol})
 %#
-%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return the cell array @var{solution} with performance informations about the TRANSISTOR testsuite of differential algebraic equations after solving (DAE--test).
+%# If this function is called with two input arguments and the first input argument @var{@@solver} is a function handle describing an OdePkg solver and the second input argument @var{reltol} is a double scalar describing the relative error tolerance then return the cell array @var{solution} with performance information about the TRANSISTOR testsuite of differential algebraic equations after solving (DAE--test).
 %#
 %# Run examples with the command
 %# @example
diff -r 14b798b40e4f -r ab9f6b20c8be inst/steppers/rattle.m
--- a/inst/steppers/rattle.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/steppers/rattle.m	Fri May 01 17:13:41 2015 -0300
@@ -56,7 +56,7 @@
 
 function varargout = rattle (f, t, x, dt, options)
 
-  %# getting informations about the Hessian of the Hamiltonian and the Hessian of the constraint function
+  %# getting information about the Hessian of the Hamiltonian and the Hessian of the constraint function
   H  = odeget (options, 'HamiltonianHessFcn', [], 'fast');
   GG = odeget (options, 'ConstraintHessFcn', [], 'fast');
 
@@ -74,7 +74,7 @@
     opts.Restart   = odeget (options, 'Restart', 20, 'fast_not_empty');
   endif
 
-  %# getting informations about the constraints function and its gradient
+  %# getting information about the constraints function and its gradient
   g = odeget (options, 'ConstraintFcn', [], 'fast');
   G = odeget (options, 'ConstraintGradFcn', [], 'fast');
 
diff -r 14b798b40e4f -r ab9f6b20c8be inst/steppers/spectral_var_int.m
--- a/inst/steppers/spectral_var_int.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/steppers/spectral_var_int.m	Fri May 01 17:13:41 2015 -0300
@@ -76,7 +76,7 @@
 
 function varargout = spectral_var_int (f, t, x, dt, options)
 
-  %# getting informations about the Hessian of the Hamiltonian
+  %# getting information about the Hessian of the Hamiltonian
   H = odeget (options, 'HamiltonianHessFcn', [], 'fast');
   if ( ~isempty(H) )
     opts = optimset ('Jacobian', 'on', 'TolFun', options.NewtonTol, 'MaxIter', options.MaxNewtonIterations);
@@ -91,7 +91,7 @@
     opts.Restart   = odeget (options, 'Restart', 20, 'fast_not_empty');
   endif
 
-  %# getting informations about Gauss quadrature rule and Legendre polynomials
+  %# getting information about Gauss quadrature rule and Legendre polynomials
   q_dofs         = odeget (options, 'Q_DoFs', 2, 'fast_not_empty');
   p_dofs         = odeget (options, 'P_DoFs', 2, 'fast_not_empty');
   nodes          = odeget (options, 'Nodes', [-0.57735 0.57735], 'fast_not_empty');
diff -r 14b798b40e4f -r ab9f6b20c8be inst/steppers/stormer_verlet.m
--- a/inst/steppers/stormer_verlet.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/steppers/stormer_verlet.m	Fri May 01 17:13:41 2015 -0300
@@ -97,7 +97,7 @@
 
   else   %# if the system is implicit
 
-    %# getting informations about the Hessian of the Hamiltonian
+    %# getting information about the Hessian of the Hamiltonian
     H = odeget (options, 'HamiltonianHessFcn', [], 'fast');
     if (~isempty(H))
       opts = optimset ('Jacobian', 'on', 'TolFun', options.NewtonTol, 'MaxIter', options.MaxNewtonIterations);
diff -r 14b798b40e4f -r ab9f6b20c8be inst/steppers/symplectic_euler.m
--- a/inst/steppers/symplectic_euler.m	Thu Apr 16 18:45:23 2015 +0200
+++ b/inst/steppers/symplectic_euler.m	Fri May 01 17:13:41 2015 -0300
@@ -92,7 +92,7 @@
 
   else   %# if the system is implicit
 
-    %# getting informations about the Hessian of the Hamiltonian
+    %# getting information about the Hessian of the Hamiltonian
     H = odeget (options, 'HamiltonianHessFcn', [], 'fast');
     if( ~isempty(H) )
       opts = optimset ('Jacobian', 'on', 'TolFun', options.NewtonTol, 'MaxIter', options.MaxNewtonIterations);
diff -r 14b798b40e4f -r ab9f6b20c8be src/odepkg_auxiliary_functions.cc
--- a/src/odepkg_auxiliary_functions.cc	Thu Apr 16 18:45:23 2015 +0200
+++ b/src/odepkg_auxiliary_functions.cc	Fri May 01 17:13:41 2015 -0300
@@ -348,9 +348,9 @@
 /* -*- texinfo -*-
  * @deftypefn {Function} octave_value odepkg_auxiliary_makestats (octave_value_list vstats, octave_idx_type vprnt)
  *
- * Return an @var{octave_value} that contains fields about performance informations of a finished solving process. The input arguments of this function are
+ * Return an @var{octave_value} that contains fields about performance information of a finished solving process. The input arguments of this function are
  * @itemize @minus
- * @item @var{vstats}: The statistics informations list that has to be handled. The values that are treated have to be ordered as follows
+ * @item @var{vstats}: The statistics information list that has to be handled. The values that are treated have to be ordered as follows
  * @enumerate
  * @item Number of computed steps
  * @item Number of rejected steps
diff -r 14b798b40e4f -r ab9f6b20c8be src/odepkg_octsolver_ddaskr.cc
--- a/src/odepkg_octsolver_ddaskr.cc	Thu Apr 16 18:45:23 2015 +0200
+++ b/src/odepkg_octsolver_ddaskr.cc	Fri May 01 17:13:41 2015 -0300
@@ -205,7 +205,7 @@
 \n\
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{y0} is a double vector that defines the initial values of the states, @var{dy0} is a double vector that defines the initial values of the derivatives, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.\n\
 \n\
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of IDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.\n\
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of IDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.\n\
 \n\
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.\n\
 \n\
diff -r 14b798b40e4f -r ab9f6b20c8be src/odepkg_octsolver_mebdfdae.cc
--- a/src/odepkg_octsolver_mebdfdae.cc	Thu Apr 16 18:45:23 2015 +0200
+++ b/src/odepkg_octsolver_mebdfdae.cc	Fri May 01 17:13:41 2015 -0300
@@ -252,7 +252,7 @@
 \n\
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.\n\
 \n\
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.\n\
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.\n\
 \n\
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.\n\
 \n\
diff -r 14b798b40e4f -r ab9f6b20c8be src/odepkg_octsolver_mebdfi.cc
--- a/src/odepkg_octsolver_mebdfi.cc	Thu Apr 16 18:45:23 2015 +0200
+++ b/src/odepkg_octsolver_mebdfi.cc	Fri May 01 17:13:41 2015 -0300
@@ -327,7 +327,7 @@
 \n\
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{y0} is a double vector that defines the initial values of the states, @var{dy0} is a double vector that defines the initial values of the derivatives, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.\n\
 \n\
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of IDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.\n\
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of IDEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.\n\
 \n\
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.\n\
 \n\
diff -r 14b798b40e4f -r ab9f6b20c8be src/odepkg_octsolver_radau.cc
--- a/src/odepkg_octsolver_radau.cc	Thu Apr 16 18:45:23 2015 +0200
+++ b/src/odepkg_octsolver_radau.cc	Fri May 01 17:13:41 2015 -0300
@@ -255,7 +255,7 @@
 \n\
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.\n\
 \n\
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.\n\
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.\n\
 \n\
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.\n\
 \n\
diff -r 14b798b40e4f -r ab9f6b20c8be src/odepkg_octsolver_radau5.cc
--- a/src/odepkg_octsolver_radau5.cc	Thu Apr 16 18:45:23 2015 +0200
+++ b/src/odepkg_octsolver_radau5.cc	Fri May 01 17:13:41 2015 -0300
@@ -255,7 +255,7 @@
 \n\
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.\n\
 \n\
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.\n\
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.\n\
 \n\
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.\n\
 \n\
diff -r 14b798b40e4f -r ab9f6b20c8be src/odepkg_octsolver_rodas.cc
--- a/src/odepkg_octsolver_rodas.cc	Thu Apr 16 18:45:23 2015 +0200
+++ b/src/odepkg_octsolver_rodas.cc	Fri May 01 17:13:41 2015 -0300
@@ -469,7 +469,7 @@
 \n\
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.\n\
 \n\
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.\n\
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.\n\
 \n\
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.\n\
 \n\
diff -r 14b798b40e4f -r ab9f6b20c8be src/odepkg_octsolver_seulex.cc
--- a/src/odepkg_octsolver_seulex.cc	Thu Apr 16 18:45:23 2015 +0200
+++ b/src/odepkg_octsolver_seulex.cc	Fri May 01 17:13:41 2015 -0300
@@ -263,7 +263,7 @@
 \n\
 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 @var{@@fun}. The second input argument @var{slot} is a double vector that defines the time slot, @var{init} is a double vector that defines the initial values of the states, @var{opt} can optionally be a structure array that keeps the options created with the command @command{odeset} and @var{par1}, @var{par2}, @dots{} can optionally be other input arguments of any type that have to be passed to the function defined by @var{@@fun}.\n\
 \n\
-If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{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 @var{opt}.\n\
+If this function is called with one return argument then return the solution @var{sol} of type structure array after solving the set of ODEs. The solution @var{sol} has the fields @var{x} of type double column vector for the steps chosen by the solver, @var{y} of type double column vector for the solutions at each time step of @var{x}, @var{solver} of type string for the solver name and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector that keep the information of the event function if an event function handle is set in the option argument @var{opt}.\n\
 \n\
 If this function is called with more than one return argument then return the time stamps @var{t}, the solution values @var{y} and optionally the extended time stamp information @var{xe}, the extended solution information @var{ye} and the extended index information @var{ie} all of type double column vector.\n\
 \n\
