Revision of help pages for ode function (en_US, ru_RU). 94/10294/2
Stanislav KROTER [Thu, 24 Jan 2013 13:59:11 +0000 (19:59 +0600)]
Change-Id: I091fa4aca050484b7bc0e5c85651a0e35d3e5387

scilab/modules/differential_equations/help/en_US/ode.xml
scilab/modules/differential_equations/help/ru_RU/ode.xml

index 13b83e0..eabeb21 100644 (file)
@@ -4,11 +4,11 @@
  * Copyright (C) 2008 - INRIA
  * Copyright (C) 2011 - DIGITEO - Michael Baudin
  * Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  -->
@@ -77,7 +77,7 @@
                 <listitem>
                     <para>
                         a real constant or real vector of the same size as
-                        <literal>y</literal>, the relative tolerance.
+                        <varname>y</varname>, the relative tolerance.
                     </para>
                 </listitem>
             </varlistentry>
@@ -86,7 +86,7 @@
                 <listitem>
                     <para>
                         a real constant or real vectors of the same size as
-                        <literal>y</literal>, the absolute tolerance.
+                        <varname>y</varname>, the absolute tolerance.
                     </para>
                 </listitem>
             </varlistentry>
@@ -95,7 +95,7 @@
                 <listitem>
                     <para>
                         a function, external, string or list, the Jacobian of the
-                        function <literal>f</literal>.
+                        function <varname>f</varname>.
                     </para>
                 </listitem>
             </varlistentry>
     <refsection>
         <title>Description</title>
         <para>
-            <literal>ode</literal> solves explicit Ordinary Different Equations defined by:
+            <function>ode</function> solves explicit Ordinary Different Equations defined by:
         </para>
         <para>
             <latex>
             It is an interface to various solvers, in particular to ODEPACK.
         </para>
         <para>
-            In this help, we only describe the use of <literal>ode</literal> for
+            In this help, we only describe the use of <function>ode</function> for
             standard explicit ODE systems.
         </para>
         <para>
-            The simplest call of <literal>ode</literal> is:
-            <literal>y=ode(y0,t0,t,f)</literal> where <literal>y0</literal> is the
+            The simplest call of <function>ode</function> is:
+            <literal>y = ode(y0,t0,t,f)</literal> where <literal>y0</literal> is the
             vector of initial conditions, <literal>t0</literal> is the initial
             time, <literal>t</literal> is the vector of times at which the
-            solution <literal>y</literal> is computed and <literal>y</literal> is
+            solution <varname>y</varname> is computed and <varname>y</varname> is
             matrix of solution vectors
             <literal>y=[y(t(1)),y(t(2)),...]</literal>.
         </para>
         <para>
-            The input argument <literal>f</literal> defines the right hand side of the
+            The input argument <varname>f</varname> defines the right hand side of the
             first order differential equation. This argument is a function with a specific header.
         </para>
         <itemizedlist>
             <listitem>
                 <para>
-                    If <literal>f</literal> is a Scilab function, its calling sequence
+                    If <varname>f</varname> is a Scilab function, its calling sequence
                     must be
                 </para>
