scilab/modules/functions/help/ru_RU/deff.xml

   1 <?xml version="1.0" encoding="UTF-8"?>
   2 <!--
   3  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   4  * Copyright (C) XXXX-2008 - INRIA
   5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
   6  * Copyright (C) 2018 - 2020 - Samuel GOUGEON
   7  *
   8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
   9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
  10  * This file was originally licensed under the terms of the CeCILL v2.1,
  11  * and continues to be available under such terms.
  12  * For more information, see the COPYING file which you should have received
  13  * along with this program.
  14  *
  15  -->
  16 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
  17           xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML"
  18           xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org"
  19           xml:lang="ru" xml:id="deff">
  20     <refnamediv>
  21         <refname>deff</refname>
  22         <refpurpose>
  23             вставленное определение (анонимной) функции на языке Scilab
  24         </refpurpose>
  25     </refnamediv>
  26     <refsynopsisdiv>
  27         <title>Синтаксис</title>
  28         <synopsis>
  29             deff(funcHeadline, funcBody)
  30             deff(definition)
  31             deff("[r1, r2, ...] = myFunc(in1, in2, ...)", funcBody)
  32             deff "r = myFunc(x,y) r = x^2 - y"
  33             deff "r = myFunc(x,y) x^2 - y"
  34             deff("r = @(x,y) x^2 - y")      // в качестве элемента анонимного контейнера
  35
  36             myFunc = deff(funcHeadline, funcBody)
  37             myFunc = deff(definition)
  38             myFunc = deff("[r1, r2, ...] = fakeName(in1, in2, ...)", funcBody)
  39             myFunc = deff("r = fakeName(x,y) r = x^2 - y")
  40             myFunc = deff("r = fakeName(x,y) x^2 - y")
  41             myFunc = deff("r = @(x,y) x^2 - y")
  42         </synopsis>
  43     </refsynopsisdiv>
  44     <refsection>
  45         <title>Аргументы</title>
  46         <variablelist>
  47             <varlistentry>
  48                 <term>x, y, in1, in2, ...</term>
  49                 <listitem>
  50                     входные аргументы определяемой функции. Последняя может иметь
  51                     любое количество входных аргументов, от 0 до любого N.
  52                     <para/>
  53                 </listitem>
  54             </varlistentry>
  55             <varlistentry>
  56                 <term>r, r1, r2, ...</term>
  57                 <listitem>
  58                     результаты на выходе определяемой функции. Последняя может
  59                     иметь любое количество результатов на выходе, от 0 до любого
  60                     M. Все выходные аргументы должны быть явными, то есть,
  61                     записанными слева от имени функции.
  62                     <para/>
  63                 </listitem>
  64             </varlistentry>
  65             <varlistentry>
  66                 <term>funcHeadline</term>
  67                 <listitem>
  68                     одиночная строка: заголовок функции, то есть, её первая строчка,
  69                     указывающая локальное имя функции и списки её входных аргументов
  70                     с правой стороны и выходных аргументов с левой стороны. Примеры:
  71                     <itemizedlist>
  72                         <listitem>
  73                             <literal>"myFunction(x,y)"</literal> : нет аргументов на выходе
  74                         </listitem>
  75                         <listitem>
  76                             <literal>"r = myFunction(x,y)"</literal> : один аргумент на выходе
  77                         </listitem>
  78                         <listitem>
  79                             <literal>"[a,b] = myFunction(x,y)"</literal> : два аргумента
  80                             на выходе. И т.д.
  81                         </listitem>
  82                     </itemizedlist>
  83                     Пожалуйста, обратите внимание, что a) ключевое слово <literal>function</literal>
  84                     не обязательно указывать. b) запись выходных аргументов, если они есть, на левой
  85                     части заголовочной строчки является обязательной.
  86                     <para/>
  87                 </listitem>
  88             </varlistentry>
  89             <varlistentry>
  90                 <term>funcBody</term>
  91                 <listitem>
  92                     вектор текстов, то есть Scilab-инструкций тела функции, в том
  93                     порядке, в котором они должны быть выполнены. Эти инструкции
  94                     должны определять и назначать значения всех выходных аргументов.
  95                     Завершающее ключевое слово "endfunction" не ожидается.
  96                     <para/>
  97                     Этот вектор ожидается, когда <literal>deff(…)</literal> вызывается
  98                     с двумя входными аргументами.
  99                     <para/>
 100                     <warning>
 101                         Одинарные или двойные кавычки внутри инструкций должны
 102                         дублироваться для защиты.
 103                     </warning>
 104                     <para/>
 105                 </listitem>
 106             </varlistentry>
 107             <varlistentry>
 108                 <term>definition</term>
 109                 <listitem>
 110                     Отдельный текст или вектор текстов, включая как заголовочную
 111                     строчку функции, так и тело.
 112                     <itemizedlist>
 113                         <listitem>
 114                             Если это вектор, то это эквивалентно
 115                             <literal>definition = [funcHeadline ; funcBody]</literal>.
 116                         </listitem>
 117                         <listitem>
 118                             В противном случае одностроковое определение эквивалентно
 119                             <literal>funcHeadline + " " + strcat(funcBody,"; ")</literal>.
 120                         </listitem>
 121                     </itemizedlist>
 122                     Пожалуйста, смотрите разделы "Описание" и "Примеры".
 123                     <para/>
 124                 </listitem>
 125             </varlistentry>
 126             <varlistentry>
 127                 <term>myFunc</term>
 128                 <listitem>
 129                     Публичное имя и идентификатор определяемой функции, неявно
 130                     возвращаемый в текущее окружение, либо явно присваиваемый
 131                     переменной на выходе <literal>deff(…)</literal>.
 132                     <para/>
 133                     <note>
 134                         Когда <literal>deff(…)</literal> вызывается без явных выходных
 135                         аргументов, но в качестве элемента контейнера или в качестве
 136                         входного аргумента другой функции, то она неявно присваивается
 137                         этому элементу или аргументу, который является анонимным. То
 138                         тогда она является
 139                         <emphasis role="bold">анонимной функцией</emphasis>. Например:
 140                         <para/>
 141                         <literal>L = list(3, deff("r=noName(x) x.^2+1"), "Hello");</literal>.
 142                         Результат <literal>deff(…)</literal> присваивается <literal>L(2)</literal>.
 143                         Тогда <literal>L(2)(3.5) // ➜ 13.25</literal>.
 144                     </note>
 145                     <para/>
 146                 </listitem>
 147             </varlistentry>
 148         </variablelist>
 149     </refsection>
 150     <refsection>
 151         <title>Описание</title>
 152         <para>
 153             <literal>deff(…)</literal> может использоваться для определения
 154             <emphasis>отдельной</emphasis> функции из инструкций Scilab, указанных
 155             через матрицу текстов, вместо любого внешнего текстового файла с
 156             инструкциями для исполнения, записанными в блок <literal>function … endfunction</literal>.
 157         </para>
 158         <para>
 159             Файл исходного Scilab-кода может включать в себя определение нескольких
 160             публичных функций. Это не возможно сделать с помощью <literal>deff(…)</literal>:
 161             только одну публичную функцию можно определить. Однако, как и в случае
 162             с файлом, тело определяемой функции может включать в себя один или
 163             несколько блоков <literal>function … endfunction</literal>, определяющих
 164             вложенные приватные функции.
 165         </para>
 166         <para>
 167             Независимо от синтаксиса <literal>deff(…)</literal>, используемого для
 168             обеспечения исходного кода (см. ниже), если он содержит синтаксическую
 169             ошибку, то <literal>deff(…)</literal> выдаст ошибку компиляции
 170             и остановит работу.
 171         </para>
 172         <refsect3>
 173             <title>Указание исходного кода</title>
 174             <para>
 175                 <emphasis role="bold">deff(funcHeadline, funcBody)</emphasis> (2 входа) и
 176                 <emphasis role="bold">deff([funcHeadline ; funcBody])</emphasis>
 177                 (единый конкатенированный вход) эквивалентны.
 178             </para>
 179             <para>
 180                 Когда <varname>funcBody</varname> сделана только из одной (короткой)
 181                 строки, она может быть приклеена и передана вместе с
 182                 <varname>funcHeadline</varname>, как одностроковое определение функции.
 183                 Примеры:
 184                 <table cellpadding="0" cellspacing="0">
 185                     <tr><td><literal>deff("[a,b] = myFunction(x,y) a = x.^2; b = x-y;")</literal></td>
 186                     </tr>
 187                     <tr><td>
 188                             <literal>deff("r = myFunction(x,y) r = (x-y).^2")</literal>.
 189                             Это можно даже упростить до
 190                         </td>
 191                     </tr>
 192                     <tr><td>
 193                             <literal>deff("r = myFunction(x,y) (x-y).^2")</literal>
 194                         </td>
 195                     </tr>
 196                     <tr><td><literal>deff("myFunction(x,y) disp(x.^2 - b)")</literal></td>
 197                     </tr>
 198                 </table>
 199             </para>
 200             <para>
 201                 Когда результат <literal>deff(…)</literal> присваивается или вводится
 202                 в любой анонимный контейнер, то оказывается, что псевдоимя
 203                 <varname>fakeName</varname>, определённое в <varname>funcHeadline</varname>
 204                 не играет роли вообще, и может совсем не использоваться для вызова
 205                 функции. Это имя может быть тогда заменено символом "@" в
 206                 <varname>funcHeadline</varname> для указания, что определяемая
 207                 функция становится <emphasis>анонимной</emphasis>.
 208             </para>
 209         </refsect3>
 210         <refsect3>
 211             <title>Идентификатор определяемой функции</title>
 212             <para>
 213                 Идентификатор - это фактическое слово (имя), которое используется
 214                 для вызова определяемой функции. Следующие три случая представлены
 215                 для примера.
 216             </para>
 217             <para>
 218                 Когда определяемая функция не предполагает присваиваемый результат,
 219                 то её идентификатор возвращается напрямую в вызывающее окружение.
 220                 Её публичное имя тогда является именем, используемым в заголовочной
 221                 строчке представленного исходного кода.
 222             </para>
 223             <para>
 224                 В противном случае, когда <literal>deff(…)</literal> вызывается с
 225                 явным выходным аргументом, то его имя становится единственным
 226                 фактическим  идентификатором публичной функции. В результате, имя
 227                 функции, используемой в исходном коде, нельзя использовать для её
 228                 вызова. Оно становится псевдоименем. По этой причине в заголовочной
 229                 строчке может быть использован символ "@" (ставящийся для "анонимок")
 230                 вместо какого-либо корректного имени функции, определённой в заголовочной
 231                 строчке. Но это не обязательно.
 232             </para>
 233             <para>
 234                 Последний случай использования <literal>deff(…)</literal> в качестве
 235                 элемента контейнера, например когда определяется или вводится в список,
 236                 либо в качестве входного аргумента другой функции. Тогда
 237                 <literal>deff(…)</literal> работает как присвоение. Она возвращает
 238                 идентификатор определяемой функции и присваивает его соответствующему
 239                 элементу списка или входного аргумента. Они безымянны, следовательно
 240                 вызов <literal>deff(…)</literal> является выражением. Определяемая
 241                 функция тогда становиться реально <emphasis>анонимной</emphasis>.
 242             </para>
 243         </refsect3>
 244     </refsection>
 245     <refsection>
 246         <title>Примеры</title>
 247         <refsect3>
 248             <title>Неприсваивающие функции</title>
 249             <para/>
 250             <programlisting role="example"><![CDATA[
 251                 deff('x = myplus(y,z)', 'x = y+z')
 252                 myplus(1,%i)
 253
 254                 deff('[y, z] = mymacro(x)', ['y = 3*x+1'; 'z = a*x + x.^2'])
 255                 a = 3;
 256                 [u, v] = mymacro(2)
 257          ]]></programlisting>
 258             <screen><![CDATA[
 259 --> deff('x = myplus(y,z)', 'x = y+z')
 260 --> myplus(1,%i)
 261  ans  =
 262    1. + i
 263
 264 --> deff('[y, z] = mymacro(x)', ['y = 3*x+1'; 'z = a*x + x.^2'])
 265 --> a = 3;
 266 --> [u, v] = mymacro(2)
 267  v  =
 268    10.
 269
 270  u  =
 271    7.
 272 ]]></screen>
 273             <para>
 274                 С единственным входным и выходным аргументом:
 275             </para>
 276             <programlisting role="example"><![CDATA[
 277                 clear myFunc
 278                 source = ["r = myFunc(x,y)" ; "r = x.*(x-y)"]
 279                 deff(source)
 280                 myFunc(3, -2)
 281          ]]></programlisting>
 282             <screen><![CDATA[
 283 --> source = ["r = myFunc(x,y)" ; "r = x.*(x-y)"]
 284  source  =
 285   "r = myFunc(x,y)"
 286   "r = x.*(x-y)"
 287
 288 --> deff(source)
 289 --> myFunc(3, -2)
 290  ans  =
 291    15.
 292 ]]></screen>
 293             <para>
 294                 Тот же пример с одностроковым определением, которое затем позволяет
 295                 синтаксис, ориентированный на командную строку (без необязательных
 296                 скобок deff, но с, по-прежнему, обязательными разделительными кавычками):
 297             </para>
 298             <programlisting role="example"><![CDATA[
 299                 clear myFunc
 300                 deff "r = myFunc(x,y) r = x.*(x-y)"
 301                 myFunc(1:3, -2)
 302          ]]></programlisting>
 303             <screen><![CDATA[
 304 --> deff "r = myFunc(x,y) r = x.*(x-y)"
 305 --> myFunc(1:3, -2)
 306  ans  =
 307    3.   8.   15.
 308 ]]></screen>
 309             <para>
 310                 Для однострокового прямого определения с единственным выходным аргументом,
 311                 мы можем даже опустить дубликат "r = " в теле функции:
 312             </para>
 313             <programlisting role="example"><![CDATA[
 314                 clear myFunc
 315                 deff "r = myFunc(x,y) x.*(x-y)"
 316                 myFunc(1:3, -2)
 317          ]]></programlisting>
 318             <screen><![CDATA[
 319 --> deff "r = myFunc(x,y) x.*(x-y)"
 320 --> myFunc(1:3, -2)
 321  ans  =
 322    3.   8.   15.
 323 ]]></screen>
 324             <para>
 325                 Функция без присваиваемого выходного аргумента: обратите также внимание
 326                 на использование удвоенных кавычек для защиты их в строке определения:
 327             </para>
 328             <programlisting role="example"><![CDATA[
 329                 clear myFunc
 330                 deff("myFunc(x, y) messagebox(prettyprint(x.*(x-y), ""html"",""""))")
 331                 myFunc([1 2 ; 3 4], -2)
 332          ]]></programlisting>
 333         </refsect3>
 334         <refsect3>
 335             <title>Определяемая функция, присваиваемая реципиенту</title>
 336             <para>
 337                 Придержимся примеров, похожих на приведённые выше:
 338             </para>
 339             <programlisting role="example"><![CDATA[
 340                 clear myFunc actualName
 341                 actualName = deff("r = myFunc(x,y) x.*(x-y)")
 342                 isdef(["myFunc" "actualName"])
 343                 actualName(1:3, -2)
 344                 myFunc(1:3, -2)
 345          ]]></programlisting>
 346             <screen><![CDATA[
 347 --> actualName = deff("r = myFunc(x,y) x.*(x-y)")
 348  actualName  =
 349 [r]=actualName(x,y)
 350
 351 --> isdef(["myFunc" "actualName"])
 352  ans  =
 353   F T
 354
 355 --> actualName(1:3, -2)
 356  ans  =
 357    3.   8.   15.
 358
 359 --> myFunc(1:3, -2)
 360 Undefined variable: myFunc
 361 ]]></screen>
 362             <para>
 363                 Поскольку имя "внутренней" функции является псевдоименем, то мы
 364                 можем вместо него использовать "@" (символ "@" нельзя использовать
 365                 в фактических именах функций):
 366             </para>
 367             <programlisting role="example"><![CDATA[
 368                 clear actualName
 369                 actualName = deff("r = @(x,y) x.*(x-y)");
 370                 actualName(1:3, -2)
 371          ]]></programlisting>
 372             <screen><![CDATA[
 373 --> actualName = deff("r = @(x,y) x.*(x-y)");
 374 --> actualName(1:3, -2)
 375  ans  =
 376    3.   8.   15.
 377 ]]></screen>
 378             <para>
 379                 Теперь напрямую присвоим созданную функцию безымянному реципиенту.
 380                 Хотя функция становится анонимной, мы, по-прежнему, можем вызывать её:
 381             </para>
 382             <programlisting role="example"><![CDATA[
 383                 L = list("abc", deff("r = @(x,y) x.*(x-y)"), %z);
 384                 L(2)(1.1:4, -2.1)
 385                 // Мы можем извлекать и устанавливать имя анонимной функции:
 386                 Abc = L(2)
 387                 Abc(1.1:4, -2.1)
 388          ]]></programlisting>
 389             <screen><![CDATA[
 390 --> L = list("abc", deff("r = @(x,y) x.*(x-y)"), %z);
 391 --> L(2)(1.1:4, -2.1)
 392  ans  =
 393    3.52   8.82   16.12
 394
 395 --> Abc = L(2)
 396  Abc  =
 397 [r]=Abc(x,y)
 398
 399 --> Abc(1.1:4, -2.1)
 400  ans  =
 401    3.52   8.82   16.12
 402 ]]></screen>
 403             <para>
 404                 Наконец, давайте используем <literal>deff()</literal> для прямого
 405                 определения и передачи функции в качестве входного элемента другой
 406                 функции:
 407             </para>
 408             <programlisting role="example"><![CDATA[
 409                 function r = test(txt, x, theFunc)
 410                     r = x + theFunc(txt)
 411                 endfunction
 412
 413                 test(rand(2,3), 0.7, deff("r = @(M) sum(size(M).^2)"))
 414          ]]></programlisting>
 415             <screen><![CDATA[
 416 --> test(rand(2,3), 0.7, deff("r = @(M) sum(size(M).^2)"))
 417  ans  =
 418    13.7
 419 ]]></screen>
 420         <para>
 421             В этом примере передаваемая функция является анонимной в вызывающем
 422             окружении, но присваивается и получает своё имя "theFunct" внутри
 423             вызываемой функции.
 424         </para>
 425         </refsect3>
 426     </refsection>
 427     <refsection role="see also">
 428         <title>Смотрите также</title>
 429         <simplelist type="inline">
 430             <member>
 431                 <link linkend="function">function</link>
 432             </member>
 433             <member>
 434                 <link linkend="exec">exec</link>
 435             </member>
 436             <member>
 437                 <link linkend="getd">getd</link>
 438             </member>
 439             <member>
 440                 <link linkend="genlib">genlib</link>
 441             </member>
 442             <member>
 443                 <link linkend="jdeff">jdeff</link>
 444             </member>
 445             <member>
 446                 <link linkend="jcompile">jcompile</link>
 447             </member>
 448         </simplelist>
 449     </refsection>
 450     <refsection role="history">
 451         <title>История</title>
 452         <revhistory>
 453             <revision>
 454                 <revnumber>6.0.0</revnumber>
 455                 <revdescription>
 456                    <itemizedlist>
 457                      <listitem>
 458                        Входная опция
 459                        <ulink url="https://help.scilab.org/docs/5.5.2/en_US/deff.html">
 460                          <varname>opt="c"|"p"|"n"</varname>
 461                        </ulink> больше не доступна.
 462                      </listitem>
 463                      <listitem>
 464                         Определяемая <varname>newfunction</varname> теперь имеет
 465                         тип 13 (вместо 11).
 466                      </listitem>
 467                   </itemizedlist>
 468                 </revdescription>
 469             </revision>
 470             <revision>
 471                 <revnumber>6.1.1</revnumber>
 472                 <revdescription>
 473                    <itemizedlist>
 474                      <listitem>
 475                         Добавлен необязательный выходной аргумент. Могут определяться
 476                         анонимные функции.
 477                      </listitem>
 478                      <listitem>
 479                         Поддерживаются одиночные входные аргументы, конкатенирующие
 480                         заголовочную строку функции и её тело.
 481                      </listitem>
 482                      <listitem>
 483                         Поддерживается синтаксис одиночной строки, вроде
 484                         <literal>deff "r = myFun(x,y) x.^2-y"</literal>
 485                      </listitem>
 486                      <listitem>
 487                         Поддерживается псевдоимя функции "@".
 488                      </listitem>
 489                   </itemizedlist>
 490                 </revdescription>
 491             </revision>
 492         </revhistory>
 493     </refsection>
 494 </refentry>