Документация Engee

Сортировка и связанные с ней функции

Julia имеет обширный и гибкий API для сортировки и взаимодействия с уже отсортированными массивами значений. По умолчанию Julia выбирает разумные алгоритмы и выполняет сортировку в порядке возрастания:

julia> sort([2,3,1])
3-element Vector{Int64}:
 1
 2
 3

Кроме того, можно сортировать значения и в обратном порядке:

julia> sort([2,3,1], rev=true)
3-element Vector{Int64}:
 3
 2
 1

sort создает отсортированную копию, оставляя входные данные без изменений. Используйте высокопроизводительную версию функции сортировки для изменения существующего массива:

julia> a = [2,3,1];

julia> sort!(a);

julia> a
3-element Vector{Int64}:
 1
 2
 3

Вместо того чтобы напрямую сортировать массив, можно вычислить перестановку индексов массива, которая приведет его в отсортированный порядок:

julia> v = randn(5)
5-element Array{Float64,1}:
  0.297288
  0.382396
 -0.597634
 -0.0104452
 -0.839027

julia> p = sortperm(v)
5-element Array{Int64,1}:
 5
 3
 4
 1
 2

julia> v[p]
5-element Array{Float64,1}:
 -0.839027
 -0.597634
 -0.0104452
  0.297288
  0.382396

Массивы можно отсортировать в соответствии с произвольным преобразованием их значений:

julia> sort(v, by=abs)
5-element Array{Float64,1}:
 -0.0104452
  0.297288
  0.382396
 -0.597634
 -0.839027

Или в обратном порядке путем преобразования:

julia> sort(v, by=abs, rev=true)
5-element Array{Float64,1}:
 -0.839027
 -0.597634
  0.382396
  0.297288
 -0.0104452

При необходимости можно выбрать алгоритм сортировки:

julia> sort(v, alg=InsertionSort)
5-element Array{Float64,1}:
 -0.839027
 -0.597634
 -0.0104452
  0.297288
  0.382396

Все функции, связанные с сортировкой и упорядочением, основаны на отношении «меньше, чем», определяющим строгий слабый порядок обрабатываемых значений. Функция isless вызывается по умолчанию, но отношение можно указать с помощью ключевого слова lt. Это функция, которая принимает два элемента массива и возвращает true тогда и только тогда, когда первый аргумент «меньше» второго. Дополнительные сведения см. в описании sort! и в разделе Альтернативные упорядочения.

Функции сортировки

sort!(A; dims::Integer, alg::Algorithm=defalg(A), lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)

Сортирует многомерный массив A в измерении dims. Описание возможных именованных аргументов см. в разделе об одномерной версии sort!.

Сведения о сортировке срезов массива см. в описании sortslices.

Совместимость: Julia 1.1

Для этой функции требуется версия Julia не ниже 1.1.

Примеры

julia> A = [4 3; 1 2]
2×2 Matrix{Int64}:
 4  3
 1  2

julia> sort!(A, dims = 1); A
2×2 Matrix{Int64}:
 1  2
 4  3

julia> sort!(A, dims = 2); A
2×2 Matrix{Int64}:
 1  2
 3  4
sort!(A; dims::Integer, alg::Algorithm=defalg(A), lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)

Sort the multidimensional array A along dimension dims. See the one-dimensional version of sort! for a description of possible keyword arguments.

To sort slices of an array, refer to sortslices.

Совместимость: Julia 1.1

This function requires at least Julia 1.1.

Examples

julia> A = [4 3; 1 2]
2×2 Matrix{Int64}:
 4  3
 1  2

julia> sort!(A, dims = 1); A
2×2 Matrix{Int64}:
 1  2
 4  3

julia> sort!(A, dims = 2); A
2×2 Matrix{Int64}:
 1  2
 3  4
sort(v; alg::Algorithm=defalg(v), lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)

Вариант sort!, который возвращает отсортированную копию v, оставляя v без изменений.

Примеры

julia> v = [3, 1, 2];

julia> sort(v)
3-element Vector{Int64}:
 1
 2
 3

julia> v
3-element Vector{Int64}:
 3
 1
 2
sort(A; dims::Integer, alg::Algorithm=defalg(A), lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)

Сортирует многомерный массив A в заданном измерении. Описание возможных именованных аргументов см. в описании sort!.

Сведения о сортировке срезов массива см. в описании sortslices.

Примеры