-                <screen><![CDATA[ 
+                <screen><![CDATA[
 ydot = f(t,y)
  ]]></screen>
                 <para>
                     where <literal>t</literal> is a real scalar (the time) and
-                    <literal>y</literal> is a real vector (the state) and
+                    <varname>y</varname> is a real vector (the state) and
                     <literal>ydot</literal> is a real vector (the first order derivative
                     dy/dt).
                 </para>
             </listitem>
             <listitem>
                 <para>
-                    If <literal>f</literal> is a string, it is 
+                    If <varname>f</varname> is a string, it is
                     the name of a Fortran subroutine or a C compiled function. For example, if
                     we call <literal>ode(y0,t0,t,"fex")</literal>, then the
                     subroutine <literal>fex</literal> is called.
@@ -204,23 +204,23 @@ ydot = f(t,y)
                 <para>
                     The Fortran routine must have the header:
                 </para>
-                <screen><![CDATA[ 
+                <screen><![CDATA[
 fex(n,t,y,ydot)
  ]]></screen>
                 <para>
                     where <literal>n</literal> is an integer, <literal>t</literal> is
-                    a double precision scalar, <literal>y</literal> and
+                    a double precision scalar, <varname>y</varname> and
                     <literal>ydot</literal> are double precision
                     vectors.
                 </para>
                 <para>
                     The C function must have the header:
                 </para>
-                <screen><![CDATA[ 
+                <screen><![CDATA[
 fex(int *n,double *t,double *y,double *ydot)
  ]]></screen>
                 <para>
-                    where <literal>t</literal> is the time, <literal>y</literal> the
+                    where <literal>t</literal> is the time, <varname>y</varname> the
                     state and <literal>ydot</literal> is the state derivative
                     (dy/dt).
                 </para>
@@ -233,10 +233,10 @@ fex(int *n,double *t,double *y,double *ydot)
             </listitem>
             <listitem>
                 <para>
-                    It may happen that the simulator <literal>f</literal> needs extra
+                    It may happen that the simulator <varname>f</varname> needs extra
                     arguments.
                     In this case, we can use the following feature.
-                    The <literal>f</literal> argument can also be a list
+                    The <varname>f</varname> argument can also be a list
                     <literal>lst=list(simuf,u1,u2,...un)</literal> where
                     <literal>simuf</literal> is a Scilab function with syntax:
                     <literal>ydot = f(t,y,u1,u2,...,un)</literal>
@@ -247,25 +247,25 @@ fex(int *n,double *t,double *y,double *ydot)
             </listitem>
         </itemizedlist>
         <para>
-            The function <literal>f</literal> can return a p-by-q matrix instead of a vector.
+            The function <varname>f</varname> can return a p-by-q matrix instead of a vector.
             With this matrix notation, we
             solve the <literal>n=p+q</literal> ODE's system
             <literal>dY/dt=F(t,Y)</literal> where <literal>Y</literal> is a
             <literal>p x q</literal> matrix. Then initial conditions,
             <literal>Y0</literal>, must also be a <literal>p x q</literal> matrix
-            and the result of <literal>ode</literal> is the <literal>p-by-q(T+1)</literal> matrix
+            and the result of <function>ode</function> is the <literal>p-by-q(T+1)</literal> matrix
             <literal>[Y(t_0),Y(t_1),...,Y(t_T)]</literal>.
         </para>
         <para>
-            The tolerances <literal>rtol</literal> and <literal>atol</literal> are
+            The tolerances <varname>rtol</varname> and <varname>atol</varname> are
             thresholds for relative and absolute estimated errors. The estimated
             error on <literal>y(i)</literal> is:
             <literal>rtol(i)*abs(y(i))+atol(i)</literal>
             and integration is carried out as far as this error is small for
-            all components of the state. If <literal>rtol</literal> and/or
-            <literal>atol</literal> is a constant <literal>rtol(i)</literal>
+            all components of the state. If <varname>rtol</varname> and/or
+            <varname>atol</varname> is a constant <literal>rtol(i)</literal>
             and/or <literal>atol(i)</literal> are set to this constant value.
-            Default values for <literal>rtol</literal> and <literal>atol</literal>
+            Default values for <varname>rtol</varname> and <varname>atol</varname>
             are respectively <literal>rtol=1.d-5</literal> and
             <literal>atol=1.d-7</literal> for most solvers and
             <literal>rtol=1.d-3</literal> and <literal>atol=1.d-4</literal> for
@@ -273,7 +273,7 @@ fex(int *n,double *t,double *y,double *ydot)
         </para>
         <para>
             For stiff problems, it is better to give the Jacobian of the RHS
-            function as the optional argument <literal>jac</literal>.
+            function as the optional argument <varname>jac</varname>.
             The Jacobian  is an external i.e. a function with specified syntax, or the name of a
             Fortran subroutine or a C function (character string) with specified
             calling sequence or a list.
@@ -281,31 +281,31 @@ fex(int *n,double *t,double *y,double *ydot)
         <itemizedlist>
             <listitem>
                 <para>
-                    If <literal>jac</literal> is a function the syntax should be
+                    If <varname>jac</varname> is a function the syntax should be
                     <literal>J=jac(t,y)</literal> where <literal>t</literal> is a real
-                    scalar (time) and <literal>y</literal> a real vector (state).
-                    The result matrix <literal>J</literal> must evaluate to df/dx i.e. 
+                    scalar (time) and <varname>y</varname> a real vector (state).
+                    The result matrix <literal>J</literal> must evaluate to df/dx i.e.
                     <literal>J(k,i) = dfk/dxi</literal> where <literal>fk</literal> is the
-                    <literal>k</literal>-th component of <literal>f</literal>.
+                    <literal>k</literal>-th component of <varname>f</varname>.
                 </para>
             </listitem>
             <listitem>
                 <para>
-                    If <literal>jac</literal> is a character string it refers to the
+                    If <varname>jac</varname> is a character string it refers to the
                     name of a Fortran subroutine or a C function.
                 </para>
                 <para>
                     The Fortran routine must have the header:
                 </para>
-                <screen><![CDATA[ 
-subroutine fex(n,t,y,ml,mu,J,nrpd) 
+                <screen><![CDATA[
+subroutine fex(n,t,y,ml,mu,J,nrpd)
 integer n,ml,mu,nrpd
 double precision t,y(*),J(*)
  ]]></screen>
                 <para>
                     The C function must have the header:
                 </para>
-                <screen><![CDATA[ 
+                <screen><![CDATA[
 void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
  ]]></screen>
                 <para>
@@ -315,16 +315,16 @@ void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
             </listitem>
             <listitem>
                 <para>
-                    If <literal>jac</literal> is a list the same conventions as for
-                    <literal>f</literal> apply.
+                    If <varname>jac</varname> is a list the same conventions as for
+                    <varname>f</varname> apply.
                 </para>
             </listitem>
         </itemizedlist>
         <para>
-            Optional arguments <literal>w</literal> and
-            <literal>iw</literal> are vectors for storing information returned by
+            Optional arguments <varname>w</varname> and
+            <varname>iw</varname> are vectors for storing information returned by
             the integration routine (see <link linkend="ode_optional_output">ode_optional_output</link> for details).
-            When these vectors are provided in RHS of <literal>ode</literal> the
+            When these vectors are provided in RHS of <function>ode</function> the
             integration re-starts with the same parameters as in its previous
             stop.
         </para>
@@ -338,7 +338,7 @@ void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
         <para>
             The type of problem solved and
             the method used depend on the value of the first optional argument
-            <literal>type</literal> which can be one of the following strings:
+            <varname>type</varname> which can be one of the following strings:
         </para>
         <variablelist>
             <varlistentry>
@@ -396,7 +396,7 @@ void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
                     <para>
                         Same solver as <literal>"rkf"</literal>, but the user interface
                         is very simple,
-                        i.e. only <literal>rtol</literal> and <literal>atol</literal>
+                        i.e. only <varname>rtol</varname> and <varname>atol</varname>
                         parameters can be passed to the solver. This is the simplest method
                         to try.
                     </para>
@@ -434,26 +434,26 @@ void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
             condition <literal>y(0)=0</literal>.
             We use the default solver.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 function ydot=f(t,y)
        ydot=y^2-y*sin(t)+cos(t)
 endfunction
 y0=0;
 t0=0;
 t=0:0.1:%pi;
-y=ode(y0,t0,t,f);
+y = ode(y0,t0,t,f);
 plot(t,y)
  ]]></programlisting>
         <para>
             In the following example, we solve the equation <literal>dy/dt=A*y</literal>.
-            The exact solution is <literal>y(t)=expm(A*t)*y(0)</literal>, where 
-            <literal>expm</literal> is the matrix exponential. 
+            The exact solution is <literal>y(t)=expm(A*t)*y(0)</literal>, where
+            <literal>expm</literal> is the matrix exponential.
             The unknown is the 2-by-1 matrix y(t).
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 function ydot=f(t,y)
     ydot=A*y
-endfunction 
+endfunction
 function J=Jacobian(t,y)
     J=A
 endfunction
@@ -468,11 +468,11 @@ expm(A*t)*y0
         <para>
             In the following example, we solve the ODE <literal>dx/dt = A x(t) + B u(t)</literal>
             with <literal>u(t)=sin(omega*t)</literal>.
-            Notice the extra arguments of <literal>f</literal>: 
+            Notice the extra arguments of <varname>f</varname>:
             <literal>A</literal>, <literal>u</literal>, <literal>B</literal>,
-            <literal>omega</literal> are passed to function <literal>f</literal> in a list.
+            <literal>omega</literal> are passed to function <varname>f</varname> in a list.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 function xdot=linear(t,x,A,u,B,omega)
     xdot=A*x+B*u(t,omega)
 endfunction
@@ -488,30 +488,30 @@ t=[0.1,0.2,0.5,1];
 ode(y0,t0,t,list(linear,A,u,B,omega))
  ]]></programlisting>
         <para>
-            In the following example, we solve the Riccati differential equation 
-            <literal>dX/dt=A'*X + X*A - X'*B*X + C</literal> where initial 
+            In the following example, we solve the Riccati differential equation
+            <literal>dX/dt=A'*X + X*A - X'*B*X + C</literal> where initial
             condition <literal>X(0)</literal> is the 2-by-2 identity matrix.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 function Xdot=ric(t,X,A,B,C)
     Xdot=A'*X+X*A-X'*B*X+C
-endfunction  
-A=[1,1;0,2]; 
-B=[1,0;0,1]; 
+endfunction
+A=[1,1;0,2];
+B=[1,0;0,1];
 C=[1,0;0,1];
 y0=eye(A);
 t0=0;
 t=0:0.1:%pi;
-X=ode(y0,t0,t,list(ric,A,B,C))
+X = ode(y0,t0,t,list(ric,A,B,C))
  ]]></programlisting>
         <para>
-            In the following example, we solve the differential equation 
-            <literal>dY/dt=A*Y</literal> where the unknown <literal>Y(t)</literal> 
-            is a 2-by-2 matrix. 
-            The exact solution is <literal>Y(t)=expm(A*t)</literal>, where 
+            In the following example, we solve the differential equation
+            <literal>dY/dt=A*Y</literal> where the unknown <literal>Y(t)</literal>
+            is a 2-by-2 matrix.
+            The exact solution is <literal>Y(t)=expm(A*t)</literal>, where
             <literal>expm</literal> is the matrix exponential.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 function ydot=f(t,y,A)
     ydot=A*y;
 endfunction
@@ -530,7 +530,7 @@ ode("adams",y0,t0,t,f)
         <para>
             The following example requires a C compiler.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 // ---------- Simple one dimension ODE (C coded external)
 ccode=['#include <math.h>'
        'void myode(int *n,double *t,double *y,double *ydot)'
@@ -544,7 +544,7 @@ exec(TMPDIR+'/loader.sce') //incremental linking
 y0=0;
 t0=0;
 t=0:0.1:%pi;
-y=ode(y0,t0,t,'myode');
+y = ode(y0,t0,t,'myode');
 
  ]]></programlisting>
     </refsection>
index 860a3d4..3338115 100644 (file)
@@ -7,7 +7,7 @@
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  -->
     <refnamediv>
         <refname>ode</refname>
         <refpurpose>
-            программа решения обычных дифференциальных уравнений
+            программа решения обыкновенных дифференциальных уравнений
         </refpurpose>
     </refnamediv>
     <refsynopsisdiv>
         <title>Последовательность вызова</title>
         <synopsis>
-            y=ode(y0, t0, t, f)
-            [y, w, iw]=ode([type,]y0, t0, t [,rtol [,atol]],f [,jac] [,w, iw])
-            [y, rd, w, iw]=ode("root", y0, t0, t [,rtol [,atol]], f [,jac], ng, g [, w, iw])
-            y=ode("discrete", y0, k0, kvect, f)
+            y = ode(y0, t0, t, f)
+            [y, w, iw] = ode([type,]y0, t0, t [,rtol [,atol]],f [,jac] [,w, iw])
+            [y, rd, w, iw] = ode("root", y0, t0, t [,rtol [,atol]], f [,jac], ng, g [, w, iw])
+            y = ode("discrete", y0, k0, kvect, f)
         </synopsis>
     </refsynopsisdiv>
     <refsection>
@@ -58,8 +58,8 @@
                 <term>f</term>
                 <listitem>
                     <para>
-                        внешняя функция (функция, строка или список), правая сторона
-                        дифференциального  уравнения.
+                        внешняя функция (функция, строка или список),
+                        правая сторона дифференциального  уравнения.
                     </para>
                 </listitem>
             </varlistentry>
@@ -80,7 +80,7 @@
                 <listitem>
                     <para>
                         вещественная константа либо вещественный вектор того же размера,
-                        что и <literal>y</literal>, относительный допуск.
+                        что и <varname>y</varname>, относительный допуск.
                     </para>
                 </listitem>
             </varlistentry>
@@ -89,7 +89,7 @@
                 <listitem>
                     <para>
                         вещественная константа либо вещественный вектор того же размера,
-                        что и <literal>y</literal>, абсолютный допуск.
+                        что и <varname>y</varname>, абсолютный допуск.
                     </para>
                 </listitem>
             </varlistentry>
@@ -97,8 +97,8 @@
                 <term>jac</term>
                 <listitem>
                     <para>
-                        внешняя функция (функция, строка или список), якобиан функции 
-                        <literal>f</literal>.
+                        внешняя функция (функция, строка или список), якобиан функции
+                        <varname>f</varname>.
                     </para>
                 </listitem>
             </varlistentry>
     <refsection>
         <title>Описание</title>
         <para>
-            <literal>ode</literal> решает явные обычные дифференциальные уравнения,
-            определённые как:
+            <function>ode</function> решает явные обыкновенные
+            дифференциальные уравнения, определённые как:
         </para>
         <para>
             <latex>
             Это интерфейс для различных программ решения, в частности для ODEPACK.
         </para>
         <para>
-            В данной справке описывается использование <literal>ode</literal> для
-            стандартных явных систем ОДУ.
+            В данной справке описывается использование
+            <function>ode</function> для стандартных явных систем ОДУ.
         </para>
         <para>
-            Самый простой способ вызова <literal>ode</literal>:
-            <literal>y=ode(y0,t0,t,f)</literal>, где <literal>y0</literal> --
-            вектор начальных условий, <literal>t0</literal> -- начальное время,
-            <literal>t</literal> -- вектор моментов времени, для которых вычисляется
-            решение <literal>y</literal> и <literal>y</literal> -- матрица векторов
+            Самый простой способ вызова <function>ode</function>:
+            <code>y = ode(y0, t0, t, f)</code>, где <varname>y0</varname> -
+            вектор начальных условий, <varname>t0</varname> - начальное время,
+            <varname>t</varname> - вектор моментов времени, для которых вычисляется
+            решение <varname>y</varname> и <varname>y</varname> - матрица векторов
             решения <literal>y=[y(t(1)),y(t(2)),...]</literal>.
         </para>
         <para>
-            Входной аргумент <literal>f</literal> определяет правую сторону
+            Входной аргумент <varname>f</varname> определяет правую сторону
             дифференциального уравнения первого порядка. Этот аргумент является
             функцией с определённым заголовком.
         </para>
         <itemizedlist>
             <listitem>
                 <para>
-                    Если <literal>f</literal> является Scilab-функцией, то её
+                    Если <varname>f</varname> является Scilab-функцией, то её
                     последовательность вызова должна быть:
                 </para>
-                <screen><![CDATA[ 
+                <screen><![CDATA[
 ydot = f(t,y)
  ]]></screen>
                 <para>
-                    где <literal>t</literal> -- вещественный скаляр (время), а 
-                    <literal>y</literal> -- вещественный вектор (состояние) и
-                    <literal>ydot</literal> -- вещественный вектор (производная первого
+                    где <literal>t</literal> - вещественный скаляр (время), а
+                    <varname>y</varname> - вещественный вектор (состояние) и
+                    <varname>ydot</varname> - вещественный вектор (производная первого
                     порядка dy/dt).
                 </para>
             </listitem>
             <listitem>
                 <para>
-                    Если <literal>f</literal> -- строка, то это -- имя  компилированной
+                    Если <varname>f</varname> - строка, то это - имя  компилированной
                     процедуры Fortran или функции C. Например, если вызывается
-                    <literal>ode(y0,t0,t,"fex")</literal>, то вызывается подпрограмма
+                    <code>ode(y0, t0, t, "fex")</code>, то вызывается подпрограмма
                     <literal>fex</literal>.
                 </para>
                 <para>
                     Процедура Fortran должна иметь заголовок:
                 </para>
-                <screen><![CDATA[ 
+                <screen><![CDATA[
 fex(n,t,y,ydot)
  ]]></screen>
                 <para>
-                    где <literal>n</literal> -- целое число, <literal>t</literal> -- 
-                    скаляр двойной точности, <literal>y</literal> и
-                    <literal>ydot</literal> -- векторы двойной точности.
+                    где <varname>n</varname> - целое число, <varname>t</varname> --
+                    скаляр двойной точности, <varname>y</varname> и
+                    <varname>ydot</varname> - векторы двойной точности.
                 </para>
                 <para>
                     Функция C должна иметь заголовок:
                 </para>
-                <screen><![CDATA[ 
+                <screen><![CDATA[
 fex(int *n,double *t,double *y,double *ydot)
  ]]></screen>
                 <para>
-                    где <literal>t</literal> -- время, <literal>y</literal> -- состояние,
-                    а <literal>ydot</literal> -- производная состояния (dy/dt).
+                    где <varname>t</varname> - время, <varname>y</varname> - состояние,
+                    а <varname>ydot</varname> - производная состояния (dy/dt).
                 </para>
                 <para>
                     Эта внешняя функция может быть собрана способом, независящим от ОС,
                     используя <link linkend="ilib_for_link">ilib_for_link</link> и
-                    динамически связана с Scilab с помощью функции 
+                    динамически связана с Scilab с помощью функции
                     <link linkend="link">link</link>.
                 </para>
             </listitem>
             <listitem>
                 <para>
-                    Может случиться, что симулятору <literal>f</literal> потребуются
+                    Может случиться, что симулятору <varname>f</varname> потребуются
                     дополнительные аргументы. В этом случае можно использовать следующую
-                    возможность. Аргумент <literal>f</literal> может также быть
+                    возможность. Аргумент <varname>f</varname> может также быть
                     списком <literal>lst=list(simuf,u1,u2,...un)</literal>, где
                     <literal>simuf</literal> является Scilab-функцией с синтаксисом:
-                    <literal>ydot = f(t,y,u1,u2,...,un)</literal>, а 
+                    <literal>ydot = f(t,y,u1,u2,...,un)</literal>, а
                     <literal>u1</literal>, <literal>u2</literal>, ...,
-                    <literal>un</literal> -- дополнительные аргументы, автоматически
+                    <literal>un</literal> - дополнительные аргументы, автоматически
                     передаваемые симулятору <literal>simuf</literal>.
                 </para>
             </listitem>
         </itemizedlist>
         <para>
-            Функция <literal>f</literal> может возвращать вместо
+            Функция <varname>f</varname> может возвращать вместо
             вектора матрицу<literal>p x q</literal>. С этой матричной нотацией
-            решается система <literal>n=p+q</literal> ОДУ 
-            <literal>dY/dt=F(t,Y)</literal>, где <literal>Y</literal> -- матрица
-            <literal>p x q</literal>.  Затем начальные условия,      
+            решается система <literal>n=p+q</literal> ОДУ
+            <literal>dY/dt=F(t,Y)</literal>, где <literal>Y</literal> - матрица
+            <literal>p x q</literal>.  Затем начальные условия,
             <literal>Y0</literal>, должны быть так же матрицей
-            <literal>p x q</literal>, а результат <literal>ode</literal> -- матрицей
-            <literal>p x q(T+1)</literal> 
+            <literal>p x q</literal>, а результат <function>ode</function> - матрицей
+            <literal>p x q(T+1)</literal>
             <literal>[Y(t_0),Y(t_1),...,Y(t_T)]</literal>.
         </para>
         <para>
-            Допуски <literal>rtol</literal> и <literal>atol</literal> являются
-            порогами для относительной и абсолютной оцененных ошибок. Оцененная
+            Допуски <varname>rtol</varname> и <varname>atol</varname> являются
+            порогами для относительной и абсолютной оценённых ошибок. Оценённая
             ошибка <literal>y(i)</literal> равна:
             <literal>rtol(i)*abs(y(i))+atol(i)</literal> и интегрирование выполняется
             пока эта ошибка мала для каждого из элементов состояния. Если
-            <literal>rtol</literal> и/или <literal>atol</literal> является
+            <varname>rtol</varname> и/или <varname>atol</varname> является
             константой, то <literal>rtol(i)</literal> и/или <literal>atol(i)</literal>
             являются набором констант. Значения по умолчанию для
-            <literal>rtol</literal> и <literal>atol</literal> соответственно равны
+            <varname>rtol</varname> и <varname>atol</varname> соответственно равны
             <literal>rtol=1.d-5</literal> и <literal>atol=1.d-7</literal> для
             большинства программ решения, а для <literal>"rfk"</literal> и
             <literal>"fix"</literal>  <literal>rtol=1.d-3</literal> и
@@ -275,41 +275,41 @@ fex(int *n,double *t,double *y,double *ydot)
         </para>
         <para>
             Для жёстких задач лучше указывать якобиан функции правой стороны в
-            качестве необязательного аргумента <literal>jac</literal>.
+            качестве необязательного аргумента <varname>jac</varname>.
             Якобиан является внешней функцией, т. е. функцией со специальным
-            синтаксисом, либо именем процедуры Fortran или функции C 
+            синтаксисом, либо именем процедуры Fortran или функции C
             (символьная строка) с определённой последовательностью вызова, либо
             списком.
         </para>
         <itemizedlist>
             <listitem>
                 <para>
-                    Если <literal>jac</literal> является функцией, то синтаксис должен
+                    Если <varname>jac</varname> является функцией, то синтаксис должен
                     быть <literal>J=jac(t,y)</literal>, где <literal>t</literal> --
-                    вещественный скаляр (время), а <literal>y</literal> -- вещественный
+                    вещественный скаляр (время), а <varname>y</varname> - вещественный
                     вектор (состояние). Результирующая матрица <literal>J</literal>
                     должна вычислять df/dx, т. е. <literal>J(k,i) = dfk/dxi</literal>, где
-                    <literal>fk</literal> --  <literal>k</literal>-тый элемент
-                    <literal>f</literal>.
+                    <literal>fk</literal> - <literal>k</literal>-тый элемент
+                    <varname>f</varname>.
                 </para>
             </listitem>
             <listitem>
                 <para>
-                    Если <literal>jac</literal> является символьной строкой, то она
+                    Если <varname>jac</varname> является символьной строкой, то она
                     ссылается на имя процедуры Fortran или функции C.
                 </para>
                 <para>
                     Процедура Fortran должна иметь заголовок:
                 </para>
-                <screen><![CDATA[ 
-subroutine fex(n,t,y,ml,mu,J,nrpd) 
+                <screen><![CDATA[
+subroutine fex(n,t,y,ml,mu,J,nrpd)
 integer n,ml,mu,nrpd
 double precision t,y(*),J(*)
  ]]></screen>
                 <para>
                     Функция C должна иметь заголовок:
                 </para>
-                <screen><![CDATA[ 
+                <screen><![CDATA[
 void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
  ]]></screen>
                 <para>
@@ -319,16 +319,16 @@ void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
             </listitem>
             <listitem>
                 <para>
-                    Если <literal>jac</literal> является списком, то для
-                    <literal>f</literal> применяются те же договорённости.
+                    Если <varname>jac</varname> является списком, то для
+                    <varname>f</varname> применяются те же договорённости.
                 </para>
             </listitem>
         </itemizedlist>
         <para>
-            Необязательные аргументы <literal>w</literal> и
-            <literal>iw</literal> являются векторами для хранения информации,
+            Необязательные аргументы <varname>w</varname> и
+            <varname>iw</varname> являются векторами для хранения информации,
             возвращаемой подпрограммой интегрирования (см. <link linkend="ode_optional_output">ode_optional_output</link>).
-            Когда эти векторы указываются с правой стороны  <literal>ode</literal>,
+            Когда эти векторы указываются с правой стороны  <function>ode</function>,
             интегрирование начинается заново с теми же параметрами, что и до
             остановки.
         </para>
@@ -341,7 +341,7 @@ void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
         <title>Программы решения</title>
         <para>
             Тип задачи, которую надо решить и используемый метод зависят от
-            значения первого необязательного аргумента <literal>type</literal>,
+            значения первого необязательного аргумента <varname>type</varname>,
             который может быть одной из следующих строк:
         </para>
         <variablelist>
@@ -350,8 +350,8 @@ void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
                 <listitem>
                     <para>
                         Программа решения <literal>lsoda</literal> из пакета ODEPACK
-                        вызывается по умолчанию. Она автоматически выбирает между  
-                        нежёстким  методом прогноза-исправления Адамса 
+                        вызывается по умолчанию. Она автоматически выбирает между
+                        нежёстким  методом прогноза-исправления Адамса
                         (predictor-corrector Adams method) и жёстким методом обратной
                         дифференциальной формулой (ОДФ) ( Backward Differentiation
                         Formula (BDF) method). Изначально она применяет нежёсткий метод и
@@ -374,7 +374,7 @@ void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
                 <term>"stiff":</term>
                 <listitem>
                     <para>
-                        Это для жёстких задач. Вызывается программа решения 
+                        Это для жёстких задач. Вызывается программа решения
                         <literal>lsode</literal> из пакета ODEPACK, и она использует метод
                         ОДФ.
                     </para>
@@ -405,8 +405,8 @@ void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
                     <para>
                         Та же программа решения, что и <literal>"rkf"</literal>, но
                         пользовательский интерфейс очень прост, т. е. программе решения
-                        могут быть переданы только параметры <literal>rtol</literal> и
-                        <literal>atol</literal>. Это самый простой метод для пробы.
+                        могут быть переданы только параметры <varname>rtol</varname> и
+                        <varname>atol</varname>. Это самый простой метод для пробы.
                     </para>
                 </listitem>
             </varlistentry>
@@ -414,7 +414,7 @@ void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
                 <term>"root":</term>
                 <listitem>
                     <para>
-                        Программа решения ОДУ с возможностью нахождения корней. 
+                        Программа решения ОДУ с возможностью нахождения корней.
                         Используется программа решения <literal>lsodar</literal> из пакета
                         ODEPACK. Она является вариантом программы
                         решения <literal>lsoda</literal>, где она ищет корни заданной
@@ -436,29 +436,29 @@ void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
         <title>Примеры</title>
         <para>
             В следующем примере мы решим обыкновенное дифференциальное уравнение
-            <literal>dy/dt=y^2-y*sin(t)+cos(t)</literal> с начальным условием     
+            <literal>dy/dt=y^2-y*sin(t)+cos(t)</literal> с начальным условием
             <literal>y(0)=0</literal>. Используем программу решения по умолчанию.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 function ydot=f(t,y)
        ydot=y^2-y*sin(t)+cos(t)
 endfunction
 y0=0;
 t0=0;
 t=0:0.1:%pi;
-y=ode(y0,t0,t,f);
+y = ode(y0,t0,t,f);
 plot(t,y)
  ]]></programlisting>
         <para>
             В следующем примере мы решаем уравнение <literal>dy/dt=A*y</literal>.
-            Точное решение равно <literal>y(t)=expm(A*t)*y(0)</literal>, где 
-            <literal>expm</literal> -- матричная экспонента. 
+            Точное решение равно <literal>y(t)=expm(A*t)*y(0)</literal>, где
+            <literal>expm</literal> - матричная экспонента.
             Неизвестное равно матрице  <literal>y(t)</literal> размером 2 на 1.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 function ydot=f(t,y)
     ydot=A*y
-endfunction 
+endfunction
 function J=Jacobian(t,y)
     J=A
 endfunction
@@ -475,11 +475,11 @@ expm(A*t)*y0
                 B*u(t)
             </literal>
             с <literal>u(t)=sin(omega*t)</literal>.
-            Обратите внимание, что дополнительные аргументы <literal>f</literal>: 
+            Обратите внимание, что дополнительные аргументы <varname>f</varname>:
             <literal>A</literal>, <literal>u</literal>, <literal>B</literal>,
-            <literal>omega</literal> передаются в <literal>f</literal> в списке.
+            <literal>omega</literal> передаются в <varname>f</varname> в списке.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 function xdot=linear(t,x,A,u,B,omega)
     xdot=A*x+B*u(t,omega)
 endfunction
@@ -499,26 +499,26 @@ ode(y0,t0,t,list(linear,A,u,B,omega))
             <literal>dX/dt=A'*X + X*A - X'*B*X + C</literal>, где начальное
             условие  <literal>X(0)</literal> является единичной матрицей 2 на 2.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 function Xdot=ric(t,X,A,B,C)
     Xdot=A'*X+X*A-X'*B*X+C
-endfunction  
-A=[1,1;0,2]; 
-B=[1,0;0,1]; 
+endfunction
+A=[1,1;0,2];
+B=[1,0;0,1];
 C=[1,0;0,1];
 y0=eye(A);
 t0=0;
 t=0:0.1:%pi;
-X=ode(y0,t0,t,list(ric,A,B,C))
+X = ode(y0,t0,t,list(ric,A,B,C))
  ]]></programlisting>
         <para>
             В следующем примере мы решаме дифференциальное уравнение
-            <literal>dY/dt=A*Y</literal>, где неизвестная <literal>Y(t)</literal> 
+            <literal>dY/dt=A*Y</literal>, где неизвестная <literal>Y(t)</literal>
             является матрицей 2 на 2.  Точное решение равно <literal>expm</literal>
             <literal>Y(t)=expm(A*t)</literal>, где <literal>expm</literal> --
             матричная экспонента.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 function ydot=f(t,y,A)
     ydot=A*y;
 endfunction
@@ -537,7 +537,7 @@ ode("adams",y0,t0,t,f)
         <para>
             Следующий пример требует компилятор C.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 // ---------- Простое одномерное ОДУ (внешняя функция на языке C)
 ccode=['#include <math.h>'
        'void myode(int *n,double *t,double *y,double *ydot)'
@@ -551,8 +551,8 @@ exec(TMPDIR+'/loader.sce') // пошаговая компоновка
 y0=0;
 t0=0;
 t=0:0.1:%pi;
-y=ode(y0,t0,t,'myode');
+y = ode(y0,t0,t,'myode');
+
  ]]></programlisting>
     </refsection>
     <refsection role="see also">