* 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
*
-->
<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>
<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>
<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.
<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>
</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>
</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
</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.
<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>
</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>
<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>
<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>
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
<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
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
<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)'
y0=0;
t0=0;
t=0:0.1:%pi;
-y=ode(y0,t0,t,'myode');
+y = ode(y0,t0,t,'myode');
]]></programlisting>
</refsection>
* 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>
<term>f</term>
<listitem>
<para>
- внешняя функция (функция, строка или список), правая сторона
- дифференциального уравнения.
+ внешняя функция (функция, строка или список),
+ правая сторона дифференциального уравнения.
</para>
</listitem>
</varlistentry>
<listitem>
<para>
вещественная константа либо вещественный вектор того же размера,
- что и <literal>y</literal>, относительный допуск.
+ что и <varname>y</varname>, относительный допуск.
</para>
</listitem>
</varlistentry>
<listitem>
<para>
вещественная константа либо вещественный вектор того же размера,
- что и <literal>y</literal>, абсолютный допуск.
+ что и <varname>y</varname>, абсолютный допуск.
</para>
</listitem>
</varlistentry>
<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> и
</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>
</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>
<title>Программы решения</title>
<para>
Тип задачи, которую надо решить и используемый метод зависят от
- значения первого необязательного аргумента <literal>type</literal>,
+ значения первого необязательного аргумента <varname>type</varname>,
который может быть одной из следующих строк:
</para>
<variablelist>
<listitem>
<para>
Программа решения <literal>lsoda</literal> из пакета ODEPACK
- вызывается по умолчанию. Она автоматически выбирает между
- нежёстким методом прогноза-исправления Адамса
+ вызывается по умолчанию. Она автоматически выбирает между
+ нежёстким методом прогноза-исправления Адамса
(predictor-corrector Adams method) и жёстким методом обратной
дифференциальной формулой (ОДФ) ( Backward Differentiation
Formula (BDF) method). Изначально она применяет нежёсткий метод и
<term>"stiff":</term>
<listitem>
<para>
- Это для жёстких задач. Вызывается программа решения
+ Это для жёстких задач. Вызывается программа решения
<literal>lsode</literal> из пакета ODEPACK, и она использует метод
ОДФ.
</para>
<para>
Та же программа решения, что и <literal>"rkf"</literal>, но
пользовательский интерфейс очень прост, т. е. программе решения
- могут быть переданы только параметры <literal>rtol</literal> и
- <literal>atol</literal>. Это самый простой метод для пробы.
+ могут быть переданы только параметры <varname>rtol</varname> и
+ <varname>atol</varname>. Это самый простой метод для пробы.
</para>
</listitem>
</varlistentry>
<term>"root":</term>
<listitem>
<para>
- Программа решения ОДУ с возможностью нахождения корней.
+ Программа решения ОДУ с возможностью нахождения корней.
Используется программа решения <literal>lsodar</literal> из пакета
ODEPACK. Она является вариантом программы
решения <literal>lsoda</literal>, где она ищет корни заданной
<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
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
<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
<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)'
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">
projects / scilab.git / commitdiff