<?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) 2018 - 2020 - Samuel GOUGEON
 * Copyright (C) 2020 - Stanislav KROTER
 *
 * 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="gsort" xml:lang="ru">
    <refnamediv>
        <refname>gsort</refname>
        <refpurpose>сортирует массивы логических, числовых и строковых значений</refpurpose>
    </refnamediv>
    <refsynopsisdiv>
        <title>Синтаксис</title>
        <synopsis>
            B = gsort(A)
            B = gsort(A, method)
            B = gsort(A, method, direction)
            B = gsort(A, method, directions, rankFuncs)
            [B, k] = gsort(..)
        </synopsis>
    </refsynopsisdiv>
    <refsection>
        <title>Аргументы</title>
        <variablelist>
            <varlistentry>
                <term>A</term>
                <listitem>
                    Скаляр, вектор, матрица или гиперматрица логических значений, целых,
                    вещественных или комплексных чисел, или строковых значений. Разрежённые матрицы
                    вещественных чисел, комплексных чисел или логических значений также могут
                    быть отсортированы.
                    <note>
                        Разрешена перегрузка необрабатываемых типов.
                    </note>
                    <para/>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>method</term>
                <listitem>
                    Ключевое слово или индекс больше 0: метод сортировки:
                    <informaltable>
                        <tr valign="top">
                            <th>'g'</th><td>:</td>
                            <td>Общая сортировка: сортируются все элементы в <literal>A</literal>
                                (метод по умолчанию).
                            </td>
                        </tr>
                        <tr valign="top">
                            <td style="white-space:nowrap">
                                <emphasis role="bold">'r'</emphasis> или
                                <emphasis role="bold">1</emphasis></td>
                            <td>:</td>
                            <td>Сортируются строки в каждом столбце в <literal>A</literal>.</td>
                        </tr>
                        <tr valign="top">
                            <td style="white-space:nowrap">
                                <emphasis role="bold">'c'</emphasis> или
                                <emphasis role="bold">2</emphasis></td>
                            <td>:</td>
                            <td>Сортируются столбцы в каждой строке в <literal>A</literal>.</td>
                        </tr>
                        <tr valign="top"><td><emphasis role="bold">'lr'</emphasis></td><td>:</td>
                            <td>
                                лексикографическая сортировка строк в <literal>A</literal>:
                                Сортируются строки в соответствии со значениями в первом столбце.
                                Если группа сортированных строк имеет то же значение, что и в
                                столбце №1, то группа пересортировывается в соответствии со
                                значениями в столбце №2, и так далее. Не применимо к гиперматрицам.
                            </td>
                        </tr>
                        <tr valign="top"><td><emphasis role="bold">'lc'</emphasis></td><td>:</td>
                            <td>
                                лексикографическая сортировка столбцов в <literal>A</literal>
                                (не для гиперматриц).
                            </td>
                        </tr>
                    </informaltable>
                    <para/>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>direction</term>
                <listitem>
                    направление сортировки:
                    "d": в порядке уменьшения (по умолчанию);
                    "i": в порядке увеличения.
                    <para/>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>directions</term>
                <listitem>
                    вектор символов "i" и "d", у которого столько же элементов, сколько
                    элементов имеет <varname>rankFuncs</varname>.
                    <literal>directions(k)</literal> используется для
                    <varname>rankFuncs(k)</varname>.
                    <para/>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>rankFuncs</term>
                <listitem>
                    список <literal>list()</literal>, элементы которого имеют следующие типы:
                    <itemizedlist>
                        <listitem>
                            идентификатор <literal>fun</literal> функции на языке Scilab,
                            либо встроенной функции.
                        </listitem>
                        <listitem>
                            : двоеточие. Ставится для такой <literal>fun</literal>, для которой
                            <literal>fun(A)</literal> возвращает <literal>A</literal>.
                        </listitem>
                        <listitem>
                            список <literal>list(fun, param1, param2,..)</literal>, в котором
                            <itemizedlist>
                                <listitem>
                                    <literal>fun</literal> - это идентификатор функции Scilab или
                                    встроенной функции.
                                </listitem>
                                <listitem>
                                    <literal>param1, param2,..</literal> - это параметры.
                                </listitem>
                            </itemizedlist>
                            так что будет вызываться <literal>fun(A, param1, param2, ..)</literal>.
                        </listitem>
                    </itemizedlist>
                    <para>
                        Функции <literal>fun</literal> должны удовлетворять следующим условиям:
                        <itemizedlist>
                            <listitem>
                                должны поддерживаться <literal>R=fun(A)</literal> или
                                <literal>R=fun(A, param1, param2,..)</literal>.
                            </listitem>
                            <listitem>
                                <literal>fun</literal> должна работать поэлементно, то есть:
                                <literal>size(R)==size(A)</literal> и <literal>R(k)</literal>
                                по сути равно <literal>A(k)</literal>
                            </listitem>
                            <listitem>
                                <literal>R</literal> должен быть простым сортируемым типом:
                                логические значения, целые числа, вещественные значения, строковое значение.
                            </listitem>
                        </itemizedlist>
                    </para>
                    <para>
                        <note>
                            Если <literal>A</literal> содержит комплексные числа, то можно
                            определить обычные функции <literal>real, imag, abs, atan</literal>.
                            Тогда <literal>atan(imag(A),real(A))</literal> будет вызываться
                            вместо <literal>atan(A)</literal>.
                        </note>
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>B</term>
                <listitem>
                    Сортированный массив того же типа, кодирования и размера, что и <literal>A</literal>.
                    <para/>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>k</term>
                <listitem>
                    Массив десятичных целых чисел размера <literal>size(A)</literal>:
                    исходные индексы элементов <literal>B</literal> в <literal>A</literal>.
                    Если <literal>A</literal> матрица, то в соответствии с выбранным методом
                    <table>
                    <tr>
                        <th valign="top">"g"</th><td>:</td>
                        <td>
                            <literal>k</literal> это матрица размером <literal>size(A)</literal>:
                            <literal>k(i)</literal> - это линейный индекс элемента
                            <literal>B(i)</literal> в <literal>A</literal> такой, что <literal>B(:) = A(k)</literal>.
                        </td>
                    </tr>
                    <tr>
                        <th valign="top">"r"</th><td>:</td>
                        <td>
                            <literal>k</literal> это матрица размером <literal>size(A)</literal>:
                            <literal>k(i,j)</literal> равна <literal>1 ≤ index ≤ size(A,1)</literal>
                            элемента <literal>B(i,j)</literal> в столбце <literal>A(:,j)</literal>.
                        </td>
                    </tr>
                    <tr>
                        <th valign="top">"c"</th><td>:</td>
                        <td>
                            <literal>k</literal> это матрица размером <literal>size(A)</literal>:
                            <literal>k(i,j)</literal> равна <literal>1 ≤ index ≤ size(A,2)</literal>
                            элемента <literal>B(i,j)</literal> в строке <literal>A(i,:)</literal>.
                        </td>
                    </tr>
                    <tr>
                        <th valign="top">"lr"</th><td>:</td>
                        <td>
                            <literal>k</literal> - это столбец размером <literal>size(A,1)</literal>
                            такой, что <literal>B = A(k,:)</literal>.
                        </td>
                    </tr>
                    <tr>
                        <th valign="top">"lc"</th><td>:</td>
                        <td>
                            <literal>k</literal> - это строка размером <literal>size(A,2)</literal>
                            такая, что <literal>B = A(:,k)</literal>.
                        </td>
                    </tr>
                    </table>
                    <para/>
                </listitem>
            </varlistentry>
        </variablelist>
    </refsection>
    <refsection>
        <title>Описание</title>
        <para>
            Функция <literal>gsort</literal> выполняет "быструю сортировку" различных типов
            данных. По умолчанию сортировка выполняется в порядке убывания.
        </para>
        <para>
            Значения <literal>%nan</literal> считаются больше, чем <literal>%inf</literal>.
        </para>
        <para>
            Комплексные числа по умолчанию сортируются только в соответствии с их модулями.
            Полная сортировка может быть достигнута, используя многоуровневый режим, через
            аргументы <varname>rankFuncs</varname> и <varname>directions</varname>.
            Например:
        </para>
        <para>
            <literal>M = gsort(C, "g", ["i" "d"], list(real, imag))</literal><para/>
            отсортирует массив <literal>C</literal>, сначала в порядке возрастания вещественных
            частей, и элементов у которых вещественные части равны, а затем в порядке убывания
            мнимых частей. Многоуровневый режим детально описан в соответствующем подразделе ниже.
        </para>
        <para>
            Тексты сортируются в алфавитном порядке, с учётом регистра.
            Поддерживаются расширенные UTF-символы. The empty text "" is considered "smaller"
            than any other text.
        </para>
        <para>
            Сортировка массивов логических значений главным образом полезна с помощью методов
            "r", "c", "lr" или "lc".
        </para>
        <para>
            <note>
                Какой бы метод ни выбрали, <emphasis role="bold">алгоритм сохраняет относительный
                порядок элементов с равными значениями</emphasis>.
            </note>
        </para>
        <refsect3>
            <title>Методы сортировки</title>
            <para>
                <emphasis role="bold">B = gsort(A,'g', ..)</emphasis> сортирует все элементы в
                <varname>A</varname> и сохраняет сортированные элементы в первом столбце сверху
                вниз, а затем во втором столбце и т.д.
            </para>
            <para>
                <emphasis role="bold">B = gsort(A,'c', ..)</emphasis> сортирует каждую строку в
                <varname>A</varname>. Каждый сортированный элемент находится в той же строке, что
                и в <varname>A</varname>, но возможно в другом столбце в соответствии с его
                рангом сортировки в строке.
            </para>
            <para>
                <emphasis role="bold">B = gsort(A,'r', ..)</emphasis> сортирует каждый столбец в
                <varname>A</varname>. Каждый сортированный элемент находится в том же столбце,
                что и в <varname>A</varname>, но возможно в другой строке в соответствии с его
                рангом сортировки в строке.
            </para>
            <para>
                <emphasis role="bold">B = gsort(A,'lr', ..)</emphasis> сортирует строки в
                <varname>A</varname> целиком в лексическом порядке. Две строки сравниваются и
                сортируются следующим образом. Сравниваются элементы их первых столбцов. Если их
                ранги не равны, то обе строки сортируются соответствующим образом. В противном
                случае сравниваются элементы их вторых столбцов, и т.д. вплоть до последнего
                столбца, если это потребуется.
            </para>
            <para>
                <emphasis role="bold">B = gsort(A,'lc', ..)</emphasis> сортируются столбцы в
                <varname>A</varname> целиком, в лексикографическом порядке (см. выше).
            </para>
        </refsect3>
        <refsect3>
            <title>Многоуровневая сортировка</title>
            <para>
                Как отмечено выше, когда два сравниваемых элемента имеют одинаковые ранги, их
                исходный относительный порядок в <varname>A</varname> сохраняется в
                результирующей <varname>B</varname>.
            </para>
            <para>
                Однако, во многих случаях, выходящих за рамки, может быть полезна и затребована
                многоуровневая сортировка:
                после выполнения первой сортировки в соответствии с первым критерием и
                направлением сортировки, можно указать второй критерий и направление сортировки и
                применить их к одинаковым элементам 1-го ранга, собранным после первой
                сортировки.
            </para>
            <para>
                Если после двух первых сортировок некоторые элементы по-прежнему имеют одинаковый
                ранг, то можно определить и использовать третий уровень сортировки и т.д.
            </para>
            <para>
                <emphasis role="bold">Применимые примеры</emphasis> (смотрите также раздел
                Примеры):
                <orderedlist>
                    <listitem>
                        <emphasis>Сортировка матрицы <literal>C</literal> комплексных чисел,
                            сначала в порядке увеличения модуля, затем в порядке увеличения
                            фазы</emphasis>:
                        <para/>
                        <literal>gsort(C, "g", ["i" "i"], list(abs, atan))</literal>
                        <para/>
                    </listitem>
                    <listitem>
                        <emphasis>Сортировка столбцов матрицы <literal>T</literal> строковых значений,
                        сначала в порядке увеличения длины, затем в обратном алфавитном
                        порядке</emphasis>:
                        <para/>
                        <literal>gsort(T, "c", ["i" "d"], list(length, :))</literal>
                        <para/>
                    </listitem>
                    <listitem>
                        <emphasis>Сортировка матрицы <literal>P</literal> полиномов,
                        сначала в порядке увеличения степени, затем в порядке уменьшения значения
                        постоянного коэффициента 0-й степени</emphasis>:
                        <screen>