julia> A = [4 3; 1 2]
2×2 Matrix{Int64}:
 4  3
 1  2

julia> sort(A, dims = 1)
2×2 Matrix{Int64}:
 1  2
 4  3

julia> sort(A, dims = 2)
2×2 Matrix{Int64}:
 3  4
 1  2
sortperm(A; alg::Algorithm=DEFAULT_UNSTABLE, lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward, [dims::Integer])

Возвращает вектор перестановки или массив I, в котором элементы A[I] размещаются в отсортированном порядке в заданном измерении. Если A имеет несколько измерений, необходимо указать именованный аргумент dims. Порядок задается с помощью тех же именованных аргументов, что и для sort!. Перестановка гарантированно будет устойчивой, даже если алгоритм сортировки является неустойчивым: индексы равных элементов будут располагаться в порядке возрастания.

См. также описание sortperm!, partialsortperm, invperm и indexin. Сведения о сортировке срезов массива см. в описании sortslices.

Совместимость: Julia 1.9

Для метода, принимающего dims, требуется версия Julia не ниже 1.9.

Примеры

julia> v = [3, 1, 2];

julia> p = sortperm(v)
3-element Vector{Int64}:
 2
 3
 1

julia> v[p]
3-element Vector{Int64}:
 1
 2
 3

julia> A = [8 7; 5 6]
2×2 Matrix{Int64}:
 8  7
 5  6

julia> sortperm(A, dims = 1)
2×2 Matrix{Int64}:
 2  4
 1  3

julia> sortperm(A, dims = 2)
2×2 Matrix{Int64}:
 3  1
 2  4
InsertionSort

Использует алгоритм сортировки вставкой.

Сортировка вставками проходит по одному элементу коллекции за раз, вставляя каждый элемент в правильную отсортированную позицию в выходном векторе.

Характеристики:

  • Устойчивость: сохраняется порядок элементов, которые считаются равными (например, «a» и «A» при сортировке букв без учета регистра).

  • Выполнение на месте в памяти.

  • Квадратичная производительность в количестве подлежащих сортировке элементов: хорошо подходит для небольших коллекций, но не следует использовать для больших.

MergeSort

Указывает, что функция сортировки должна использовать алгоритм сортировки слиянием. Сортировка слиянием делит коллекцию на подколлекции и многократно объединяет их, сортируя каждую подколлекцию на каждом этапе до тех пор, пока вся коллекция не будет перекомпонована в отсортированный вид.

Характеристики:

  • Устойчивость: сохраняется порядок элементов, которые считаются равными (например, «a» и «A» при сортировке букв без учета регистра).

  • Выполнение не на месте в памяти.

  • Стратегия сортировки «разделяй и властвуй».

  • Хорошая производительность для больших коллекций, но, как правило, не настолько быстрая, как QuickSort.

QuickSort

Указывает, что функция сортировки должна использовать алгоритм быстрой сортировки, который не является устойчивым.

Характеристики:

  • Неустойчивость: не сохраняется порядок элементов, которые считаются равными (например, «a» и «A» при сортировке букв без учета регистра).

  • Выполнение на месте в памяти.

  • «Разделяй и властвуй»: стратегия сортировки, аналогичная MergeSort.

  • Хорошая производительность для больших коллекций.

PartialQuickSort{T <: Union{Integer,OrdinalRange}}

Указывает, что функция сортировки должна использовать алгоритм частичной быстрой сортировки. PartialQuickSort(k) напоминает QuickSort, но требуется искать и сортировать только элементы, которые при полной сортировке v попали бы в v[k].

Характеристики:

  • Неустойчивость: не сохраняется порядок элементов, которые считаются равными (например, «a» и «A» при сортировке букв без учета регистра).

  • Выполнение на месте в памяти.

  • «Разделяй и властвуй»: стратегия сортировки, аналогичная MergeSort.

Обратите внимание, что PartialQuickSort(k) необязательно выполняет сортировку всего массива. Примеры:

julia> x = rand(100);

julia> k = 50:100;

julia> s1 = sort(x; alg=QuickSort);

julia> s2 = sort(x; alg=PartialQuickSort(k));

julia> map(issorted, (s1, s2))
(true, false)

julia> map(x->issorted(x[k]), (s1, s2))
(true, true)

julia> s1[k] == s2[k]
true
sortperm!(ix, A; alg::Algorithm=DEFAULT_UNSTABLE, lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward, [dims::Integer])

