<?xml version="1.0" encoding="UTF-8"?>
<!--
 * Scilab ( https://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) 2012 - 2016 - Scilab Enterprises
 * Copyright (C) 2019 - Samuel GOUGEON
 *
 * This file is hereby licensed under the terms of the GNU GPL v2.0,
 * pursuant to article 5.3.4 of the CeCILL v.2.1.
 * This file was originally licensed under the terms of the CeCILL v2.1,
 * and continues to be available under such terms.
 * For more information, see the COPYING file which you should have received
 * along with this program.
 *
 -->
<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="empty">
    <refnamediv>
        <refname>пустая матрица []</refname>
        <refpurpose>пустая матрица. Деструктор диапазонов массива.</refpurpose>
    </refnamediv>
    <refsection>
        <title>Содержание</title>
        <simplelist type="inline">
            <member>
                <link linkend="empty_general_properties">Общие свойства [ ]</link>
            </member>
            <member>
                <link linkend="empty_operand_or_argument">[ ] в качестве операнда или входного аргумента</link>
            </member>
            <member>
                <link linkend="empty_assigned_as_destructor">[ ] в качестве деструктора диапазонов</link>
            </member>
            <member>
                <link linkend="empty_examples">Примеры</link>
            </member>
            <member>
                <link linkend="empty_seealso">Смотрите также</link>
            </member>
            <member>
                <link linkend="empty_history">История</link>
            </member>
        </simplelist>
    </refsection>
    <refsection>
        <title>Описание</title>
        <refsect3 id="empty_general_properties">
            <title>Общие свойства [ ]</title>
            <para>
            Пустые квадратные скобки <literal>[]</literal> представляют пустую матрицу. Опишем её общие свойства.
            </para>
            <orderedlist>
                <listitem>
                    <para>
                    Она имеет лишь две размерности. Любая размерность больше двух автоматически сокращается:
                    <screen><![CDATA[
--> e = ones(1,2,0,2); size(e)
 ans  =
   0.   0.
--> e == []
 ans  =
  T
]]></screen>
                    </para>
                </listitem>
                <listitem>
                    <para>
                    Она всегда вещественного десятичного типа. Нет пустых матриц ни целочисленного типа
                    (int8, uint8, int16, uint16, int32, uint32, int64, uint64), ни строкового типа, и т.д.:
                    <screen><![CDATA[
--> type(uint8([]))  // не типа 8 (кодированные целые числа)
 ans  =
   1.
--> a = [1 2 ; 3 4] + %i;
--> a(1,:) = []
 a  =
   3. + i     4. + i
--> a(1,:) = [], isreal(a)
 a  =
    []
 ans  =
  T
--> t = "abcd efg", type(t)
 t  =
 abcd efg
 ans  =
   10.
--> t(1) = [], type(t)
 t  =
    []
 ans  =
   1.
]]></screen>
                    </para>
                </listitem>
                <listitem>
                    <para>
                    Однако она всегда отличается от разрежённой пустой матрицы:
                    <screen><![CDATA[
--> se = sparse([])
 se  =
(  0,  0) zero sparse matrix
--> size(se)
 ans  =
   0.   0.
--> se == []
 ans  =
  F
]]></screen>
                    </para>
                </listitem>
                <listitem>
                    <para>
                    Она также отличается от всех пустых разнотипных контейнеров
                    <literal>list()</literal>, <literal>struct()</literal> или
                    <literal>cell()</literal> :
                    <screen><![CDATA[
--> L = list()
 L  =
     ()
--> L == []
 ans  =
  F
--> s = struct()
 s  =
0x0 struct array with no fields.
--> s == []
 ans  =
  F
--> c = cell()
 c  =
   {}
--> c == []
 ans  =
  F
]]></screen>
                    </para>
                </listitem>
            </orderedlist>
        </refsect3>
        <refsect3 id="empty_operand_or_argument">
            <title>[ ] в качестве операнда или входного аргумента</title>
            <orderedlist>
                <listitem>
                    <para>
                    В качестве операнда обычных предопределённых небулевых операторов [] устанавливает результат равным [].
                    <emphasis>Все следующие операции дают</emphasis> []:
                    <table>
                        <tr><td colspan="2"><emphasis role="bold">Унарные операторы</emphasis></td></tr>
                        <tr><td colspan="2">[]', [].', -[],  ~[]</td></tr>
                        <tr><td></td><td></td></tr>
                        <tr><td colspan="2"><emphasis role="bold">Binary numerical operators</emphasis></td></tr>
                        <tr><td>суммирование:</td>      <td> [] + [1 2], [1 2] + []</td></tr>
                        <tr><td>вычитание:</td>   <td> [] - [1 2], [1 2] - []</td></tr>
                        <tr><td>деление:</td>      <td> []/[1 2], []./[1 2], [1 2]/[], [1 2]./[]</td></tr>
                        <tr><td>левое деление:</td> <td> []\[1 2], [].\[1 2], [1 2]\[], [1 2].\[]</td></tr>
                        <tr><td>умножение:</td><td> []*[1 2], [].*[1 2], [1 2]*[], [1 2].*[]</td></tr>
                        <tr><td>кронекер:</td>     <td> [].*.[1 2], [1 2].*.[]</td></tr>
                        <tr><td>степень:</td>         <td> []^[1 2], [].^[1 2], [1 2]^[], [1 2].^[]</td></tr>
                        <tr><td></td><td></td></tr>
                        <tr><td colspan="2"><emphasis role="bold">Сравнение на неравенство</emphasis></td></tr>
                        <tr><td>больше:</td><td> []>[1 2], []>=[1 2], [1 2]>[], [1 2]>=[]</td></tr>
                        <tr><td>меньше:</td><td> []&lt;[1 2], []&lt;=[1 2], [1 2]&lt;[], [1 2]&lt;=[]</td></tr>
                    </table>
                    </para>
                </listitem>
                <listitem>
                    <para>
                    В качестве операнда булевых бинарных операторов [] <emphasis>эквивалентна %T</emphasis>:
                    <table>
                        <tr><td colspan="4"><emphasis role="bold">Двоичные числовые операторы</emphasis></td></tr>
                        <tr><td>или:</td> <td> [] | [%T %F], [%T %F] | []        </td><td>→</td><td>[%T %T]</td></tr>
                        <tr><td>и:</td><td> [] &amp; [%T %F], [%T %F] &amp; []</td><td>→</td><td>[%T %F]</td></tr>
                    </table>
                    </para>
                    Но обратите внимание:
                    <itemizedlist>
                        <listitem>
                            <para>
                                <literal>or([])</literal> равно %F.
                            </para>
                        </listitem>
                        <listitem>
                            <para>
                                В качестве условия любого <literal>if</literal> или <literal>while</literal>,
                                [] равна %F:
                                <screen><![CDATA[
--> if []
-->     r = "[] равно %T в любом условии if";
--> else
-->     r = "[] равно %F в любом условии if";
--> end
--> r
 r  =
 [] равно %F в любом условии if
]]></screen>
                            </para>
                        </listitem>
                    </itemizedlist>
                </listitem>
                <listitem>
                    <para>
                    При конкатенации [] просто игнорируется:
                    <literal>[A,[]] == [[],A] == [A ; []] == [[] ; A] == A</literal>
                    </para>
                </listitem>
                <listitem>
                    <para>
                    При конкатенации текста <literal>+[]</literal> даёт []:
                    <literal>[]+["a" "bc"] == ["a" "bc"]+[] == []</literal>
                    </para>
                </listitem>
                <listitem>
                    <para>
                        В качестве специальной входной матрицы функций линейной алгебры или общих функций
                        ответ зависит от конкретной функции. Он документируется на странице справки для
                        каждой функции. Например:
                    </para>
                    <para>
                    <table>
                    <tr valign="top">
                    <td>
                    <table>
                        <tr><td><literal>det([])</literal></td>     <td><literal>1</literal></td></tr>
                        <tr><td><literal>rank([])</literal></td>    <td><literal>0</literal></td></tr>
                        <tr><td><literal>trace([])</literal></td>   <td><literal>0</literal></td></tr>
                        <tr><td><literal>norm([])</literal></td>    <td><literal>0</literal></td></tr>
                        <tr><td><literal>cond([])</literal></td>    <td><literal>0</literal></td></tr>
                        <tr><td><literal>rcond([])</literal></td>   <td><literal>Inf</literal></td></tr>
                    </table>
                    </td>
                    <td></td>
                    <td>
                    <table>
                        <tr><td><literal>diag([])</literal></td>    <td><literal>[]</literal></td></tr>
                        <tr><td><literal>tril([])</literal></td>    <td><literal>[]</literal></td></tr>
                        <tr><td><literal>triu([])</literal></td>    <td><literal>[]</literal></td></tr>
                        <tr><td><literal>min([])</literal></td>     <td><literal>[]</literal></td></tr>
                        <tr><td><literal>max([])</literal></td>     <td><literal>[]</literal></td></tr>
                        <tr><td><literal>sign([])</literal></td>    <td><literal>[]</literal></td></tr>
                        <tr><td><literal>clean([])</literal></td>   <td><literal>[]</literal></td></tr>
                        <tr><td><literal>svd([])</literal></td>     <td><literal>[]</literal></td></tr>
                    </table>
                    </td>
                    <td></td>
                    <td>
                    <table>
                        <tr><td><literal>cumprod([])</literal></td> <td><literal>[]</literal></td></tr>
                        <tr><td><literal>cumsum([])</literal></td>  <td><literal>[]</literal></td></tr>
                        <tr><td><literal>sum([])</literal></td>     <td><literal>0</literal></td></tr>
                        <tr><td><literal>prod([])</literal></td>    <td><literal>1</literal></td></tr>
                        <tr><td><literal>mean([])</literal></td>    <td><literal>Nan</literal></td></tr>
                        <tr><td><literal>median([])</literal></td>  <td><literal>Nan</literal></td></tr>
                        <tr><td><literal>stdev([])</literal></td>   <td><literal>Nan</literal></td></tr>
                        <tr><td><literal>mad([])</literal></td>     <td><literal>Nan</literal></td></tr>
                        <tr><td><literal>variance([])</literal></td><td><literal>Nan</literal></td></tr>
                    </table>
                    </td>
                    </tr>
                    </table>
                    </para>
                </listitem>
                <listitem>
                    <para>
                        В качестве входного аргумента функций [] часто используется для выбора значения
                        по умолчанию входного аргумента (чтобы как-то пропусть его, избежать указания 
                        фактического конкретного значения). Однако это не жёсткое правило.
                    </para>
                </listitem>
                <!--
                <listitem>
                    <para>
                        Пустая линейная система (списки <literal> syslin</literal>) может иметь несколько
                        строк или столбцов.
                        w=ssrand(2,2,2);
                        wr=[]*w;
                        size(wr), w1=ss2tf(wr), size(w1)
                    </para>
                </listitem>
                -->
            </orderedlist>
        </refsect3>
        <refsect3 id="empty_assigned_as_destructor">
            <title>Использование [ ] для удаления диапазонов в массивах</title>
        </refsect3>
        <para>
            Что касается массива любого количества размерностей и любого размера, который может быть
            матрицей или гиперматрицей любого типа данных, массивом структура или cell-массивом, то
            [] может использоваться для удаления указанного диапазона (строк, столбцов и т.д.). Это
            указание должно перекрывать полный размер массива по крайней мере вдоль одной из его
            размерностей.
        </para>
        <para>Примеры:</para>
        <para>С матрицей десятичных чисел:</para>
        <programlisting role="example"><![CDATA[
a = grand(3,5,"uin",0,9)
     ]]></programlisting>
        <screen><![CDATA[
--> a = grand(3,5,"uin",0,9)
 a  =
   2.   4.   8.   0.   9.
   2.   1.   3.   6.   4.
   4.   9.   5.   9.   7.
--> a(:,[3 5]) = []
 a  =
   2.   4.   0.
   2.   1.   6.
   4.   9.   9.
--> a(2,:) = []
 a  =
   2.   4.   0.
   4.   9.   9.
]]></screen>
        <para>
            С гиперматрицей текстовых значений:
        </para>
        <programlisting role="example"><![CDATA[
cs = cumsum(grand(2,4,3,"uin",1,3));
t = matrix(strsplit(ascii(grand(1,cs($),"uin",ascii("a"),ascii("c"))),cs(1:$-1)),2,4,3)
     ]]></programlisting>
        <screen><![CDATA[
--> cs = cumsum(grand(2,4,3,"uin",1,3));
--> t = matrix(strsplit(ascii(grand(1,cs($),"uin",ascii("a"),ascii("c"))),cs(1:$-1)),2,4,3)
 t  =
(:,:,1)
!ccc  b    b   b  !
!bbb  bcc  bc  c  !
(:,:,2)
!aa  aab  bc  a   !
!ab  a    cc  ba  !
(:,:,3)
!c   aba  c    abb  !
!bc  cc   acb  c    !
--> t(:,3,:) = []  // Удаление всех третьих столбцов
 t  =
(:,:,1)
!ccc  b    b  !
!bbb  bcc  c  !
(:,:,2)
!aa  aab  a   !
!ab  a    ba  !
(:,:,3)
!c   aba  abb  !
!bc  cc   c    !
--> t(:,:,2) = []   // Удаление второй страницы
 t  =
(:,:,1)
!ccc  b    b  !
!bbb  bcc  c  !
(:,:,2)
!c   aba  abb  !
!bc  cc   c    !
]]></screen>
        <para>
            С cell-массивами:
        </para>
        <programlisting role="example"><![CDATA[
c = cat(3, {"start", -1.23, %f  ; (1-%s)^2, gda(), list(2,,%z)}, ..
           {%t     , "abc", 5.2 ; int8(21), []   , %z})
     ]]></programlisting>
        <screen><![CDATA[
--> c = cat(3, {"start", -1.23, %f  ; (1-%s)^2, gda(), list(2,,%z)}, ..
               {%t     , "abc", 5.2 ; int8(21), []   , %z})
 c  =
(:,:,1)
  [1x1 string    ]  [1x1 constant]  [1x1 boolean]
  [1x1 polynomial]  [1x1 handle  ]  [    list   ]
(:,:,2)
  [1x1 boolean]  [1x1 string  ]  [1x1 constant  ]
  [1x1 int8   ]  [0x0 constant]  [1x1 polynomial]
--> c(:,2,:) = []                   // Удаление всех вторых столбцов
 c  =
(:,:,1)
  [1x1 string    ]  [1x1 boolean]
  [1x1 polynomial]  [    list   ]
(:,:,2)
  [1x1 boolean]  [1x1 constant  ]
  [1x1 int8   ]  [1x1 polynomial]
--> c(1,:,:) = []                   // Удаление всех первых строк
 c  =
(:,:,1)
  [1x1 polynomial]  [ list]
(:,:,2)
  [1x1 int8]  [1x1 polynomial]
]]></screen>
        <para>
            С массивом структур:
        </para>
        <screen><![CDATA[
--> s(4,5).r = %pi;
--> s.b = %t
 s  =
4x5 struct array with fields:
   r
   b
--> s([1 3],:) = []
 s  =
2x5 struct array with fields:
   r
   b
--> s(:,2) = []
 s  =
2x4 struct array with fields:
   r
   b
]]></screen>
    </refsection>
    <refsection id="empty_examples">
        <title>Другие примеры</title>
        <programlisting role="example"><![CDATA[
type(string([]))
[type(int8([])) , type(int16([])) , type(int32([])) , type(int64([]))]
[type(uint8([])), type(uint16([])), type(uint32([])), type(uint64([]))]
[] * %F
     ]]></programlisting>
        <screen><![CDATA[
--> type(string([]))
 ans  =
   1.
--> [type(int8([])) , type(int16([])) , type(int32([])) , type(int64([]))]
 ans  =
   1.   1.   1.   1.
--> [type(uint8([])), type(uint16([])), type(uint32([])), type(uint64([]))]
 ans  =
   1.   1.   1.   1.
--> [] * %F
 ans  =
    []
]]></screen>
        <para/>
        <programlisting role="example"><![CDATA[
A = [%s-1, %s^2]
A + []
A - []
A * []
     ]]></programlisting>
        <screen><![CDATA[
--> A = [%s-1, %s^2]
 A  =
           2
  -1 +s   s
--> A + []
 ans  =
    []
--> A - []
 ans  =
    []
--> A * []
 ans  =
    []
]]></screen>
        <para/>
        <programlisting role="example"><![CDATA[
string([]) == []
["a" "bc"] + []
[] + ["a" "bc"]
     ]]></programlisting>
        <screen><![CDATA[
--> string([]) == []
 ans  =
  T
--> ["a" "bc"] + []
 ans  =
    []
--> [] + ["a" "bc"]
 ans  =
    []
]]></screen>
        <para/>
        <programlisting role="example"><![CDATA[
A = rand(2,2);
A([],:)
     ]]></programlisting>
        <screen><![CDATA[
--> A = rand(2,2);
--> A([],:)
 ans  =
    []
]]></screen>
        <para/>
        <programlisting role="example"><![CDATA[
[det([]) rank([]) trace([]) norm([]) cond([]) rcond([])]
     ]]></programlisting>
        <screen><![CDATA[
--> [det([]) rank([]) trace([]) norm([]) cond([]) rcond([])]
 ans  =
   1.   0.   0.   0.   0.   Inf
]]></screen>
        <para/>
        <programlisting role="example"><![CDATA[
[sum([]) prod([]) mean([]) median([]) stdev([]) mad([])]
     ]]></programlisting>
        <screen><![CDATA[
--> [sum([]) prod([]) mean([]) median([]) stdev([]) mad([])]
 ans  =
   0.   1.   Nan   Nan   Nan   Nan
]]></screen>
    </refsection>
    <refsection role="see also" id="empty_seealso">
        <title>Смотрите также</title>
        <simplelist type="inline">
            <member>
                <link linkend="null">null</link>
            </member>
            <member>
                <link linkend="isempty">isempty</link>
            </member>
            <member>
                <link linkend="emptystr">emptystr</link>
            </member>
            <member>
                <link linkend="brackets">brackets</link>
            </member>
            <member>
                <link linkend="symbols">operators</link>
            </member>
            <member>
                <link linkend="matrices">matrices</link>
            </member>
            <member>
                <link linkend="oldEmptyBehaviour">oldEmptyBehaviour</link>
            </member>
            <member>
                <link linkend="insertion">insertion</link>
            </member>
        </simplelist>
    </refsection>
    <refsection id="empty_history">
        <title>История</title>
        <revhistory>
            <revision>
                <revnumber>6.0.0</revnumber>
                <revremark>
                    <itemizedlist>
                      <listitem>
                          <literal>A+[]</literal>, <literal>[]+A</literal> и <literal>A-[]</literal>
                          теперь возвращают <literal>[]</literal> вместо <literal>A</literal>.
                          <literal>[]-A</literal> теперь возвращают <literal>[]</literal> вместо
                          <literal>-A</literal>.
                      </listitem>
                      <listitem>
                         <literal> A>[] </literal>, <literal> A>=[] </literal>,
                         <literal> A&lt;[] </literal>, <literal> A&lt;=[] </literal>,
                         <literal> []>A </literal>, <literal> []>=A </literal>,
                         <literal> []&lt;A </literal> и <literal> []&lt;=A </literal> теперь возвращают
                         <literal> [] </literal> вместо ошибки.
                      </listitem>
                    </itemizedlist>
                </revremark>
            </revision>
        </revhistory>
    </refsection>
</refentry>