function c = get_coef(p, i)
    // i: степень возвращаемого коэффициента
    c = matrix(coeff(p(:))(:,i+1), size(p))
endfunction

gsort(P, "c", ["i" "d"], list(degree, list(get_coef,0)))
</screen>
                        В этом примере функция второго ранжирования позволяет определить степень
                        <literal>i</literal> того коэффициента, который рассматривается в
                        качестве значения вторичной сортировки.
                    <para/>
                    </listitem>
                    <listitem>
                        <emphasis>Сортировка матрицы <literal>D</literal> десятичных чисел,
                        сначала в порядке возрастания целых частей, затем в порядке уменьшения дробных частей</emphasis>:
                        <screen>
function r = get_frac(numbers)
    r = numbers - int(numbers)
endfunction

gsort(D, "g", ["i" "d"], list(int, get_frac))
</screen>
                    </listitem>
                    <para/>
                </orderedlist>
            </para>
        </refsect3>
    </refsection>
    <refsection>
        <title>Примеры</title>
        <para>
            Сортировка элементов в строках:
        </para>
        <para>
        <programlisting role="example"><![CDATA[
m = [ 0.  2.  1.  2.  1.  0.
      1.  1.  3.  1.  0.  3.
      2.  3   3.  2.  1.  1. ];

[s, k] = gsort(m, "c")
]]>     </programlisting>
        <screen><![CDATA[
--> [s, k] = gsort(m, "c")
 s  =
   2.   2.   1.   1.   0.   0.
   3.   3.   1.   1.   1.   0.
   3.   3.   2.   2.   1.   1.

 k  =
   2.   4.   3.   5.   1.   6.
   3.   6.   1.   2.   4.   5.
   2.   3.   1.   4.   5.   6.
]]></screen>
        </para>
        <para>
            Лексикографическая сортировка строк:
        </para>
        <para>
        <programlisting role="example"><![CDATA[
v = ['Scilab' '3.1'
     'xcos'   '4.0'
     'xcos'   '3.1'
     'Scilab' '2.7'
     'xcos'   '2.7'
     'Scilab' '4.0'];

[s, k] = gsort(v,'lr','i'); s, k'
]]>     </programlisting>
            <screen><![CDATA[
--> [s, k] = gsort(v,'lr','i'); s, k'
 s  =
  "Scilab"  "2.7"
  "Scilab"  "3.1"
  "Scilab"  "4.0"
  "xcos"    "2.7"
  "xcos"    "3.1"
  "xcos"    "4.0"

 ans  =
   4.   1.   6.   5.   3.   2.
]]></screen>
        </para>
        <para>
            Лексикографическая сортировка логических столбцов:
        </para>
        <para>
        <programlisting role="example"><![CDATA[
m  = [ 0 1 0 1 1 1 0 1
       0 0 1 1 1 1 0 0
       0 0 1 1 0 0 0 0 ]==1;
m
[s, k] = gsort(m, "lc")  // сортировка столбцов в порядке убывания
]]>     </programlisting>
        <screen><![CDATA[
--> m
 m  =
  F T F T T T F T
  F F T T T T F F
  F F T T F F F F

--> [s, k] = gsort(m, "lc")
 s  =
  T T T T T F F F
  T T T F F T F F
  T F F F F T F F

 k  =
   4.   5.   6.   2.   8.   3.   1.   7.
]]></screen>
        </para>
        <refsect3>
        <title>Многоуровневая сортировка</title>
        <para>
            <emphasis role="bold">С некоторыми десятичными числами</emphasis>:
            Сначала сортировка в порядке возрастания целых частей, а затем в порядке убывания
            дробных частей.
        </para>
        <para>
        <programlisting role="example"><![CDATA[
// Функция получения дробных частей
function r = get_frac(d)
    r = d - int(d)
endfunction

// Несортированные данные
d = [
   2.1   0.1   1.3   1.2   0.1   1.2
   0.3   1.2   2.3   0.3   1.2   2.1
   0.1   1.2   1.1   1.2   2.2   1.1
   2.3   1.3   0.1   2.3   0.1   0.1
   0.1   2.2   2.1   0.2   1.1   0.3
  ];
// Сортировка
[r, k] = gsort(d, "g", ["i" "d"], list(int, get_frac))
]]>     </programlisting>
        <screen><![CDATA[
 r  =
   0.3   0.1   0.1   1.2   1.1   2.2
   0.3   0.1   1.3   1.2   1.1   2.2
   0.3   0.1   1.3   1.2   2.3   2.1
   0.2   0.1   1.2   1.2   2.3   2.1
   0.1   0.1   1.2   1.1   2.3   2.1

 k  =
   2.    5.    29.   16.   25.   10.
   17.   6.    9.    18.   28.   23.
   30.   14.   11.   22.   4.    1.
   20.   21.   7.    26.   12.   15.
   3.    24.   8.    13.   19.   27.
]]></screen>
        </para>
        <para>
            <emphasis role="bold">С комплексными числами</emphasis>:
            Сортировка сначала в порядке увеличения вещественных частей, затем в порядке
            увеличения мнимых частей.
        </para>
        <para>
        <programlisting role="example"><![CDATA[
//c = [-1 1 ; -1 0; 0 2; 0 %nan; 0 -1; 0 %inf ; 0 1; 1 %nan ; 1 1; 1 -1 ; -1 %nan ; 1 -%inf]
//c = matrix(squeeze(grand(1,"prm",complex(c(:,1), c(:,2)))), [3,4])
s = "complex([0,0,-1,-1;0,-1,1,1;1,1,0,0]," + ..
            "[%inf,2,%nan,1;-1,0,-1,%nan;1,-%inf,1,%nan])";
c = evstr(s)
[r, k] = gsort(c, "g", ["i" "i"], list(real, imag))
]]>     </programlisting>
    <screen><![CDATA[
--> c = evstr(s)
 c  =
   0. + Infi   0. + 2.i   -1. + Nani  -1. + i
   0. - i     -1. + 0.i    1. - i      1. + Nani
   1. + i      1. - Infi   0. + i      0. + Nani

 r  =
  -1. + 0.i    0. - i     0. + Infi   1. - i
  -1. + i      0. + i     0. + Nani   1. + i
  -1. + Nani   0. + 2.i   1. - Infi   1. + Nani

 k  =
   5.    2.   1.    8.
   10.   9.   12.   3.
   7.    4.   6.    11.
]]></screen>
        </para>
        <para>
            <emphasis role="bold">С некоторыми строковыми значениями:</emphasis>
            Сортировка строк в столбцах, сначала в порядке увеличения длины, затем в алфавитном
            порядке.
        </para>
        <para>
        <programlisting role="example"><![CDATA[
t = [
  "cc"    "ca"    "ab"    "bbca"  "b"     "ccbc"  "aab"   "bca"
  "ac"    "bba"   "aba"   "bb"    "a"     "cac"   "b"     "b"
  "aaaa"  "ac"    "b"     "bbca"  "bb"    "bc"    "aa"    "ca"
  "c"     "ba"    "cbb"   "a"     "aab"   "abbb"  "ac"    "c"
  "cbb"   "b"     "cabb"  "bccc"  "aba"   "acb"   "acb"   "b"
  "cba"   "cc"    "a"     "abbb"  "ab"    "cc"    "bba"   "caaa"
  ];

[r, k] = gsort(t, "r", ["i" "i"], list(length, :))
]]>     </programlisting>
        <screen><![CDATA[
--> [r, k] = gsort(t, "r", ["i" "i"], list(length, :))
 r  =
  "c"     "b"    "a"     "a"     "a"    "bc"    "b"    "b"
  "ac"    "ac"   "b"     "bb"    "b"    "cc"    "aa"   "b"
  "cc"    "ba"   "ab"    "abbb"  "ab"   "acb"   "ac"   "c"
  "cba"   "ca"   "aba"   "bbca"  "bb"   "cac"   "aab"  "ca"
  "cbb"   "cc"   "cbb"   "bbca"  "aab"  "abbb"  "acb"  "bca"
  "aaaa"  "bba"  "cabb"  "bccc"  "aba"  "ccbc"  "bba"  "caaa"

 k  =
   4.   5.   6.   4.   2.   3.   2.   2.
   2.   3.   3.   2.   1.   6.   3.   5.
   1.   4.   1.   6.   6.   5.   4.   4.
   6.   1.   2.   1.   3.   2.   1.   3.
   5.   6.   4.   3.   4.   4.   5.   1.
   3.   2.   5.   5.   5.   1.   6.   6.
]]></screen>
        </para>
