* Bugs 15838 15839 15842 16452 16454 fixed: gsort() for all sparse in all modes
[scilab.git] / scilab / modules / elementary_functions / help / ru_RU / searchandsort / gsort.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) 2008 - INRIA
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  * Copyright (C) 2018 - 2020 - Samuel GOUGEON
7  * Copyright (C) 2020 - Stanislav KROTER
8  *
9  * This file is hereby licensed under the terms of the GNU GPL v2.0,
10  * pursuant to article 5.3.4 of the CeCILL v.2.1.
11  * This file was originally licensed under the terms of the CeCILL v2.1,
12  * and continues to be available under such terms.
13  * For more information, see the COPYING file which you should have received
14  * along with this program.
15  *
16  -->
17 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
18           xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml"
19           xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook"
20           xmlns:scilab="http://www.scilab.org" xml:id="gsort" xml:lang="ru">
21     <refnamediv>
22         <refname>gsort</refname>
23         <refpurpose>сортировка по алгоритму быстрой сортировки</refpurpose>
24     </refnamediv>
25     <refsynopsisdiv>
26         <title>Синтаксис</title>
27         <synopsis>
28             B = gsort(A)
29             B = gsort(A, method)
30             B = gsort(A, method, direction)
31             B = gsort(A, method, directions, rankFuncs)
32             [B, k] = gsort(..)
33         </synopsis>
34     </refsynopsisdiv>
35     <refsection>
36         <title>Аргументы</title>
37         <variablelist>
38             <varlistentry>
39                 <term>A</term>
40                 <listitem>
41                     Скаляр, вектор, матрица или гиперматрица логических значений, целых,
42                     вещественных или комплексных чисел, или текстов. Sparse matrices of
43                     real numbers, of complex numbers, or of booleans can also be sorted.
44                     <note>
45                         Разрешена перегрузка необрабатываемых типов.
46                     </note>
47                     <para/>
48                 </listitem>
49             </varlistentry>
50             <varlistentry>
51                 <term>method</term>
52                 <listitem>
53                     Ключевое слово: метод сортировки:
54                     <informaltable>
55                         <tr valign="top">
56                             <th>'g'</th><td>:</td>
57                             <td>Общая сортировка: сортируются все элементы в <literal>A</literal>
58                                 ( метод по умолчанию).
59                             </td>
60                         </tr>
61                         <tr valign="top">
62                             <th>'r'</th><td>:</td>
63                             <td>Сортируются строки в каждом столбце в <literal>A</literal>.</td>
64                         </tr>
65                         <tr valign="top">
66                             <th>'c'</th><td>:</td>
67                             <td>Сортируются столбцы в каждой строке в <literal>A</literal>.</td>
68                         </tr>
69                         <tr valign="top"><th>'lr'</th><td>:</td>
70                             <td>
71                                 лексикографическая сортировка строк в <literal>A</literal>:
72                                 Сортируются строки в соответствии со значениями в первом столбце.
73                                 Если группа сортированных строк имеет то же значение, что и в
74                                 столбце №1, то группа пересортировывается в соответствии со
75                                 значениями в столбце №2, и так далее. Не применимо к гиперматрицам.
76                             </td>
77                         </tr>
78                         <tr valign="top"><th>'lc'</th><td>:</td>
79                             <td>
80                                 лексикографическая сортировка столбцов в <literal>A</literal>
81                                 (не для гиперматриц).
82                             </td>
83                         </tr>
84                     </informaltable>
85                     <para/>
86                 </listitem>
87             </varlistentry>
88             <varlistentry>
89                 <term>direction</term>
90                 <listitem>
91                     направление сортировки:
92                     "d": в порядке уменьшения (по умолчанию);
93                     "i": в порядке увеличения.
94                     <para/>
95                 </listitem>
96             </varlistentry>
97             <varlistentry>
98                 <term>directions</term>
99                 <listitem>
100                     вектор символов "i" и "d", у которого столько же элементов, сколько
101                     элементов имеет <varname>rankFuncs</varname>.
102                     <literal>directions(k)</literal> используется для
103                     <varname>rankFuncs(k)</varname>.
104                     <para/>
105                 </listitem>
106             </varlistentry>
107             <varlistentry>
108                 <term>rankFuncs</term>
109                 <listitem>
110                     список <literal>list()</literal>, элементы которого имеют следующие типы:
111                     <itemizedlist>
112                         <listitem>
113                             идентификатор <literal>fun</literal> функции на языке Scilab,
114                             либо встроенной функции.
115                         </listitem>
116                         <listitem>
117                             : двоеточие. Ставится для такой <literal>fun</literal>, для которой
118                             <literal>fun(A)</literal> возвращает <literal>A</literal>.
119                         </listitem>
120                         <listitem>
121                             список <literal>list(fun, param1, param2,..)</literal>, в котором
122                             <itemizedlist>
123                                 <listitem>
124                                     <literal>fun</literal> - это идентификатор функции Scilab или
125                                     встроенной функции.
126                                 </listitem>
127                                 <listitem>
128                                     <literal>param1, param2,..</literal> - это параметры.
129                                 </listitem>
130                             </itemizedlist>
131                             так что будет вызываться <literal>fun(A, param1, param2, ..)</literal>.
132                         </listitem>
133                     </itemizedlist>
134                     <para>
135                         Функции <literal>fun</literal> должны удовлетворять следующим условиям:
136                         <itemizedlist>
137                             <listitem>
138                                 должны поддерживаться <literal>R=fun(A)</literal> или
139                                 <literal>R=fun(A, param1, param2,..)</literal>.
140                             </listitem>
141                             <listitem>
142                                 <literal>fun</literal> должна работать поэлементно, то есть:
143                                 <literal>size(R)==size(A)</literal> и <literal>R(k)</literal>
144                                 по сути равно <literal>A(k)</literal>
145                             </listitem>
146                             <listitem>
147                                 <literal>R</literal> должен быть простым сортируемым типом:
148                                 логические значения, целые числа, вещественные значения, текст.
149                             </listitem>
150                         </itemizedlist>
151                     </para>
152                     <para>
153                         <note>
154                             Если <literal>A</literal> содержит комплексные числа, то можно
155                             определить обычные функции <literal>real, imag, abs, atan</literal>.
156                             Тогда <literal>atan(imag(A),real(A))</literal> будет вызываться
157                             вместо <literal>atan(A)</literal>.
158                         </note>
159                     </para>
160                 </listitem>
161             </varlistentry>
162             <varlistentry>
163                 <term>B</term>
164                 <listitem>
165                     Сортированный массив того же типа, кодирования и размера, что и <literal>A</literal>.
166                     <para/>
167                 </listitem>
168             </varlistentry>
169             <varlistentry>
170                 <term>k</term>
171                 <listitem>
172                     Массив десятичных целых чисел размера <literal>size(A)</literal>:
173                     исходные индексы элементов <literal>B</literal> в <literal>A</literal>.
174                     Если <literal>A</literal> матрица, то в соответствии с выбранным методом
175                     <table>
176                     <tr>
177                         <th valign="top">"g"</th><td>:</td>
178                         <td>
179                             <literal>k</literal> это матрица размером <literal>size(A)</literal>:
180                             <literal>k(i)</literal> - это линейный индекс элемента
181                             <literal>B(i)</literal> в <literal>A</literal> такой, что <literal>B(:) = A(k)</literal>.
182                         </td>
183                     </tr>
184                     <tr>
185                         <th valign="top">"r"</th><td>:</td>
186                         <td>
187                             <literal>k</literal> это матрица размером <literal>size(A)</literal>:
188                             <literal>k(i,j)</literal> равна <literal>1 ≤ index ≤ size(A,1)</literal>
189                             элемента <literal>B(i,j)</literal> в столбце <literal>A(:,j)</literal>.
190                         </td>
191                     </tr>
192                     <tr>
193                         <th valign="top">"c"</th><td>:</td>
194                         <td>
195                             <literal>k</literal> это матрица размером <literal>size(A)</literal>:
196                             <literal>k(i,j)</literal> равна <literal>1 ≤ index ≤ size(A,2)</literal>
197                             элемента <literal>B(i,j)</literal> в строке <literal>A(i,:)</literal>.
198                         </td>
199                     </tr>
200                     <tr>
201                         <th valign="top">"lr"</th><td>:</td>
202                         <td>
203                             <literal>k</literal> - это столбец размером <literal>size(A,1)</literal>
204                             такой, что <literal>B = A(k,:)</literal>.
205                         </td>
206                     </tr>
207                     <tr>
208                         <th valign="top">"lc"</th><td>:</td>
209                         <td>
210                             <literal>k</literal> - это строка размером <literal>size(A,2)</literal>
211                             такая, что <literal>B = A(:,k)</literal>.
212                         </td>
213                     </tr>
214                     </table>
215                     <para/>
216                 </listitem>
217             </varlistentry>
218         </variablelist>
219     </refsection>
220     <refsection>
221         <title>Описание</title>
222         <para>
223             Функция <literal>gsort</literal> выполняет "быструю сортировку" различных типов
224             данных. По умолчанию сортировка выполняется в порядке убывания.
225         </para>
226         <para>
227             Значения <literal>%nan</literal> считаются больше, чем <literal>%inf</literal>.
228         </para>
229         <para>
230             Комплексные числа по умолчанию сортируются только в соответствии с их модулями.
231             Полная сортировка может быть достигнута, используя многоуровневый режим, через
232             аргументы <varname>rankFuncs</varname> и <varname>directions</varname>.
233             Например:
234         </para>
235         <para>
236             <literal>M = gsort(C, "g", ["i" "d"], list(real, imag))</literal><para/>
237             отсортирует массив <literal>C</literal>, сначала в порядке возрастания вещественных
238             частей, и элементов у которых вещественные части равны, а затем в порядке убывания
239             мнимых частей. Многоуровневый режим детально описан в соответствующем подразделе ниже.
240         </para>
241         <para>
242             Тексты сортируются в алфавитном порядке, с учётом регистра.
243             Поддерживаются расширенные UTF-символы.
244         </para>
245         <para>
246             Сортировка массивов логических значений главным образом полезна с помощью методов
247             "r", "c", "lr" или "lc".
248         </para>
249         <para>
250             <note>
251                 Какой бы метод ни выбрали, <emphasis role="bold">алгоритм сохраняет относительный порядок элементов с равными значениями</emphasis>.
252             </note>
253         </para>
254         <refsect3>
255             <title>Методы сортировки</title>
256             <para>
257                 <emphasis role="bold">B = gsort(A,'g', ..)</emphasis> сортирует все элементы в
258                 <varname>A</varname> и сохраняет сортированные элементы в первом столбце сверху
259                 вниз, а затем во втором столбце и т.д.
260             </para>
261             <para>
262                 <emphasis role="bold">B = gsort(A,'c', ..)</emphasis> сортирует каждую строку в
263                 <varname>A</varname>. Каждый сортированный элемент находится в той же строке, что
264                 и в <varname>A</varname>, но возможно в другом столбце в соответствии с его
265                 рангом сортировки в строке.
266             </para>
267             <para>
268                 <emphasis role="bold">B = gsort(A,'r', ..)</emphasis> сортирует каждый столбец в
269                 <varname>A</varname>. Каждый сортированный элемент находится в том же столбце,
270                 что и в <varname>A</varname>, но возможно в другой строке в соответствии с его
271                 рангом сортировки в строке.
272             </para>
273             <para>
274                 <emphasis role="bold">B = gsort(A,'lr', ..)</emphasis> сортирует строки в
275                 <varname>A</varname> целиком в лексическом порядке. Две строки сравниваются и
276                 сортируются следующим образом. Сравниваются элементы их первых столбцов. Если их
277                 ранги не равны, то обе строки сортируются соответствующим образом. В противном
278                 случае сравниваются элементы их вторых столбцов, и т.д. вплоть до последнего
279                 столбца, если это потребуется.
280             </para>
281             <para>
282                 <emphasis role="bold">B = gsort(A,'lc', ..)</emphasis> сортируются столбцы в
283                 <varname>A</varname> целиком, в лексикографическом порядке (см. выше).
284             </para>
285         </refsect3>
286         <refsect3>
287             <title>Многоуровневая сортировка</title>
288             <para>
289                 Как отмечено выше, когда два сравниваемых элемента имеют одинаковые ранги, их
290                 исходный относительный порядок в <varname>A</varname> сохраняется в
291                 результирующей <varname>B</varname>.
292             </para>
293             <para>
294                 Однако, во многих случаях, выходящих за рамки, может быть полезна и затребована
295                 многоуровневая сортировка:
296                 после выполнения первой сортировки в соответствии с первым критерием и
297                 направлением сортировки, можно указать второй критерий и направление сортировки и
298                 применить их к одинаковым элементам 1-го ранга, собранным после первой
299                 сортировки.
300             </para>
301             <para>
302                 Если после двух первых сортировок некоторые элементы по-прежнему имеют одинаковый
303                 ранг, то можно определить и использовать третий уровень сортировки и т.д.
304             </para>
305             <para>
306                 <emphasis role="bold">Применимые примеры</emphasis> (смотрите также раздел
307                 Примеры):
308                 <orderedlist>
309                     <listitem>
310                         <emphasis>Сортировка матрицы <literal>C</literal> комплексных чисел,
311                             сначала в порядке увеличения модуля, затем в порядке увеличения
312                             фазы</emphasis>:
313                         <para/>
314                         <literal>gsort(C, "g", ["i" "i"], list(abs, atan))</literal>
315                         <para/>
316                     </listitem>
317                     <listitem>
318                         <emphasis>Сортировка столбцов матрицы <literal>T</literal> текстов,
319                         сначала в порядке увеличения длины, затем в обратном алфавитном
320                         порядке</emphasis>:
321                         <para/>
322                         <literal>gsort(T, "c", ["i" "d"], list(length, :))</literal>
323                         <para/>
324                     </listitem>
325                     <listitem>
326                         <emphasis>Сортировка матрицы <literal>P</literal> полиномов,
327                         сначала в порядке увеличения степени, затем в порядке уменьшения значения постоянного коэффициента 0-й степени</emphasis>:
328                         <screen>
329 function c = get_coef(p, i)
330     // i: степень возвращаемого коэффициента
331     c = matrix(coeff(p(:))(:,i+1), size(p))
332 endfunction
333
334 gsort(P, "c", ["i" "d"], list(degree, list(get_coef,0)))
335 </screen>
336                         В этом примере функция второго ранжирования позволяет определить степень
337                         <literal>i</literal> того коэффициента, который рассматривается в
338                         качестве значения вторичной сортировки.
339                     <para/>
340                     </listitem>
341                     <listitem>
342                         <emphasis>Сортировка матрицы <literal>D</literal> десятичных чисел,
343                         сначала в порядке возрастания целых частей, затем в порядке уменьшения дробных частей</emphasis>:
344                         <screen>
345 function r = get_frac(numbers)
346     r = numbers - int(numbers)
347 endfunction
348
349 gsort(D, "g", ["i" "d"], list(int, get_frac))
350 </screen>
351                     </listitem>
352                     <para/>
353                 </orderedlist>
354             </para>
355         </refsect3>
356     </refsection>
357     <refsection>
358         <title>Примеры</title>
359         <para>
360             Сортировка элементов в строках:
361         </para>
362         <para>
363         <programlisting role="example"><![CDATA[
364 m = [ 0.  2.  1.  2.  1.  0.
365       1.  1.  3.  1.  0.  3.
366       2.  3   3.  2.  1.  1. ];
367
368 [s, k] = gsort(m, "c")
369 ]]>     </programlisting>
370         <screen><![CDATA[
371 --> [s, k] = gsort(m, "c")
372  s  =
373    2.   2.   1.   1.   0.   0.
374    3.   3.   1.   1.   1.   0.
375    3.   3.   2.   2.   1.   1.
376
377  k  =
378    2.   4.   3.   5.   1.   6.
379    3.   6.   1.   2.   4.   5.
380    2.   3.   1.   4.   5.   6.
381 ]]></screen>
382         </para>
383         <para>
384             Лексикографическая сортировка строк:
385         </para>
386         <para>
387         <programlisting role="example"><![CDATA[
388 v = ['Scilab' '3.1'
389      'xcos'   '4.0'
390      'xcos'   '3.1'
391      'Scilab' '2.7'
392      'xcos'   '2.7'
393      'Scilab' '4.0'];
394
395 [s, k] = gsort(v,'lr','i'); s, k'
396 ]]>     </programlisting>
397             <screen><![CDATA[
398 --> [s, k] = gsort(v,'lr','i'); s, k'
399  s  =
400   "Scilab"  "2.7"
401   "Scilab"  "3.1"
402   "Scilab"  "4.0"
403   "xcos"    "2.7"
404   "xcos"    "3.1"
405   "xcos"    "4.0"
406
407  ans  =
408    4.   1.   6.   5.   3.   2.
409 ]]></screen>
410         </para>
411         <para>
412             Лексикографическая сортировка логических столбцов:
413         </para>
414         <para>
415         <programlisting role="example"><![CDATA[
416 m  = [ 0 1 0 1 1 1 0 1
417        0 0 1 1 1 1 0 0
418        0 0 1 1 0 0 0 0 ]==1;
419 m
420 [s, k] = gsort(m, "lc")  // сортировка столбцов в порядке убывания
421 ]]>     </programlisting>
422         <screen><![CDATA[
423 --> m
424  m  =
425   F T F T T T F T
426   F F T T T T F F
427   F F T T F F F F
428
429 --> [s, k] = gsort(m, "lc")
430  s  =
431   T T T T T F F F
432   T T T F F T F F
433   T F F F F T F F
434
435  k  =
436    4.   5.   6.   2.   8.   3.   1.   7.
437 ]]></screen>
438         </para>
439         <refsect3>
440         <title>Многоуровневая сортировка</title>
441         <para>
442             <emphasis role="bold">С некоторыми десятичными числами</emphasis>:
443             Сначала сортировка в порядке возрастания целых частей, а затем в порядке убывания
444             дробных частей.
445         </para>
446         <para>
447         <programlisting role="example"><![CDATA[
448 // Функция получения дробных частей
449 function r = get_frac(d)
450     r = d - int(d)
451 endfunction
452
453 // Несортированные данные
454 d = [
455    2.1   0.1   1.3   1.2   0.1   1.2
456    0.3   1.2   2.3   0.3   1.2   2.1
457    0.1   1.2   1.1   1.2   2.2   1.1
458    2.3   1.3   0.1   2.3   0.1   0.1
459    0.1   2.2   2.1   0.2   1.1   0.3
460   ];
461 // Сортировка
462 [r, k] = gsort(d, "g", ["i" "d"], list(int, get_frac))
463 ]]>     </programlisting>
464         <screen><![CDATA[
465  r  =
466    0.3   0.1   0.1   1.2   1.1   2.2
467    0.3   0.1   1.3   1.2   1.1   2.2
468    0.3   0.1   1.3   1.2   2.3   2.1
469    0.2   0.1   1.2   1.2   2.3   2.1
470    0.1   0.1   1.2   1.1   2.3   2.1
471
472  k  =
473    2.    5.    29.   16.   25.   10.
474    17.   6.    9.    18.   28.   23.
475    30.   14.   11.   22.   4.    1.
476    20.   21.   7.    26.   12.   15.
477    3.    24.   8.    13.   19.   27.
478 ]]></screen>
479         </para>
480         <para>
481             <emphasis role="bold">С комплексными числами</emphasis>:
482             Сортировка сначала в порядке увеличения вещественных частей, затем в порядке
483             увеличения мнимых частей.
484         </para>
485         <para>
486         <programlisting role="example"><![CDATA[
487 //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]
488 //c = matrix(squeeze(grand(1,"prm",complex(c(:,1), c(:,2)))), [3,4])
489 s = "complex([0,0,-1,-1;0,-1,1,1;1,1,0,0]," + ..
490             "[%inf,2,%nan,1;-1,0,-1,%nan;1,-%inf,1,%nan])";
491 c = evstr(s)
492 [r, k] = gsort(c, "g", ["i" "i"], list(real, imag))
493 ]]>     </programlisting>
494     <screen><![CDATA[
495 --> c = evstr(s)
496  c  =
497    0. + Infi   0. + 2.i   -1. + Nani  -1. + i
498    0. - i     -1. + 0.i    1. - i      1. + Nani
499    1. + i      1. - Infi   0. + i      0. + Nani
500
501  r  =
502   -1. + 0.i    0. - i     0. + Infi   1. - i
503   -1. + i      0. + i     0. + Nani   1. + i
504   -1. + Nani   0. + 2.i   1. - Infi   1. + Nani
505
506  k  =
507    5.    2.   1.    8.
508    10.   9.   12.   3.
509    7.    4.   6.    11.
510 ]]></screen>
511         </para>
512         <para>
513             <emphasis role="bold">С некоторыми текстами:</emphasis>
514             Сортировка строк в столбцах, сначала в порядке увеличения длины, затем в алфавитном
515             порядке.
516         </para>
517         <para>
518         <programlisting role="example"><![CDATA[
519 t = [
520   "cc"    "ca"    "ab"    "bbca"  "b"     "ccbc"  "aab"   "bca"
521   "ac"    "bba"   "aba"   "bb"    "a"     "cac"   "b"     "b"
522   "aaaa"  "ac"    "b"     "bbca"  "bb"    "bc"    "aa"    "ca"
523   "c"     "ba"    "cbb"   "a"     "aab"   "abbb"  "ac"    "c"
524   "cbb"   "b"     "cabb"  "bccc"  "aba"   "acb"   "acb"   "b"
525   "cba"   "cc"    "a"     "abbb"  "ab"    "cc"    "bba"   "caaa"
526   ];
527
528 [r, k] = gsort(t, "r", ["i" "i"], list(length, :))
529 ]]>     </programlisting>
530         <screen><![CDATA[
531 --> [r, k] = gsort(t, "r", ["i" "i"], list(length, :))
532  r  =
533   "c"     "b"    "a"     "a"     "a"    "bc"    "b"    "b"
534   "ac"    "ac"   "b"     "bb"    "b"    "cc"    "aa"   "b"
535   "cc"    "ba"   "ab"    "abbb"  "ab"   "acb"   "ac"   "c"
536   "cba"   "ca"   "aba"   "bbca"  "bb"   "cac"   "aab"  "ca"
537   "cbb"   "cc"   "cbb"   "bbca"  "aab"  "abbb"  "acb"  "bca"
538   "aaaa"  "bba"  "cabb"  "bccc"  "aba"  "ccbc"  "bba"  "caaa"
539
540  k  =
541    4.   5.   6.   4.   2.   3.   2.   2.
542    2.   3.   3.   2.   1.   6.   3.   5.
543    1.   4.   1.   6.   6.   5.   4.   4.
544    6.   1.   2.   1.   3.   2.   1.   3.
545    5.   6.   4.   3.   4.   4.   5.   1.
546    3.   2.   5.   5.   5.   1.   6.   6.
547 ]]></screen>
548         </para>
549 <!--  Display up to 6.0.2 (without extra blank lines)
550  r  =
551 !c     b    a     a     a    bc    b    b     !
552 !ac    ac   b     bb    b    cc    aa   b     !
553 !cc    ba   ab    abbb  ab   acb   ac   c     !
554 !cba   ca   aba   bbca  bb   cac   aab  ca    !
555 !cbb   cc   cbb   bbca  aab  abbb  acb  bca   !
556 !aaaa  bba  cabb  bccc  aba  ccbc  bba  caaa  !
557 -->
558         <para>
559             <emphasis role="bold">С некоторыми полиномами:</emphasis>
560             Сортировка сначала в порядке уменьшения значений x^0, затем в порядке увеличения
561             степеней.
562         </para>
563         <para>
564         <programlisting role="example"><![CDATA[
565 function c = get_coef(p, d)
566     // d : степени возвращаемых коэффициентов
567     c = matrix(coeff(p(:))(:,d+1), size(p))
568 endfunction
569
570 P = ["[-x,1-2*x,2+2*x,1-x,2,-1-x;"
571      "1-x,-1+x,-1,x,1+2*x,2*x;"
572      "-2+x,1,-2,2+x,-x,-1-x]"];
573
574 x = varn(%s,"x");
575 P = evstr(P)
576
577 [r, k] = gsort(P, "g", ["d" "i"], list(list(get_coef, 0), degree))
578 ]]>     </programlisting>
579         <screen><![CDATA[
580 --> P = evstr(P)
581  P  =
582   -x      1 -2x   2 +2x   1 -x   2      -1 -x
583    1 -x  -1 +x   -1       x      1 +2x   2x
584   -2 +x   1      -2       2 +x   -x     -1 -x
585
586 --> [r, k] = gsort(P, "g", ["d" "i"], list(list(get_coef, 0), degree))
587  r  =
588   2      1      1 -x   x   -1     -1 -x
589   2 +2x  1 -x   1 +2x  -x  -1 +x  -2
590   2 +x   1 -2x  -x     2x  -1 -x  -2 +x
591
592  k  =
593    13.   6.   10.   11.   8.    18.
594    7.    2.   14.   15.   5.    9.
595    12.   4.   1.    17.   16.   3.
596 ]]></screen>
597         </para>
598     </refsect3>
599     </refsection>
600     <refsection role="see also">
601         <title>Смотрите также</title>
602         <simplelist type="inline">
603             <member>
604                 <link linkend="comparison">сравнение</link>
605             </member>
606             <member>
607                 <link linkend="strcmp">strcmp</link>
608             </member>
609             <member>
610                 <link linkend="find">find</link>
611             </member>
612             <member>
613                 <link linkend="overloading">перегрузка</link>
614             </member>
615         </simplelist>
616     </refsection>
617     <refsection>
618         <title>Литература</title>
619         <para>Quick sort algorithm from Bentley &amp; McIlroy's "Engineering a
620             Sort Function". Software---Practice and Experience,
621             23(11):1249-1265
622         </para>
623     </refsection>
624     <refsection>
625         <title>История</title>
626         <revhistory>
627             <revision>
628                 <revnumber>5.4.0</revnumber>
629                 <revremark>
630                     Теперь gsort() может быть перегружена для неуправляемых типов.
631                 </revremark>
632             </revision>
633             <revision>
634                 <revnumber>6.1.0</revnumber>
635                 <revremark>
636                     <itemizedlist>
637                         <listitem>
638                             Теперь можно сортировать логические значения.
639                         </listitem>
640                         <listitem>
641                             Многоуровневая сортировка, добавленная с помощью опции rankFuncs.
642                         </listitem>
643                     </itemizedlist>
644                 </revremark>
645             </revision>
646             <revision>
647                 <revnumber>6.1.1</revnumber>
648                 <revremark>
649                     gsort() ранее была ограничена вещественными или комплексными
650                     векторами и только методом 'g'. Теперь она полностью способна
651                     к работе с разрежёнными векторами и двумерными матрицами логических,
652                     вещественных или комплексных чисел, всеми методами 'g, r, c, lr, lc'.
653                     Многоуровневая сортировка возможна для всех типов разрежённых входных данных.
654                 </revremark>
655             </revision>
656         </revhistory>
657     </refsection>
658 </refentry>