Аналогично sortperm, но принимает предварительно выделенный вектор или массив индексов ix с теми же осями axes, что и у A. ix инициализируется со значениями LinearIndices(A).

Если какой-либо измененный аргумент размещается в одной области памяти с любым другим аргументом, поведение может быть непредвиденным.
Совместимость: Julia 1.9

Для метода, принимающего dims, требуется версия Julia не ниже 1.9.

Примеры

julia> v = [3, 1, 2]; p = zeros(Int, 3);

julia> sortperm!(p, v); p
3-element Vector{Int64}:
 2
 3
 1

julia> v[p]
3-element Vector{Int64}:
 1
 2
 3

julia> A = [8 7; 5 6]; p = zeros(Int,2, 2);

julia> sortperm!(p, A; dims=1); p
2×2 Matrix{Int64}:
 2  4
 1  3

julia> sortperm!(p, A; dims=2); p
2×2 Matrix{Int64}:
 3  1
 2  4
sortslices(A; dims, alg::Algorithm=DEFAULT_UNSTABLE, lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)

Сортирует срезы массива A. Обязательный именованный аргумент dims должен быть целым числом или кортежем целых чисел. Он задает измерения, в которых сортируются срезы.

Например, если A является матрицей, dims=1 будет сортировать строки, dims=2 будет сортировать столбцы. Обратите внимание, что функция сравнения по умолчанию в одномерных срезах выполняет лексикографическую сортировку.

Сведения об остальных именованных аргументах см. в документации по sort!.

Примеры

julia> sortslices([7 3 5; -1 6 4; 9 -2 8], dims=1) # Сортировка строк
3×3 Matrix{Int64}:
 -1   6  4
  7   3  5
  9  -2  8

julia> sortslices([7 3 5; -1 6 4; 9 -2 8], dims=1, lt=(x,y)->isless(x[2],y[2]))
3×3 Matrix{Int64}:
  9  -2  8
  7   3  5
 -1   6  4

julia> sortslices([7 3 5; -1 6 4; 9 -2 8], dims=1, rev=true)
3×3 Matrix{Int64}:
  9  -2  8
  7   3  5
 -1   6  4

julia> sortslices([7 3 5; 6 -1 -4; 9 -2 8], dims=2) # Сортировка столбцов
3×3 Matrix{Int64}:
  3   5  7
 -1  -4  6
 -2   8  9

julia> sortslices([7 3 5; 6 -1 -4; 9 -2 8], dims=2, alg=InsertionSort, lt=(x,y)->isless(x[2],y[2]))
3×3 Matrix{Int64}:
  5   3  7
 -4  -1  6
  8  -2  9

julia> sortslices([7 3 5; 6 -1 -4; 9 -2 8], dims=2, rev=true)
3×3 Matrix{Int64}:
 7   5   3
 6  -4  -1
 9   8  -2

Более высокие измерения

sortslices естественным образом распространяется на более высокие измерения. Например, если A является массивом 2x2x2, sortslices(A, dims=3) будет сортировать срезы в третьем измерении, передавая срезы 2x2 A[:, :, 1] и A[:, :, 2] функции сравнения. Обратите внимание, что хотя для срезов более высоких измерений порядок по умолчанию отсутствует, его можно указать с помощью именованного аргумента by или lt.

Если dims представляет собой кортеж, порядок измерений в dims является относительным и указывает линейный порядок срезов. Например, если A является трехмерным и dims имеет значение (1, 2), порядки первых двух измерений изменяются таким образом, что сортируются срезы (оставшегося третьего измерения). Если dims имеет значение (2, 1), используются же самые срезы, но результирующий порядок будет построчным.

Примеры более высоких измерений

julia> A = [4 3; 2 1 ;;; 'A' 'B'; 'C' 'D']
2×2×2 Array{Any, 3}:
[:, :, 1] =
 4  3
 2  1

[:, :, 2] =
 'A'  'B'
 'C'  'D'

julia> sortslices(A, dims=(1,2))
2×2×2 Array{Any, 3}:
[:, :, 1] =
 1  3
 2  4

[:, :, 2] =
 'D'  'B'
 'C'  'A'

julia> sortslices(A, dims=(2,1))
2×2×2 Array{Any, 3}:
[:, :, 1] =
 1  2
 3  4

[:, :, 2] =
 'D'  'C'
 'B'  'A'