<!--  Display up to 6.0.2 (without extra blank lines)
 r  =
!c     b    a     a     a    bc    b    b     !
!ac    ac   b     bb    b    cc    aa   b     !
!cc    ba   ab    abbb  ab   acb   ac   c     !
!cba   ca   aba   bbca  bb   cac   aab  ca    !
!cbb   cc   cbb   bbca  aab  abbb  acb  bca   !
!aaaa  bba  cabb  bccc  aba  ccbc  bba  caaa  !
-->
        <para>
            <emphasis role="bold">С некоторыми полиномами:</emphasis>
            Сортировка сначала в порядке уменьшения значений x^0, затем в порядке увеличения
            степеней.
        </para>
        <para>
        <programlisting role="example"><![CDATA[
function c = get_coef(p, d)
    // d : степени возвращаемых коэффициентов
    c = matrix(coeff(p(:))(:,d+1), size(p))
endfunction

P = ["[-x,1-2*x,2+2*x,1-x,2,-1-x;"
     "1-x,-1+x,-1,x,1+2*x,2*x;"
     "-2+x,1,-2,2+x,-x,-1-x]"];

x = varn(%s,"x");
P = evstr(P)

[r, k] = gsort(P, "g", ["d" "i"], list(list(get_coef, 0), degree))
]]>     </programlisting>
        <screen><![CDATA[
--> P = evstr(P)
 P  =
  -x      1 -2x   2 +2x   1 -x   2      -1 -x
   1 -x  -1 +x   -1       x      1 +2x   2x
  -2 +x   1      -2       2 +x   -x     -1 -x

--> [r, k] = gsort(P, "g", ["d" "i"], list(list(get_coef, 0), degree))
 r  =
  2      1      1 -x   x   -1     -1 -x
  2 +2x  1 -x   1 +2x  -x  -1 +x  -2
  2 +x   1 -2x  -x     2x  -1 -x  -2 +x

 k  =
   13.   6.   10.   11.   8.    18.
   7.    2.   14.   15.   5.    9.
   12.   4.   1.    17.   16.   3.
]]></screen>
        </para>
    </refsect3>
    <refsect3>
        <title>С гиперматрицей</title>
        <para>
            <emphasis role="bold">Сортировка столбцов в каждой строке:</emphasis>
        </para>
        <para>
        <programlisting role="example"><![CDATA[
h = matrix([9,7,9,0,2,9,4,2,0,9,5,8,5,2,0,0], [2,4,2])
[s, k] = gsort(h, "c", "i")
]]>     </programlisting>
        <screen><![CDATA[
--> h = matrix([9,7,9,0,2,9,4,2,0,9,5,8,5,2,0,0], [2,4,2])
 h  =
(:,:,1)
   9.   9.   2.   4.
   7.   0.   9.   2.
(:,:,2)
   0.   5.   5.   0.
   9.   8.   2.   0.

--> [s, k] = gsort(h, "c", "i")
 s  =
(:,:,1)
   2.   4.   9.   9.
   0.   2.   7.   9.
(:,:,2)
   0.   0.   5.   5.
   0.   2.   8.   9.

 k  =
(:,:,1)
   3.   4.   1.   2.
   2.   4.   1.   3.
(:,:,2)
   1.   4.   2.   3.
   4.   3.   2.   1.
]]></screen>
        </para>
        <para>
            <emphasis role="bold">Сортировка значений по страницам:</emphasis>
        </para>
        <para>
        <programlisting role="example"><![CDATA[
h = matrix([9,7,9,0,2,9,4,2,0,9,5,8,5,2,0,0], [2,4,2])
[s, k] = gsort(h, 3, "i")   // по третьей размерности = 'толщина' гиперматрицы
]]>     </programlisting>
        <screen><![CDATA[
--> h = matrix([9,7,9,0,2,9,4,2,0,9,5,8,5,2,0,0], [2,4,2])
 h  =
(:,:,1)
   9.   9.   2.   4.
   7.   0.   9.   2.
(:,:,2)
   0.   5.   5.   0.
   9.   8.   2.   0.

--> [s, k] = gsort(h, 3, "i")
 s  =
(:,:,1)
   0.   5.   2.   0.
   7.   0.   2.   0.
(:,:,2)
   9.   9.   5.   4.
   9.   8.   9.   2.

 k  =
(:,:,1)
   2.   2.   1.   2.
   1.   1.   2.   2.
(:,:,2)
   1.   1.   2.   1.
   2.   2.   1.   1.
]]></screen>
        </para>
    </refsect3>
    </refsection>
    <refsection role="see also">
        <title>Смотрите также</title>
        <simplelist type="inline">
            <member>
                <link linkend="comparison">сравнение</link>
            </member>
            <member>
                <link linkend="strcmp">strcmp</link>
            </member>
            <member>
                <link linkend="find">find</link>
            </member>
            <member>
                <link linkend="overloading">перегрузка</link>
            </member>
        </simplelist>
    </refsection>
    <refsection>
        <title>Литература</title>
        <para>Quick sort algorithm from Bentley &amp; McIlroy's "Engineering a
            Sort Function". Software---Practice and Experience,
            23(11):1249-1265
        </para>
    </refsection>
    <refsection>
        <title>История</title>
        <revhistory>
            <revision>
                <revnumber>5.4.0</revnumber>
                <revremark>
                    Теперь gsort() может быть перегружена для неуправляемых типов.
                </revremark>
            </revision>
            <revision>
                <revnumber>6.1.0</revnumber>
                <revremark>
                    <itemizedlist>
                        <listitem>
                            Теперь можно сортировать логические значения.
                        </listitem>
                        <listitem>
                            Многоуровневая сортировка, добавленная с помощью опции rankFuncs.
                        </listitem>
                    </itemizedlist>
                </revremark>
            </revision>
            <revision>
                <revnumber>6.1.1</revnumber>
                <revremark>
                    <itemizedlist>
                        <listitem>
                            Для разрежённого входа, gsort() ранее была ограничена вещественными или
                            комплексными векторами и только методом 'g'. Теперь она полностью способна
                            к работе с разрежёнными векторами и двумерными матрицами логических,
                            вещественных или комплексных чисел, всеми методами 'g, r, c, lr, lc'.
                            Многоуровневая сортировка возможна для всех типов разрежённых входных данных.
                        </listitem>
                        <listitem>
                            Теперь возможна сортировка вдоль размерности более 2.
                        </listitem>
                    </itemizedlist>
                </revremark>
            </revision>
        </revhistory>
    </refsection>
</refentry>
