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