julia> sortslices(reshape([5; 4; 3; 2; 1], (1,1,5)), dims=3, by=x->x[1,1])
1×1×5 Array{Int64, 3}:
[:, :, 1] =
 1

[:, :, 2] =
 2

[:, :, 3] =
 3

[:, :, 4] =
 4

[:, :, 5] =
 5

Функции, связанные с упорядочением

issorted(v, lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)

Проверяет, находится ли коллекция в отсортированном порядке. Именованные аргументы изменяют порядок сортировки, как описано в документации по sort!.

Примеры

julia> issorted([1, 2, 3])
true

julia> issorted([(1, "b"), (2, "a")], by = x -> x[1])
true

julia> issorted([(1, "b"), (2, "a")], by = x -> x[2])
false

julia> issorted([(1, "b"), (2, "a")], by = x -> x[2], rev=true)
true

julia> issorted([1, 2, -2, 3], by=abs)
true
searchsorted(v, x; by=identity, lt=isless, rev=false)

Возвращает диапазон индексов в v, где значения эквивалентны x, или пустой диапазон, расположенный в точке вставки, если v не содержит значений, эквивалентных x. Вектор v должен быть отсортирован в порядке, определяемом именованными аргументами. Значение именованных аргументов и определение эквивалентности см. в описании sort!. Обратите внимание, что функция by применяется к искомому значению x, а также к значениям в v.

Диапазон обычно находится посредством бинарного поиска, но для некоторых входных данных существуют оптимизированные реализации.

См. также описание searchsortedfirst, sort!, insorted, findall.

Примеры

julia> searchsorted([1, 2, 4, 5, 5, 7], 4) # одно совпадение
3:3

julia> searchsorted([1, 2, 4, 5, 5, 7], 5) # несколько совпадений
4:5

julia> searchsorted([1, 2, 4, 5, 5, 7], 3) # нет совпадений, вставить в середину
3:2

julia> searchsorted([1, 2, 4, 5, 5, 7], 9) # нет совпадений, вставить в конец
7:6

julia> searchsorted([1, 2, 4, 5, 5, 7], 0) # нет совпадений, вставить в начало
1:0

julia> searchsorted([1=>"one", 2=>"two", 2=>"two", 4=>"four"], 2=>"two", by=first) # сравнить ключи пар
2:3
searchsortedfirst(v, x; by=identity, lt=isless, rev=false)

Возвращает индекс первого значения в v, которое не упорядочено перед x. Если все значения в v упорядочены перед x, возвращает lastindex(v) + 1.

Вектор v должен быть отсортирован в порядке, определяемом именованными аргументами. При вставке (insert!) x по возвращенному индексу отсортированный порядок сохраняется. Значение и способы использования именованных аргументов см. в описании sort!. Обратите внимание, что функция by применяется к искомому значению x, а также к значениям в v.

Индекс обычно находится посредством бинарного поиска, но для некоторых входных данных существуют оптимизированные реализации.

См. также описание searchsortedlast, searchsorted, findfirst.

Примеры

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 4) # одно совпадение
3

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 5) # несколько совпадений
4

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 3) # нет совпадений, вставить в середину
3

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 9) # нет совпадений, вставить в конец
7

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 0) # нет совпадений, вставить в начало
1

julia> searchsortedfirst([1=>"one", 2=>"two", 4=>"four"], 3=>"three", by=first) # сравнить ключи пар
3
searchsortedlast(v, x; by=identity, lt=isless, rev=false)

Возвращает индекс последнего значения в v, которое не упорядочено после x. Если все значения в v упорядочены после x, возвращает firstindex(v) - 1.

Вектор v должен быть отсортирован в порядке, определяемом именованными аргументами. При вставке (insert!) x сразу после возвращенного индекса отсортированный порядок сохраняется. Значение и способы использования именованных аргументов см. в описании sort!. Обратите внимание, что функция by применяется к искомому значению x, а также к значениям в v.

Индекс обычно находится посредством бинарного поиска, но для некоторых входных данных существуют оптимизированные реализации.

Примеры

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 4) # одно совпадение
3

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 5) # несколько совпадений
5

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 3) # нет совпадений, вставить в середину
2

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 9) # нет совпадений, вставить в конец
6

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 0) # нет совпадений, вставить в начало
0

