Revision of help page for functions 92/13292/2
Stanislav KROTER [Sat, 30 Nov 2013 15:58:01 +0000 (21:58 +0600)]
Added russian translation for this help page.

Change-Id: If30d1bd9a95d932cb975c2bee51db0506804d533

scilab/modules/functions/help/en_US/functions.xml
scilab/modules/functions/help/fr_FR/functions.xml
scilab/modules/functions/help/ja_JP/functions.xml
scilab/modules/functions/help/pt_BR/functions.xml
scilab/modules/functions/help/ru_RU/functions.xml [new file with mode: 0644]

index 6241d16..436d997 100644 (file)
         <title>Function definition</title>
         <para>Usually, they are defined in files with an editor and loaded into
             Scilab using the  <link linkend="exec">exec</link> function or through a library (see
-            <link linkend="lib">lib</link> or <link linkend="genlib">genlib</link>). But They can also be
+            <link linkend="lib">lib</link> or <link linkend="genlib">genlib</link>). But they can also be
             defined on-line (see  <link linkend="deff">deff</link> or <link linkend="function">function</link>.
-            A function is defined by two components: 
+            A function is defined by two components:
         </para>
         <itemizedlist>
             <listitem>
                 <para>a "syntax definition" part  as follows:</para>
-                <programlisting><![CDATA[ 
+                <programlisting role='no-scilab-exec'><![CDATA[
 function [y1,...,yn]=foo(x1,...,xm)
 function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)
  ]]></programlisting>
             </listitem>
             <listitem>
-                <para>a sequence of scilab instructions.</para>
+                <para>a sequence of Scilab instructions.</para>
             </listitem>
         </itemizedlist>
         <para>The "syntax definition" line gives the "full" calling syntax of
@@ -72,35 +72,39 @@ function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)
             </listitem>
             <listitem>
                 <para>It is also possible to use "named argument" to specify input
-                    arguments: suppose function <literal>fun1</literal> defined as
-                    <literal>function y1=fun1(x1,x2,x3)</literal> then it can be
-                    called with a syntax like <literal>y=fun1(x1=33,x3=[1 2
-                        3])
-                    </literal>
-                    within <literal>fun1</literal> x2 will be
-                    undefined,
+                    arguments: suppose function <function>fun1</function> defined as
+                    <code>function y1 = fun1(x1, x2, x3)</code> then it can be
+                    called with a syntax like
+                    <code>y = fun1(x1=33, x3=[1 2 3])</code>
+                    within <function>fun1</function> <varname>x2</varname> will be
+                    undefined.
                 </para>
-                <para> it can also be called with a syntax like
-                    <literal>y=fun1(x1=33,y='foo')</literal>. In such a case the
-                    <literal>y</literal> variable will be available in the context
-                    of the function <literal>fun1</literal>. Note that the maximum
-                    number of argument must be less or equal to the number of
-                    formal input argument used in the function syntax part.
+                <para> It can also be called with a syntax like
+                    <code>y = fun1(x1=33, y='foo')</code>. In such a case the
+                    <varname>y</varname> variable will be available in the context
+                    of the function <function>fun1</function>.
+                    <note>
+                        Note that the maximum number of argument must be
+                        less or equal to the number of formal input
+                        argument used in the function syntax part.
+                    </note>
                 </para>
-                <para> It is possible to check for defined variables with the
-                    <link linkend="exists">exists</link> function.
+                <para>
+                    It is possible to check for defined variables with
+                    the <link linkend="exists">exists</link> function.
                 </para>
             </listitem>
             <listitem>
-                <para>When a function has no left hand side argument and is called only
-                    with character string arguments, the calling syntax may be
-                    simplified:
+                <para>
+                    When a function has no left hand side argument and
+                    is called only with character string arguments, the
+                    calling syntax may be simplified:
                 </para>
-                <programlisting><![CDATA[ 
-fun('a','toto','a string') 
+                <programlisting role='no-scilab-exec'><![CDATA[
+fun('a','toto','a string')
  ]]></programlisting>
                 <para>is equivalent to: </para>
-                <programlisting><![CDATA[ 
+                <programlisting role='no-scilab-exec'><![CDATA[
 fun a toto 'a string'
  ]]></programlisting>
             </listitem>
@@ -109,14 +113,12 @@ fun a toto 'a string'
     <refsection>
         <title>Miscellaneous</title>
         <para>
-            Functions are Scilab objects (with type numbers 13 or 11). They
-            and can be manipulated (built, saved, loaded, passed as
-            arguments,..) as other variable types.
+            Functions are Scilab objects (with type numbers 13 or 11). And they can be manipulated (built, saved, loaded, passed as
+            arguments,...) as other variable types.
         </para>
         <para>Collections of functions can be collected in libraries.  Functions
             which begin with <literal>%</literal> sign
-            (e.g. <literal>%foo</literal>) are often used to overload (see <link linkend="overloading">overloading</link>
-            ) operations or functions for new data type.
+            (e.g. <literal>%foo</literal>) are often used to overload (see <link linkend="overloading">overloading</link>) operations or functions for new data type.
         </para>
         <para>
             Note that a function name must respect some syntax rules (see <link linkend="names">names</link>).
@@ -124,7 +126,7 @@ fun a toto 'a string'
     </refsection>
     <refsection>
         <title>Examples</title>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 //inline definition (see function)
 function [x,y]=myfct(a,b)
   x=a+b
index d0ec60b..a01f40c 100644 (file)
@@ -32,9 +32,9 @@
         <itemizedlist>
             <listitem>
                 <para>une ligne de déclaration formelle</para>
-                <programlisting><![CDATA[ 
+                <programlisting role='no-scilab-exec'><![CDATA[
 function [y1,...,yn]=foo(x1,...,xm)
-function [y1,...,yn,varargout]=foo(x1,...,xm,varargin) 
+function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)
  ]]></programlisting>
             </listitem>
             <listitem>
@@ -72,20 +72,23 @@ function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)
             <listitem>
                 <para>Il est aussi possible d'utiliser des "arguments
                     nommés" pour spécifier les valeurs des arguments d'entrée :
-                    supposons que la fonction <literal>fun1</literal> est
-                    définie ainsi <literal>function y1=fun1(x1,x2,x3)</literal>
+                    supposons que la fonction <varname>x2</varname> est
+                    définie ainsi <code>function y1 = fun1(x1, x2, x3)</code>
                     alors on peut utiliser la syntaxe
-                    <literal>y=fun1(x1=33,x3=[1 2 3])</literal>, et dans
-                    <literal>fun1</literal> x2 ne sera pas défini.
+                    <code>y = fun1(x1=33, x3=[1 2 3])</code>, et dans
+                    <varname>x2</varname> ne sera pas défini.
                 </para>
                 <para>Il est aussi possible d'appeler la fonction
-                    <literal>fun1</literal> avec une syntaxe comme
-                    <literal>y=fun1(x1=33,y='foo')</literal>. Dans ce cas la
-                    variable <literal>y</literal> sera définie dans le contexte
-                    local de la fonction. Noter qu'alors il n'est pas possible
-                    de passer plus d'arguments d'entrée que le nombre
-                    d'arguments formel declarés dans la définition de la syntaxe
-                    d'appel de la fonction.
+                    <varname>x2</varname> avec une syntaxe comme
+                    <code>y = fun1(x1=33, y='foo')</code>. Dans ce cas la
+                    variable <varname>y</varname> sera définie dans le contexte
+                    local de la fonction.
+                    <note>
+                        Noter qu'alors il n'est pas possible de passer
+                        plus d'arguments d'entrée que le nombre
+                        d'arguments formel declarés dans la définition
+                        de la syntaxe d'appel de la fonction.
+                    </note>
                 </para>
                 <para>Il est possible de vérifier quelles sont les variables
                     définies avec la fonction <link linkend="exists">exists</link>.
@@ -96,11 +99,11 @@ function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)
                     appelée avec des arguments d'entrée de type chaîne de
                     caractère, la syntaxe d'appel peut être simplifiée :
                 </para>
-                <programlisting><![CDATA[ 
-fun('a','toto','une chaîne') 
+                <programlisting role='no-scilab-exec'><![CDATA[
+fun('a','toto','une chaîne')
  ]]></programlisting>
                 <para>est alors équivalent à: </para>
-                <programlisting><![CDATA[ 
+                <programlisting role='no-scilab-exec'><![CDATA[
 fun a toto 'une chaîne'
  ]]></programlisting>
             </listitem>
@@ -124,7 +127,7 @@ fun a toto 'une chaîne'
     </refsection>
     <refsection>
         <title>Exemples</title>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 // définition en ligne
 function [x,y]=myfct(a,b)
 x=a+b
index c8b0c5e..5264739 100644 (file)
             しかし,オンライン定義
             (<link linkend="deff">deff</link> または <link linkend="function">function</link>参照)
             することも可能です.
-            関数は以下の2つの要素により定義されます:: 
+            関数は以下の2つの要素により定義されます::
         </para>
         <itemizedlist>
             <listitem>
                 <para>以下のような "構文定義" 部:</para>
-                <programlisting><![CDATA[ 
+                <programlisting role='no-scilab-exec'><![CDATA[
 function [y1,...,yn]=foo(x1,...,xm)
 function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)
  ]]></programlisting>
@@ -76,20 +76,21 @@ function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)
             </listitem>
             <listitem>
                 <para>It is also possible to use "named argument" to specify input
-                    arguments: suppose function <literal>fun1</literal> defined as
-                    <literal>function y1=fun1(x1,x2,x3)</literal> then it can be
-                    called with a syntax like <literal>y=fun1(x1=33,x3=[1 2
-                        3])
-                    </literal>
-                    within <literal>fun1</literal> x2 will be
+                    arguments: suppose function <function>fun1</function> defined as
+                    <code>function y1 = fun1(x1, x2, x3)</code> then it can be
+                    called with a syntax like <code>y = fun1(x1=33, x3=[1 2 3])</code>
+                    within <function>fun1</function> x2 will be
                     undefined,
                 </para>
                 <para> it can also be called with a syntax like
-                    <literal>y=fun1(x1=33,y='foo')</literal>. In such a case the
-                    <literal>y</literal> variable will be available in the context
-                    of the function <literal>fun1</literal>. Note that the maximum
-                    number of argument must be less or equal to the number of
-                    formal input argument used in the function syntax part.
+                    <code>y = fun1(x1=33, y='foo')</code>. In such a case the
+                    <varname>y</varname> variable will be available in the context
+                    of the function <function>fun1</function>.
+                    <note>
+                        Note that the maximum number of argument must be
+                        less or equal to the number of formal input
+                        argument used in the function syntax part.
+                    </note>
                 </para>
                 <para> It is possible to check for defined variables with the
                     <link linkend="exists">exists</link> function.
@@ -100,11 +101,11 @@ function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)
                     with character string arguments, the calling syntax may be
                     simplified:
                 </para>
-                <programlisting><![CDATA[ 
-fun('a','toto','a string') 
+                <programlisting role='no-scilab-exec'><![CDATA[
+fun('a','toto','a string')
  ]]></programlisting>
                 <para>is equivalent to: </para>
-                <programlisting><![CDATA[ 
+                <programlisting role='no-scilab-exec'><![CDATA[
 fun a toto 'a string'
  ]]></programlisting>
             </listitem>
@@ -115,17 +116,16 @@ fun a toto 'a string'
         <para>
             Functions are Scilab objects (with type numbers 13 or 11). They
             and can be manipulated (built, saved, loaded, passed as
-            arguments,..) as other variable types.
+            arguments,...) as other variable types.
         </para>
         <para>Collections of functions can be collected in libraries.  Functions
             which begin with <literal>%</literal> sign
-            (e.g. <literal>%foo</literal>) are often used to overload (see <link linkend="overloading">overloading</link>
-            ) operations or functions for new data type.
+            (e.g. <literal>%foo</literal>) are often used to overload (see <link linkend="overloading">overloading</link>) operations or functions for new data type.
         </para>
     </refsection>
     <refsection>
         <title>例</title>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 //インライン定義 (function参照)
 function [x,y]=myfct(a,b)
   x=a+b
index 1cafb35..65b9b0a 100644 (file)
@@ -10,7 +10,7 @@
  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  *
  -->
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns4="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="functions" xml:lang="en">
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns4="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="functions" xml:lang="pt">
     <refnamediv>
         <refname>functions</refname>
         <refpurpose>procedimentos Scilab e objetos Scilab</refpurpose>
@@ -32,9 +32,9 @@
         <itemizedlist>
             <listitem>
                 <para>uma parte "definição de sintaxe" como segue:</para>
-                <programlisting role=""><![CDATA[ 
+                <programlisting  role='no-scilab-exec'><![CDATA[
 function [y1,...,yn]=foo(x1,...,xm)
-function [y1,...,yn,varargout]=foo(x1,...,xm,varargin) 
+function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)
  ]]></programlisting>
             </listitem>
             <listitem>
@@ -72,22 +72,20 @@ function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)
             </listitem>
             <listitem>
                 <para>Também é possível utilizar "argumentos nomeados" para
-                    especificar argumentos de entrada: suponha que a função <literal>fun1
-                        seja
-                    </literal>
-                    definida como <literal>function
-                        y1=fun1(x1,x2,x3)
-                    </literal>
-                    ,então pode ser chamada com uma sintaxe
-                    como <literal>y=fun1(x1=33,x3=[1 2 3])</literal>. Dentro de
-                    <literal>fun1</literal> x2 será indefinida.
+                    especificar argumentos de entrada: suponha que a função <function>fun1</function> seja
+                    definida como <code>function y1 = fun1(x1, x2, x3)</code>, então pode ser chamada com uma sintaxe
+                    como <code>y = fun1(x1=33, x3=[1 2 3])</code>. Dentro de
+                    <function>fun1</function> <varname>x2</varname> será indefinida.
                 </para>
                 <para>Também pode ser chamada com sintaxe como
-                    <literal>y=fun1(x1=33,y='foo')</literal>. Em tal caso, a variável
-                    <literal>y</literal> estará disponível no contexto da função
-                    <literal>fun1</literal>. Note que o número máximo de argumentos deve
-                    ser menor que ou igual ao número de argumentos de entrada fornais
-                    utilizados na parte de sintaxe da função.
+                    <code>y = fun1(x1=33, y='foo')</code>. Em tal caso, a variável
+                    <varname>y</varname> estará disponível no contexto da função
+                    <function>fun1</function>.
+                    <note>
+                        Note que o número máximo de argumentos deve
+                        ser menor que ou igual ao número de argumentos de entrada fornais
+                        utilizados na parte de sintaxe da função.
+                    </note>
                 </para>
                 <para>É possível buscar por variáveis definidas através da função
                     <link linkend="exists">exists</link>.
@@ -98,11 +96,11 @@ function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)
                     chamada apenas com argumentos strings, a sintaxe de chamamento pode
                     ser simplificada:
                 </para>
-                <programlisting role=""><![CDATA[ 
-fun('a','toto','a string') 
+                <programlisting  role='no-scilab-exec'><![CDATA[
+fun('a','toto','a string')
  ]]></programlisting>
                 <para>is equivalent to:</para>
-                <programlisting role=""><![CDATA[ 
+                <programlisting  role='no-scilab-exec'><![CDATA[
 fun a toto 'a string'
  ]]></programlisting>
             </listitem>
@@ -112,17 +110,17 @@ fun a toto 'a string'
         <title>Miscelânea</title>
         <para>Funções Scilab são objetos (com números de tipo 13 ou 11). Elas
             podem ser manipuladas (construídas, salvas, carregadas, passadas como
-            argumentos,..) como outros tipos de variáveis.
+            argumentos,...) como outros tipos de variáveis.
         </para>
         <para>Coleções de funções podem ser reunidas em bibliotecas. Funções que
             começam pelo sinal <literal>%</literal> (ex: <literal>%foo</literal>) são
-            geralmente utilizadas para operações de sobrecarga (ver <link linkend="overloading">overloading</link> ) ou são funções para novos tipos
+            geralmente utilizadas para operações de sobrecarga (ver <link linkend="overloading">overloading</link>) ou são funções para novos tipos
             de dados.
         </para>
     </refsection>
     <refsection>
         <title>Exemplos</title>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 //definição inline (ver function)
 function [x,y]=myfct(a,b)
   x=a+b
diff --git a/scilab/modules/functions/help/ru_RU/functions.xml b/scilab/modules/functions/help/ru_RU/functions.xml
new file mode 100644 (file)
index 0000000..95ae0ae
--- /dev/null
@@ -0,0 +1,195 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) ????-2008 - INRIA
+ *
+ * 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
+ * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
+ *
+ -->
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:lang="ru" xml:id="functions">
+    <refnamediv>
+        <refname>функции</refname>
+        <refpurpose>
+            Scilab-процедуры и Scilab-объекты
+        </refpurpose>
+    </refnamediv>
+    <refsection>
+        <title>Описание</title>
+        <para>
+            Функции являются процедурами Scilab ("макрос", "функция" и
+            "процедура" имеют одно и то же значение).
+        </para>
+    </refsection>
+    <refsection>
+        <title>Определение функции</title>
+        <para>
+            Обычно они определяются в файлах с помощью редактора и загружаются в Scilab, используя функцию <link linkend="exec">exec</link> или через библиотеку (см.
+            <link linkend="lib">lib</link> либо <link linkend="genlib">genlib</link>). Однако, они также могут быть определены во время исполнения программы (см. <link linkend="deff">deff</link> либо <link linkend="function">function</link>.
+            Функция определяется двумя составляющими:
+        </para>
+        <itemizedlist>
+            <listitem>
+                <para>часть "синтаксис определения", как например:</para>
+                <programlisting role='no-scilab-exec'><![CDATA[
+function [y1,...,yn]=foo(x1,...,xm)
+function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)
+ ]]></programlisting>
+            </listitem>
+            <listitem>
+                <para>ряд Scilab-инструкций.</para>
+            </listitem>
+        </itemizedlist>
+        <para>
+            Строка "синтаксиса определения" указывает "полный" синтаксис
+            вызова этой функции. <literal>yi</literal> - выходные
+            переменные, вычисленные в зависимости от входных переменных
+            <literal>xi</literal> и переменные, существующие в Scilab'е
+            в момент исполнения функции.
+        </para>
+    </refsection>
+    <refsection>
+        <title>Вызов функции</title>
+        <itemizedlist>
+            <listitem>
+                <para>
+                    Обычно синтаксис вызова функции следующий:
+                    <literal>[y1,...,yn]=foo(x1,...,xm)</literal>. Можно
+                    использовать более короткий список входных или
+                    выходных аргументов, чем определённый. В таких
+                    случаях используются или устанавливаются только
+                    самые первые переменные, начиная слева.
+                </para>
+                <para>
+                    Функция <link linkend="argn">argn</link> может быть
+                    использована для получения фактического количества
+                    аргументов при вызове.
+                </para>
+            </listitem>
+            <listitem>
+                <para>
+                    Можно определять функцию с неопределённым
+                    максимальным количеством входных или выходных
+                    аргументов. Это можно сделать, используя ключевые
+                    слова <link linkend="varargin">varargin</link> и
+                    <link linkend="varargout">varargout</link>.
+                </para>
+            </listitem>
+            <listitem>
+                <para>
+                    Также можно использовать "именованный аргумент" для определения входных аргументов: предположим, что функция <function>fun1</function>, определённая как
+                    <code>function y1 = fun1(x1, x2, x3)</code>, тогда её можно вызвать следующим синтаксисом:
+                    <code>y = fun1(x1=33, x3=[1 2 3])</code>; внутри
+                    <function>fun1</function> переменная <varname>x2</varname> не будет определена.
+                </para>
+                <para>
+                    Её можно также вызвать следующим синтаксисом:
+                    <code>y = fun1(x1=33, y='foo')</code>. в таком
+                    случае переменная <varname>y</varname> будет
+                    доступна в контексте функции
+                    <function>fun1</function>.
+                    <note>
+                        Обратите внимание, что максимальное количество
+                        аргументов должно быть меньше или равно числу
+                        формальных входных аргументов, используемых в
+                        части синтаксиса функции.
+                    </note>
+                </para>
+                <para>
+                    Проверить определены ли переменные можно с помощью
+                    функции <link linkend="exists">exists</link>.
+                </para>
+            </listitem>
+            <listitem>
+                <para>
+                    Когда у функции нет аргументов слева и она вызывается только с аргументами символьных строк, синтаксис вызова может быть упрощён:
+                </para>
+                <programlisting role='no-scilab-exec'><![CDATA[
+fun('a','toto','a string')
+ ]]></programlisting>
+                <para>что эквивалентно: </para>
+                <programlisting role='no-scilab-exec'><![CDATA[
+fun a toto 'a string'
+ ]]></programlisting>
+            </listitem>
+        </itemizedlist>
+    </refsection>
+    <refsection>
+        <title>Прочие вопросы</title>
+        <para>
+            Функции являются Scilab-объектами (с номерами типа 13 или
+            11). И ими можно управлять (создавать, сохранять, загружать,
+            передавать в качестве аргументов, и т. д.) как и другими
+            типами переменных.
+        </para>
+        <para>
+            Коллекции функций можно собирать в библиотеки. Функции,
+            которые начинаются со знака <literal>%</literal> (например,
+            <literal>%foo</literal>) часто используются чтобы
+            перегрузить (см. <link linkend="overloading">перегрузку</link>) операции или
+            функции для нового типа данных.
+        </para>
+        <note>
+            Заметьте, что имя функции должно удовлетворять некоторым правилам синтаксиса (см. <link linkend="names">имена</link>).
+        </note>
+    </refsection>
+    <refsection>
+        <title>Примеры</title>
+        <programlisting role="example"><![CDATA[
+//определение встраиваемой функции (см. function)
+function [x,y]=myfct(a,b)
+  x=a+b
+  y=a-b
+endfunction
+[x,y]=myfct(3,2)
+
+//определение встраиваемой функции (см. deff)
+deff('[x,y]=myfct(a,b)',['x=a+b';
+                         'y=a-b'])
+
+// определение в ASCII-файле (см. exec)
+exec SCI/modules/elementary_functions/macros/asinh.sci;
+ ]]></programlisting>
+    </refsection>
+    <refsection role="see also">
+        <title>Смотрите также</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="function">function</link>
+            </member>
+            <member>
+                <link linkend="deff">deff</link>
+            </member>
+            <member>
+                <link linkend="exec">exec</link>
+            </member>
+            <member>
+                <link linkend="comp">comp</link>
+            </member>
+            <member>
+                <link linkend="lib">lib</link>
+            </member>
+            <member>
+                <link linkend="getd">getd</link>
+            </member>
+            <member>
+                <link linkend="genlib">genlib</link>
+            </member>
+            <member>
+                <link linkend="exists">exists</link>
+            </member>
+            <member>
+                <link linkend="varargin">varargin</link>
+            </member>
+            <member>
+                <link linkend="varargout">varargout</link>
+            </member>
+            <member>
+                <link linkend="names">имена</link>
+            </member>
+        </simplelist>
+    </refsection>
+</refentry>