<?xml version="1.0" encoding="UTF-8"?>
<!--
 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) 2008 - INRIA
 * Copyright (C) 2012 - 2016 - Scilab Enterprises
 * Copyright (C) 2017 - 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:ns5="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="unique" xml:lang="ru">
    <refnamediv>
        <refname>unique</refname>
        <refpurpose>удалить все повторяющиеся компоненты из вектора или матрицы</refpurpose>
    </refnamediv>
    <refsynopsisdiv>
        <title>Синтаксис</title>
        <synopsis>
            [U, km, ku, nb] = unique(M)
            [U, km, ku, nb] = unique(M, orient)
            [U, km, ku, nb] = unique(.., "keepOrder")
            [U, km, ku, nb] = unique(.., "uniqueNan")
        </synopsis>
    </refsynopsisdiv>
    <refsection role="parameters">
        <title>Аргументы</title>
        <variablelist>
            <varlistentry>
                <term>M</term>
                <listitem>
                    <para>
                        вектор, матрица или гиперматрица логических значений, чисел или текстов.
                        Принимаются числовые или логические разрежённые матрицы.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>orient</term>
                <listitem>
                    <para>флаг с возможными значениями: 1 или "r", 2 или "c".
                        Не может использоваться, если <varname>M</varname> является гиперматрицей.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>U</term>
                <listitem>
                    <para>
                      <itemizedlist>
                        <listitem>
                            <para>
                              Если <varname>orient</varname> не используется: вектор извлечённых
                              <varname>M</varname> компонентов, сортированных в полядке возрастания.
                              Если <varname>M</varname> является вектором-строкой, то <varname>U</varname>
                              так же является вектором-строкой. В случаях всех иных <varname>M</varname>
                              <varname>U</varname> является вектором-столбцом.
                            </para>
                        </listitem>
                        <listitem>
                          Если <varname>orient</varname> используется: матрица извлечённых
                          <varname>M</varname> строк или столбцов, сортированных в лексикографическом
                          порядке возрастания.
                        </listitem>
                      </itemizedlist>
                    </para>
                    <para>
                        Если <varname>M</varname> является разрежённой, то <varname>U</varname> всегда разрежённая.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>km</term>
                <listitem>
                    <para>
                      Вектор индексов первых встреченных значений, таких что
                      <literal>U = M(km)</literal> или <literal>U = M(km,:)</literal>
                      или <literal>U = M(:,km)</literal>.
                    </para>
                    <para>
                        <varname>km</varname> является строкой, если <varname>M</varname> является
                        строкой или если используется <literal>orient="c"</literal>. В противном случае
                        это столбец.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>ku</term>
                <listitem>
                    Массив индексов в <varname>U</varname>, таких что в соответствии с опцией
                    <varname>orient</varname>
                    <itemizedlist>
                        <listitem>
                          "*": <varname>ku</varname> имеет размер <literal>size(M)</literal>, и <literal>U(ku) = M</literal>
                        </listitem>
                        <listitem>
                            "r": <varname>ku</varname> имеет размер <literal>[size(M,1), 1]</literal>, и <literal>U(ku,:) = M</literal>
                        </listitem>
                        <listitem>
                            "c": <varname>ku</varname> имеет размер <literal>[1, size(M,2)]</literal>, и <literal>U(:,ku) = M</literal>
                        </listitem>
                    </itemizedlist>
                    <para/>
                    <warning>
                        <varname>ku</varname> является плотной, даже когда <varname>M</varname>
                        является разрежённой и используется всеобщий режим "*".
                    </warning>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>nb</term>
                <listitem>
                    <para>
                      Вектор целых чисел > 0 той же формы, что и <varname>k</varname>:
                      количество случаев <varname>M</varname> соответствующих непродублированных элементов
                      (компонентов, строк, столбцов) возвращаемых в <varname>U</varname>.
                    </para>
                </listitem>
            </varlistentry>
        </variablelist>
    </refsection>
    <refsection role="description">
        <title>Описание</title>
        <para>
            <literal>unique(M)</literal> возвращает вектор, который содержит уникальные элементы
            <literal>M</literal> в порядке возрастания.
        </para>
        <para>
            <literal>unique(M,"r")</literal> или <literal>unique(M,1)</literal> возвращает
            уникальные строки <literal>M</literal> в лексикографическом порядке возрастания.
        </para>
        <para>
            <literal>unique(M,"c")</literal> или <literal>unique(M,2)</literal> возвращает
            уникальные столбцы <literal>M</literal> в лексикографическом порядке возрастания.
        </para>
        <para>
            <literal>unique(M,.. "keepOrder")</literal> возвращает <varname>M</varname> недублированных
            входов в их исходном порядке в <varname>M</varname>.  <literal>"keepOrder"</literal> нечувствителен
            к регистру.
        </para>
        <para>
            <literal>unique(M,.. "uniqueNan")</literal> принимает все значения Nan одинаковыми и не дублирует их.
            По умолчанию любой Nan отличается от другого Nan включая себя самого: <literal>%nan&lt;>%nan</literal>
            равен истине, пока не будет использоваться <literal>"uniqueNan"</literal>. Определение
            <literal>"uniqueNan"</literal> нечувствительно к регистру.
        </para>
        <para>
            Для логических значений, <literal>unique(…)</literal> полезна главным образом с опциями
            <literal>"r"</literal> or <literal>"c"</literal>.
        </para>
        <para>
            <note>
                Комплексные числа сортируются сначала по амплитудам, а затем по фазам в [-π,π].
            </note>
        </para>
    </refsection>
    <refsection role="examples">
        <title>Примеры</title>
        <para>С некотороми числами:</para>
        <programlisting role="example"><![CDATA[
M = int8([2  0  2  2  1  1  1  2  1  1  0  1  1  0  1  1
          0  1  2  0  1  2  2  0  1  1  2  0  1  0  0  0
          ])
[u, km] = unique(M)
[uc, kmc] = unique(M, "c")
 ]]></programlisting>
    <screen><![CDATA[
--> M
 M =
  2  0  2  2  1  1  1  2  1  1  0  1  1  0  1  1
  0  1  2  0  1  2  2  0  1  1  2  0  1  0  0  0

--> [u, km] = unique(M)
 u  =
  0
  1
  2

 km  =
   2.
   4.
   1.

--> [uc, kmc] = unique(M, "c")
 uc  =
  0  0  0  1  1  1  2  2
  0  1  2  0  1  2  0  2

 kmc  =
   14.   2.   11.   12.   5.   6.   1.   3.
]]></screen>
        <para>С комплексными числами:</para>
        <programlisting role="example"><![CDATA[
i = %i;
c = [1+i, 1-i, -i, i, -i, 1+i]
[u, k] = unique(c)
[uc, kc] = unique(c, "c")
 ]]></programlisting>
    <screen><![CDATA[
--> c = [1+i, 1-i, -i, i, -i, 1+i]
 c  =
   1. + i    1. - i    0. - i    0. + i    0. - i    1. + i

--> [u, k] = unique(c)
 u  =
   0. - i    0. + i    1. - i    1. + i
 k  =
   3.   4.   2.   1.

--> [uc, kc] = unique(c, "c")
 uc  =
   0. - i    0. + i    1. - i    1. + i
 kc  =
   3.   4.   2.   1.
]]></screen>

    <para>С текстом:</para>
        <programlisting role="example"><![CDATA[
t = ["BA" "BB" "AB" "BA" "AB" "BA" "AB" "AB" "BA" "AA" "AB" "BA" "BA" "BA" "AA"
     "AA" "AB" "AA" "AA" "BB" "BB" "BB" "BA" "AB" "AB" "BB" "BB" "AB" "AB" "AA"
    ]
u = unique(t)'
[u, kt, ku, nb] = unique(t(1,:))
[u, kt] = unique(t(1,:), "keepOrder")  // сохранение исходного порядка элементов строки №1
[uc, ktc, kuc, nb] = unique(t, "c")
[uc, ktc, kuc, nb] = unique(t, "c", "keepOrder")  // сохранение исходного порядка столбцов
[and(t(:,ktc)==uc), and(uc(:,kuc)==t) ]
 ]]></programlisting>
    <screen><![CDATA[
--> t = ["BA" "BB" "AB" "BA" "AB" "BA" "AB" "AB" "BA" "AA" "AB" "BA" "BA" "BA" "AA"
  >      "AA" "AB" "AA" "AA" "BB" "BB" "BB" "BA" "AB" "AB" "BB" "BB" "AB" "AB" "AA"
  >     ]
 t  =
!BA  BB  AB  BA  AB  BA  AB  AB  BA  AA  AB  BA  BA  BA  AA  !
!AA  AB  AA  AA  BB  BB  BB  BA  AB  AB  BB  BB  AB  AB  AA  !

--> u = unique(t)'
 u  =
!AA  AB  BA  BB  !

--> [u, kt, ku, nb] = unique(t(1,:))
 u  =
!AA  AB  BA  BB  !

 kt  =
   10.   3.   1.   2.

 nb  =
   2.   5.   7.   1.

--> [u, kt] = unique(t(1,:), "keepOrder")  // сохранение исходного порядка
 u  =
!BA  BB  AB  AA  !

 kt  =
   1.   2.   3.   10.

--> [uc, ktc, kuc, nb] = unique(t, "c")
 uc  =
!AA  AA  AB  AB  AB  BA  BA  BA  BB  !             сортированные столбцы
!AA  AB  AA  BA  BB  AA  AB  BB  AB  !

 ktc  =
   15.   10.   3.   8.   5.   1.   9.   6.   2.

 nb  =
   1.   1.   1.   1.   3.   2.   3.   2.   1.

--> [uc, ktc, kuc, nb] = unique(t, "c", "keepOrder")  // сохранение исходного порядка
 uc  =
!BA  BB  AB  AB  BA  AB  BA  AA  AA  !
!AA  AB  AA  BB  BB  BA  AB  AB  AA  !

 ktc  =
   1.   2.   3.   5.   6.   8.   9.   10.   15.

 nb  =
   2.   1.   1.   3.   2.   1.   3.   1.   1.

--> [and(t(:,ktc)==uc), and(uc(:,kuc)==t) ]
 ans  =
  T  T
]]></screen>
        <para/>
        <para>Со значениями Nan (и Inf). Опция "uniqueNan":</para>
        <programlisting role="example"><![CDATA[
M = [2  2  %nan  1     2  0     1  %nan  0    %nan
     1  0  1     %nan  0  %inf  0  1     %inf 1
    ];
[v, km, kv, n] = unique(M); v',n'
[v, km, kv, n] = unique(M, "uniqueNan"); v',n'
unique(M, "c")
[v, kmc, kvc, n] = unique(M, "c", "uniqueNan")
 ]]></programlisting>
    <screen><![CDATA[
--> M
 M  =
   2.   2.   Nan   1.    2.   0.    1.   Nan   0.    Nan
   1.   0.   1.    Nan   0.   Inf   0.   1.    Inf   1.

--> [v, km, kv, n] = unique(M); v',n'
 ans  =
   0.   1.   2.   Inf   Nan   Nan   Nan   Nan

 ans  =
   5.   6.   3.   2.   1.   1.   1.   1.

--> [v, km, kv, n] = unique(M, "uniqueNan"); v',n'
 ans  =
   0.   1.   2.   Inf   Nan

 ans  =
   5.   6.   3.   2.   4.

--> unique(M, "c")
 ans  =
   0.    1.   1.    2.   2.   Nan   Nan   Nan
   Inf   0.   Nan   0.   1.   1.    1.    1.

--> [v, kmc, kvc, n] = unique(M, "c", "uniqueNan")
 v  =
   0.    1.   1.    2.   2.   Nan
   Inf   0.   Nan   0.   1.   1.

 kmc  =
   6.   7.   4.   2.   1.   3.

 n  =
   2.   1.   1.   2.   1.   3.
]]></screen>
    </refsection>
    <refsection role="see also">
        <title>Смотрите также</title>
        <simplelist type="inline">
            <member>
                <link linkend="members">members</link>
            </member>
            <member>
                <link linkend="gsort">gsort</link>
            </member>
            <member>
                <link linkend="vectorfind">vectorfind</link>
            </member>
            <member>
                <link linkend="grep">grep</link>
            </member>
            <member>
                <link linkend="union">union</link>
            </member>
            <member>
                <link linkend="intersect">intersect</link>
            </member>
        </simplelist>
    </refsection>
    <refsection role="history">
        <title>История</title>
        <revhistory>
            <revision>
                <revnumber>6.0.2</revnumber>
                <revdescription>
                    unique() теперь может использоваться для удаления дубликатов комплексных чисел.
                </revdescription>
            </revision>
            <revision>
                <revnumber>6.1.0</revnumber>
                <revdescription>
                    <itemizedlist>
                        <listitem>
                            Расширено до логических значений.
                        </listitem>
                        <listitem>
                            Введены опции "keepOrder" и "uniqueNan".
                        </listitem>
                        <listitem>
                            Введён четвертый выходной аргумент <literal>nb</literal>.
                        </listitem>
                    </itemizedlist>
                </revdescription>
            </revision>
            <revision>
                <revnumber>6.1.1</revnumber>
                <revdescription>
                  Реализован третий выходной аргумент <literal>ku</literal>.
                  Теперь принимаются двумерные разрежённые матрицы.
                </revdescription>
            </revision>
        </revhistory>
    </refsection>
</refentry>