julia> searchsortedlast([1=>"one", 2=>"two", 4=>"four"], 3=>"three", by=first) # сравнить ключи пар
2
insorted(x, v; by=identity, lt=isless, rev=false) -> Bool

Определяет, содержит ли вектор v какое-либо значение, эквивалентное x. Вектор v должен быть отсортирован в порядке, определяемом именованными аргументами. Значение именованных аргументов и определение эквивалентности см. в описании sort!. Обратите внимание, что функция by применяется к искомому значению x, а также к значениям в v.

Проверка обычно осуществляется посредством бинарного поиска, но для некоторых входных данных существуют оптимизированные реализации.

См. также описание in.

Примеры

julia> insorted(4, [1, 2, 4, 5, 5, 7]) # одно совпадение
true

julia> insorted(5, [1, 2, 4, 5, 5, 7]) # несколько совпадений
true

julia> insorted(3, [1, 2, 4, 5, 5, 7]) # нет совпадений
false

julia> insorted(9, [1, 2, 4, 5, 5, 7]) # нет совпадений
false

julia> insorted(0, [1, 2, 4, 5, 5, 7]) # нет совпадений
false

julia> insorted(2=>"TWO", [1=>"one", 2=>"two", 4=>"four"], by=first) # сравнить ключи пар
true
Совместимость: Julia 1.6

insorted было добавлено в Julia 1.6.

 
partialsort!(v, k; by=identity, lt=isless, rev=false)

Частично сортирует вектор v на месте так, чтобы значение с индексом k (или диапазон смежных значений, если k является диапазоном) оказалось в той позиции, в которой оно бы находилось, если бы массив был полностью отсортирован. Если k является одним индексом, возвращается это значение. Если k является диапазоном, возвращается массив значений в этих индексах. Обратите внимание, что partialsort! не выполняет полную сортировку входного массива.

Сведения об именованных аргументах см. в документации по sort!.

Примеры

julia> a = [1, 2, 4, 3, 4]
5-element Vector{Int64}:
 1
 2
 4
 3
 4

julia> partialsort!(a, 4)
4

julia> a
5-element Vector{Int64}:
 1
 2
 3
 4
 4

julia> a = [1, 2, 4, 3, 4]
5-element Vector{Int64}:
 1
 2
 4
 3
 4

julia> partialsort!(a, 4, rev=true)
2

julia> a
5-element Vector{Int64}:
 4
 4
 3
 2
 1
partialsort(v, k, by=identity, lt=isless, rev=false)

Вариант partialsort!, который копирует v перед его частичной сортировкой, тем самым возвращая тот же результат, что и partialsort!, но оставляя v без изменений.

partialsortperm(v, k; by=identity, lt=isless, rev=false)

Возвращает частичную перестановку I вектора v, так что v[I] возвращает значения полностью отсортированной версии v по индексу k. Если k является диапазоном, возвращается вектор индексов. Если k является целым числом, возвращается один индекс. Порядок задается с помощью тех же именованных аргументов, что и для sort!. Перестановка устойчивая: индексы равных элементов будут располагаться в порядке возрастания.

Эта функция эквивалентна вызову sortperm(...)[k], но является более эффективной.

Примеры

julia> v = [3, 1, 2, 1];

julia> v[partialsortperm(v, 1)]
1

julia> p = partialsortperm(v, 1:3)
3-element view(::Vector{Int64}, 1:3) with eltype Int64:
 2
 4
 3

julia> v[p]
3-element Vector{Int64}:
 1
 1
 2
partialsortperm!(ix, v, k; by=identity, lt=isless, rev=false)

Аналогично partialsortperm, но принимает предварительно выделенный вектор индексов ix того же размера, что и у v, который используется для хранения (перестановки) индексов v.

ix инициализируется с индексами v.

(Обычно индексы v будут находиться в диапазоне 1:length(v), хотя если v имеет другой тип массива с индексами, не начинающимися с единицы, например OffsetArray, в ix должны использоваться те же индексы.)

После возвращения ix гарантированно будет иметь индексы k в отсортированных позициях, как показано далее.

partialsortperm!(ix, v, k);
v[ix[k]] == partialsort(v, k)

Возвращаемым значением является k-й элемент вектора индекса ix, если k представляет собой целое число, или представлением ix, если k представляет собой диапазон.

Если какой-либо измененный аргумент размещается в одной области памяти с любым другим аргументом, поведение может быть непредвиденным.

Примеры

julia> v = [3, 1, 2, 1];

julia> ix = Vector{Int}(undef, 4);

julia> partialsortperm!(ix, v, 1)
2

julia> ix = [1:4;];

julia> partialsortperm!(ix, v, 2:3)
2-element view(::Vector{Int64}, 2:3) with eltype Int64:
 4
 3

Алгоритмы сортировки

В настоящее время в базовой версии Julia общедоступны четыре алгоритма сортировки:

По умолчанию семейство функций sort использует стабильные алгоритмы сортировки, которые быстро работают с большинством входных данных. Точный выбор алгоритма является особенностью реализации, позволяющей улучшить производительность в будущем. В настоящее время в зависимости от типа, размера и состава входных данных используется гибрид RadixSort, ScratchQuickSort, InsertionSort и CountingSort. Детали реализации могут меняться, но сейчас они доступны в расширенной справке по ??Base.DEFAULT_STABLE и указанных там docstrings внутренних алгоритмов сортировки.

Вы можете явным образом указать предпочитаемый алгоритм с помощью ключевого слова alg (например, sort!(v, alg=PartialQuickSort(10:20))) или перенастроить алгоритм сортировки по умолчанию для пользовательских типов, добавив специализированный метод в функцию Base.Sort.defalg. Например, InlineStrings.jl определяет следующий метод:

Base.Sort.defalg(::AbstractArray{<:Union{SmallInlineStrings, Missing}}) = InlineStringSort
Совместимость: Julia 1.9

Алгоритм сортировки по умолчанию (возвращаемый Base.Sort.defalg) гарантированно стабилен начиная с Julia 1.9. Предыдущие версии имели нестабильные пограничные случаи при сортировке числовых массивов.

Альтернативные упорядочения

По умолчанию sort, searchsorted и связанные функции используют isless для сравнения двух элементов, чтобы определить, какой из них должен быть первым. Абстрактный тип Base.Order.Ordering предоставляет механизм для определения альтернативных упорядочений для одного и того же набора элементов: При вызове функции сортировки, например sort!, экземпляр Ordering может быть указан с именованным аргументом order.

Экземпляры Ordering определяют порядок с помощью функции Base.Order.lt, которая работает как обобщение isless. Действие этой функции с пользовательскими упорядочениями (Ordering) должно удовлетворять всем условиям строгого слабого порядка. См. описание sort! со сведениями и примерами допустимых и недопустимых функций lt.

Base.Order.Ordering

Абстрактный тип, представляющий строгий слабый порядок в некотором наборе элементов. Дополнительные сведения см. в описании sort!.

Для сравнения двух элементов в соответствии с упорядочением используйте Base.Order.lt.

lt(o::Ordering, a, b) -> Bool

Проверяет, меньше ли a чем b, в соответствии с упорядочением o.

ord(lt, by, rev::Union{Bool, Nothing}, order::Ordering=Forward)

Создает объект Ordering на основе тех же аргументов, которые использует функция sort!. Сначала элементы преобразуются с помощью функции by (это может быть identity), а затем сравниваются в соответствии с функцией lt или существующем упорядочением order. lt должно быть isless или являться функцией, которая подчиняется тем же правилам, что и параметр lt функции sort!. Наконец, итоговый порядок меняется на обратный, если rev=true.

Передача lt, отличного от isless, вместе с order, отличным от Base.Order.Forward или Base.Order.Reverse, запрещена. В противном случае все параметры независимы и могут использоваться вместе во всех возможных комбинациях.

Base.Order.Forward

Порядок по умолчанию в соответствии с isless.

ReverseOrdering(fwd::Ordering=Forward)

Оболочка, которая меняет порядок на обратный.

Для заданного Ordering o следующее справедливо для всех a, b:

lt(ReverseOrdering(o), a, b) == lt(o, b, a)
Base.Order.Reverse

Меняет порядок на обратный в соответствии с isless.

By(by, order::Ordering=Forward)

Ordering, который применяет order к элементам после их преобразования функцией by.

Lt(lt)

Ordering, который вызывает lt(a, b) для сравнения элементов. lt должно подчиняться тем же правилам, что и параметр lt функции sort!.

Perm(order::Ordering, data::AbstractVector)

Ordering для индексов data, где i меньше чем j, если data[i] меньше чем data[j] в соответствии с order. Если data[i] и data[j] равны, i и j сравниваются по числовому значению.