Сборники и структуры данных

Итерация

Последовательная итерация реализована методами start(), done() и next(). Общий цикл for:

for i = I   # or  "for i in I"
    # body
end

переводится в:

state = start(I)
while !done(I, state)
    (i, state) = next(I, state)
    # body
end

Объект state может быть чем угодно и должен быть выбран соответствующим образом для каждого итерируемого типа. Подробную информацию о определении пользовательского итерируемого типа см. в разделе руководства по интерфейсу итерации.

start(iter) → state

Получение начального состояния итерации для итерируемого объекта.

done(iter, state) → Bool

Проверка завершения итерации.

next(iter, state) → item, state

Для данного итерируемого объекта и состояния итерации возвращает текущий элемент и следующее состояние итерации.

zip(iters...)

Для набора итерируемых объектов возвращает итерируемый набор кортежей, где i-й кортеж содержит i-й компонент каждого входного итерируемого объекта.

Обратите внимание, что zip() — это собственная обратная функция: collect(zip(zip(a...)...)) == collect(a).

julia> a = 1:5
1:5

julia> b = ["e","d","b","c","a"]
5-element Array{String,1}:
 "e"
 "d"
 "b"
 "c"
 "a"

julia> c = zip(a,b)
Base.Zip2{UnitRange{Int64},Array{String,1}}(1:5,String["e","d","b","c","a"])

julia> length(c)
5

julia> first(c)
(1,"e")

enumerate(iter)

Итератор, который возвращает (i, x), где i — счётчик, начинающийся с 1, а x — i-е значение из данного итератора. Он полезен, когда вам нужны не только значения x по которым вы итерируетесь, но и количество итераций на данный момент. Обратите внимание, что i может быть недействительным для индексирования iter; также возможно, что x != iter[i], если iter имеет индексы, не начинающиеся с 1.

julia> a = ["a", "b", "c"];

julia> for (index, value) in enumerate(a)
           println("$index $value")
       end
1 a
2 b
3 c

rest(iter, state)

Итератор, возвращающий те же элементы, что и iter, но начиная с указанного state.

countfrom(start=1, step=1)

Итератор, который бесконечно считает, начиная с start и увеличивая на step.

take(iter, n)

Итератор, генерирующий не более первых n элементов iter.

julia> a = 1:2:11
1:2:11

julia> collect(a)
6-element Array{Int64,1}:
  1
  3
  5
  7
  9
 11

julia> collect(take(a,3))
3-element Array{Int64,1}:
 1
 3
 5

drop(iter, n)

Итератор, генерирующий все элементы, кроме первых n элементов iter.

julia> a = 1:2:11
1:2:11

julia> collect(a)
6-element Array{Int64,1}:
  1
  3
  5
  7
  9
 11

julia> collect(drop(a,4))
2-element Array{Int64,1}:
  9
 11

cycle(iter)

Итератор, который циклически проходит по iter бесконечно.

repeated(x[, n::Int])

Итератор, который бесконечно генерирует значение x. Если указано n, генерирует x раз (эквивалентно take(repeated(x), n)).

iteratorsize(itertype::Type) → IteratorSize

Для данного типа итератора возвращает одно из следующих значений:

• SizeUnknown() если длина (количество элементов) не может быть определена заранее.
• HasLength() если длина фиксирована и конечна.
• HasShape() если известна длина плюс понятие многомерной формы (как для массива). В этом случае функция size допустима для итератора.
• IsInfinite() если итератор возвращает значения бесконечно.

Значение по умолчанию (для итераторов, не определяющих эту функцию) — HasLength(). Это означает, что большинство итераторов предполагается реализуют length.

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

iteratoreltype(itertype::Type) → IteratorEltype

Для данного типа итератора возвращает одно из следующих значений:

• EltypeUnknown() если тип элементов, возвращаемых итератором, неизвестен заранее.
• HasEltype() если тип элемента известен и eltype вернёт осмысленное значение.

HasEltype() является значением по умолчанию, так как предполагается, что итераторы реализуют eltype.

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

Полностью реализовано для:

• Range
• UnitRange
• Tuple
• Number
• AbstractArray
• IntSet
• ObjectIdDict
• Dict
• WeakKeyDict
• EachLine
• AbstractString
• Set
• Task

Общие коллекции

isempty(collection) → Bool

Определите, является ли коллекция пустой (не содержит элементов).

julia> isempty([])
true

julia> isempty([1 2 3])
false

empty!(collection) → collection

Удаляет все элементы из collection.

length(collection) → Integer

Для упорядоченных, индексируемых коллекций максимальный индекс i для которого getindex(collection, i) допустим. Для неупорядоченных коллекций — количество элементов.

endof(collection) → Integer

Возвращает последний индекс коллекции.

julia> endof([1,2,4])
3

Полностью реализовано для:

• Range
• UnitRange
• Tuple
• Number
• AbstractArray
• IntSet
• Dict
• WeakKeyDict
• AbstractString
• Set

Итерируемые коллекции

in(item, collection) → Bool

∈(item, collection) → Bool

∋(collection, item) → Bool

∉(item, collection) → Bool

∌(collection, item) → Bool

Определите, содержится ли элемент в данной коллекции в том смысле, что он == одному из значений, генерируемых при итерации по коллекции. Для некоторых коллекций требуется немного иное определение; например, Set проверяет, является ли элемент isequal() одному из элементов. Dict ищет (key,value) пары, а ключ сравнивается с помощью isequal(). Для проверки наличия ключа в словаре используйте haskey() или k in keys(dict).

eltype(type)

Определяет тип элементов, генерируемых при итерации по коллекции данного type. Для ассоциативных типов коллекций это будет Pair{KeyType,ValType}. Определение eltype(x) = eltype(typeof(x)) предоставлено для удобства, чтобы можно было передавать экземпляры вместо типов. Однако форма, принимающая аргумент типа, должна быть определена для новых типов.

indexin(a, b)

Возвращает вектор, содержащий максимальный индекс в b для каждого значения в a , которое является членом b . Выходной вектор содержит 0 там, где a не является членом b.

julia> a = ['a', 'b', 'c', 'b', 'd', 'a'];

julia> b = ['a','b','c'];

julia> indexin(a,b)
6-element Array{Int64,1}:
 1
 2
 3
 2
 0
 1

julia> indexin(b,a)
3-element Array{Int64,1}:
 6
 4
 3

findin(a, b)

Возвращает индексы элементов в коллекции a , которые появляются в коллекции b.

julia> a = collect(1:3:15)
5-element Array{Int64,1}:
  1
  4
  7
 10
 13

julia> b = collect(2:4:10)
3-element Array{Int64,1}:
  2
  6
 10

julia> findin(a,b) # 10 is the only common element
1-element Array{Int64,1}:
 4

unique(itr[, dim])

Возвращает массив, содержащий только уникальные элементы итерируемого объекта itr, в порядке, в котором первый из каждого набора эквивалентных элементов первоначально появляется. Если dim указан, возвращает уникальные области массива itr вдоль dim.

unique(itr)

Возвращает массив, содержащий одно значение из itr для каждого уникального значения, как определено isequal.

unique(f, itr)

Возвращает массив, содержащий одно значение из itr для каждого уникального значения, полученного с помощью f применённого к элементам itr.

allunique(itr)

Возвращает true , если все значения из itr различны при сравнении с isequal.

reduce(op, v0, itr)

Применить данную бинарную операцию op к заданному набору ìtr. v0 должен быть нейтральным элементом для op, который будет возвращён для пустых наборов. Не определено, используется ли v0 для непустых наборов.

Для некоторых часто используемых операторов существуют специальные реализации, которые следует использовать вместо стандартных: maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr).

Ассоциативность сокращения зависит от реализации. Это означает, что вы не можете использовать неассоциативные операции, такие как -, потому что не определено, должно ли reduce(-,[1,2,3]) быть вычислено как (1-2)-3 или 1-(2-3). Используйте foldl или foldr для гарантированной левой или правой ассоциативности.

Некоторые операции накапливают ошибки, а параллелизм также будет проще, если сокращение можно выполнить группами. Будущие версии Julia могут изменить алгоритм. Обратите внимание, что элементы не переупорядочиваются, если вы используете упорядоченный набор.

reduce(op, itr)

Аналогично reduce(op, v0, itr). Это нельзя использовать с пустыми наборами, за исключением некоторых особых случаев (например, когда op является одним из +, *, max, min, &, |) когда Julia может определить нейтральный элемент op.

foldl(op, v0, itr)

Аналогично reduce(), но с гарантированной левой ассоциативностью. v0 будет использоваться ровно один раз.

foldl(op, itr)

Аналогично foldl(op, v0, itr), но используя первый элемент itr как v0. В общем случае это нельзя использовать с пустыми наборами (см. reduce(op, itr)).

foldr(op, v0, itr)

Аналогично reduce(), но с гарантированной правой ассоциативностью. v0 будет использоваться ровно один раз.

foldr(op, itr)

Аналогично foldr(op, v0, itr), но используя последний элемент itr как v0. В общем случае это нельзя использовать с пустыми наборами (см. reduce(op, itr)).

maximum(itr)

Возвращает наибольший элемент в наборе.

julia> maximum(-20.5:10)
9.5

julia> maximum([1,2,3])
3

maximum(A, dims)

Вычисляет максимальное значение массива по заданным измерениям.

maximum!(r, A)

Вычисляет максимальное значение A по одиночным измерениям r и записывает результаты в r.

minimum(itr)

Возвращает наименьший элемент в наборе.

julia> minimum(-20.5:10)
-20.5

julia> minimum([1,2,3])
1

minimum(A, dims)

Вычисляет минимальное значение массива по заданным измерениям.

minimum!(r, A)

Вычисляет минимальное значение A по одиночным измерениям r и записывает результаты в r.

extrema(itr) → Tuple

Вычисляет как минимальный, так и максимальный элемент за один проход и возвращает их как пару.

julia> extrema(2:10)
(2,10)

julia> extrema([9,pi,4.5])
(3.141592653589793,9.0)

extrema(A, dims) → Array{Tuple}

Вычисляет минимальные и максимальные элементы массива по заданным измерениям.

indmax(itr) → Integer

Возвращает индекс максимального элемента в наборе. Набор не должен быть пустым.

julia> indmax([8,0.1,-9,pi])
1

indmin(itr) → Integer

Возвращает индекс минимального элемента в наборе. Набор не должен быть пустым.

julia> indmin([8,0.1,-9,pi])
3

findmax(itr) → (x, index)

Возвращает максимальный элемент и его индекс. Набор не должен быть пустым.

julia> findmax([8,0.1,-9,pi])
(8.0,1)

findmax(A, region) → (maxval, index)

Для массива входных данных возвращает значение и индекс максимального значения в заданной области.

findmin(itr) → (x, index)

Возвращает минимальный элемент и его индекс. Набор не должен быть пустым.

julia> findmin([8,0.1,-9,pi])
(-9.0,3)

findmin(A, region) → (minval, index)

Для массива входных данных возвращает значение и индекс минимального значения в заданной области.

findmax!(rval, rind, A[, init=true]) → (maxval, index)

Находит максимальное значение A и соответствующий линейный индекс по одиночным измерениям rval и rind, и сохраняет результаты в rval и rind.

findmin!(rval, rind, A[, init=true]) → (minval, index)

Находит минимальное значение A и соответствующий линейный индекс по одиночным измерениям rval и rind, и сохраняет результаты в rval и rind.

maxabs(itr)

Вычисляет максимальное абсолютное значение коллекции значений.

julia> maxabs([-1, 3, 4*im])
4.0

maxabs(A, dims)

Вычисляет максимальные абсолютные значения по заданным измерениям.

maxabs!(r, A)

Вычисляет максимальные абсолютные значения по одиночным измерениям r и записывает значения в r.

minabs(itr)

Вычисляет минимальное абсолютное значение коллекции значений.

julia> minabs([-1, 3, 4*im])
1.0

minabs(A, dims)

Вычисляет минимальные абсолютные значения по заданным измерениям.

minabs!(r, A)

Вычисляет минимальные абсолютные значения по одиночным измерениям r и записывает значения в r.

sum(itr)

Возвращает сумму всех элементов в наборе.

sum(A, dims)

Суммирует элементы массива по заданным измерениям.

sum!(r, A)

Суммирует элементы A по одиночным измерениям r и записывает результаты в r.

sum(f, itr)

Суммирует результаты вызова функции f для каждого элемента itr.

sumabs(itr)

Суммирует абсолютные значения всех элементов в наборе. Это эквивалентно sum(abs(itr)), но быстрее.

sumabs(A, dims)

Суммирует абсолютные значения элементов массива по заданным измерениям.

sumabs!(r, A)

Суммирует абсолютные значения элементов A по одиночным измерениям r и записывает результаты в r.

sumabs2(itr)

Суммирует квадраты абсолютных значений всех элементов в наборе. Это эквивалентно sum(abs2(itr)), но быстрее.

sumabs2(A, dims)

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

sumabs2!(r, A)

Суммирует квадраты абсолютных значений элементов A по одиночным измерениям r и записывает результаты в r.

prod(itr)

Возвращает произведение всех элементов набора.

prod(A, dims)

Перемножает элементы массива по заданным измерениям.

prod!(r, A)

Перемножает элементы A по одиночным измерениям r и записывает результаты в r.

any(itr) → Bool

Проверяет, являются ли какие-либо элементы булевого набора true.

any(A, dims)

Проверяет, какие-либо значения по заданным измерениям массива являются true.

any!(r, A)

Проверяет, какие-либо значения в A по одиночным измерениям r являются true, и записывает результаты в r.

all(itr) → Bool

Проверяет, являются ли все элементы булевого набора true.

all(A, dims)

Проверяет, являются ли все значения по заданным измерениям массива true.

all!(r, A)

Проверяет, являются ли все значения в A по одиночным измерениям r true, и записывает результаты в r.

count(p, itr) → Integer

Подсчитывает количество элементов в itr, для которых предикат p возвращает true.

julia> count(i->(4<=i<=6), [2,3,4,5,6])
3

any(p, itr) → Bool

Определить, возвращает ли предикат p значение true для каких-либо элементов из itr.

julia> any(i->(4<=i<=6), [3,5,7])
true

all(p, itr) → Bool

Определить, возвращает ли предикат p значение true для всех элементов из itr.

julia> all(i->(4<=i<=6), [4,5,6])
true

foreach(f, c...) → Void

Вызвать функцию f для каждого элемента итерируемого объекта c. Для нескольких итерируемых аргументов, f вызывается поэлементно. Следует использовать foreach вместо map, когда результаты f не требуются, например, в foreach(println, array).

julia> a = 1:3:7;

julia> foreach(x->println(x^2),a)
1
16
49

map(f, c...) → collection

Преобразовать коллекцию c путём применения f к каждому элементу. Для нескольких коллекций аргументов, применять f поэлементно.

julia> map((x) -> x * 2, [1, 2, 3])
3-element Array{Int64,1}:
 2
 4
 6

julia> map(+, [1, 2, 3], [10, 20, 30])
3-element Array{Int64,1}:
 11
 22
 33

map!(function, collection)

Встроенная версия map().

map!(function, destination, collection...)

Аналогично map(), но сохраняет результат в destination, а не в новой коллекции. destination должна быть не меньше, чем первая коллекция.

mapreduce(f, op, v0, itr)

Применить функцию f к каждому элементу в itr, а затем свести результат с помощью бинарной функции op. v0 должен быть нейтральным элементом для op, который будет возвращён для пустых коллекций. Не определено, используется ли v0 для непустых коллекций.

mapreduce() функционально эквивалентна вызову reduce(op, v0, map(f, itr)), но, как правило, выполняется быстрее, так как не требуется создание промежуточной коллекции. См. документацию для reduce() и map().

julia> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
14

Ассоциативность свёртки зависит от реализации. Кроме того, некоторые реализации могут повторно использовать возвращаемое значение f для элементов, которые появляются несколько раз в itr. Используйте mapfoldl() или mapfoldr() для гарантированной левой или правой ассоциативности и вызова f для каждого значения.

mapreduce(f, op, itr)

Аналогично mapreduce(f, op, v0, itr). В общем случае это нельзя использовать с пустыми коллекциями (см. reduce(op, itr)).

mapfoldl(f, op, v0, itr)

Аналогично mapreduce(), но с гарантированной левой ассоциативностью. v0 будет использоваться ровно один раз.

mapfoldl(f, op, itr)

Аналогично mapfoldl(f, op, v0, itr), но используя первый элемент itr в качестве v0. В общем случае это нельзя использовать с пустыми коллекциями (см. reduce(op, itr)).

mapfoldr(f, op, v0, itr)

Аналогично mapreduce(), но с гарантированной правой ассоциативностью. v0 будет использоваться ровно один раз.

mapfoldr(f, op, itr)

Аналогично mapfoldr(f, op, v0, itr), но используя первый элемент itr в качестве v0. В общем случае это нельзя использовать с пустыми коллекциями (см. reduce(op, itr)).

first(coll)

Получить первый элемент итерируемой коллекции. Возвращает начальную точку Range, даже если она пуста.

last(coll)

Получить последний элемент упорядоченной коллекции, если это можно вычислить за O(1) времени. Это достигается вызовом endof() для получения последнего индекса. Возвращает конечную точку Range, даже если она пуста.

step(r)

Получить шаг размера Range объекта.

julia> step(1:10)
1

julia> step(1:2:10)
2

julia> step(2.5:0.3:10.9)
0.3

julia> step(linspace(2.5,10.9,85))
0.1

collect(collection)

Возвратить Array всех элементов в коллекции или итераторе. Для ассоциативных коллекций возвращает Pair{KeyType, ValType}. Если аргумент является массивоподобным или итератором с свойством HasShape(), результат будет иметь ту же форму и количество измерений, что и аргумент.

collect(element_type, collection)

Возвратить Array с заданным типом элемента всех элементов в коллекции или итерируемом объекте. Результат имеет ту же форму и количество измерений, что и collection.

issubset(a, b)

⊆(a, b) → Bool

⊈(a, b) → Bool

⊊(a, b) → Bool

Определить, является ли каждый элемент a также элементом b, используя in().

filter(function, collection)

Возвратить копию collection, удаляя элементы, для которых function является false. Для ассоциативных коллекций функция получает два аргумента (ключ и значение).

julia> a = 1:10
1:10

julia> filter(isodd, a)
5-element Array{Int64,1}:
 1
 3
 5
 7
 9

filter!(function, collection)

Обновить collection, удаляя элементы, для которых function является false. Для ассоциативных коллекций функция получает два аргумента (ключ и значение).

Индексируемые коллекции

getindex(collection, key...)

Получить значение(я), хранящееся по заданному ключу или индексу в коллекции. Синтаксис a[i,j,...] преобразуется компилятором в getindex(a, i, j, ...).

setindex!(collection, value, key...)

Сохранить заданное значение по заданному ключу или индексу в коллекции. Синтаксис a[i,j,...] = x преобразуется компилятором в (setindex!(a, x, i, j, ...); x).

Полностью реализовано для:

• Array
• BitArray
• AbstractArray
• SubArray
• ObjectIdDict
• Dict
• WeakKeyDict
• AbstractString

Частично реализовано для:

• Range
• UnitRange
• Tuple

Ассоциативные коллекции

Dict — стандартная ассоциативная коллекция. Ее реализация использует hash() как функцию хеширования для ключа и isequal() для определения равенства. Определите эти две функции для пользовательских типов, чтобы переопределить способ их хранения в хеш-таблице.

ObjectIdDict — специальная хеш-таблица, где ключи всегда являются идентификаторами объектов.

WeakKeyDict — реализация хеш-таблицы, где ключи являются слабыми ссылками на объекты, и, следовательно, могут быть собраны сборщиком мусора даже при наличии ссылки в хеш-таблице.

Dict могут быть созданы путём передачи объектов пар, сконструированных с помощью =>() конструктору Dict: Dict("A"=>1, "B"=>2). Этот вызов попытается вывести информацию о типе из ключей и значений (т.е. этот пример создаёт Dict{String, Int64}). Для явного указания типов используйте синтаксис Dict{KeyType,ValueType}(...). Например, Dict{String,Int32}("A"=>1, "B"=>2).

Dict также могут быть созданы с генераторами. Например, Dict(i => f(i) for i = 1:10).

Учитывая словарь D, синтаксис D[x] возвращает значение ключа x (если оно существует) или вызывает ошибку, а D[x] = y сохраняет пару ключ-значение x => y в D (заменяя любое существующее значение для ключа x). Несколько аргументов к D[...] преобразуются в кортежи; например, синтаксис D[x,y] эквивалентен D[(x,y)], т.е. он ссылается на значение, имеющее ключ в виде кортежа (x,y).

Dict([itr])

Dict{K,V}() строит хеш-таблицу с ключами типа K и значениями типа V.

При задании единственного итерируемого аргумента строит Dict, пары ключ-значение которых взяты из 2-кортежей (key,value) , сгенерированных аргументом.

julia> Dict([("A", 1), ("B", 2)])
Dict{String,Int64} with 2 entries:
  "B" => 2
  "A" => 1

В качестве альтернативы можно передать последовательность пар аргументов.

julia> Dict("A"=>1, "B"=>2)
Dict{String,Int64} with 2 entries:
  "B" => 2
  "A" => 1

haskey(collection, key) → Bool

Определить, содержит ли коллекция отображение для заданного ключа.

get(collection, key, default)

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

get(f::Function, collection, key)

Возвращает значение, сохранённое для данного ключа, или f(), если сопоставления для ключа нет. Используйте get!(), чтобы также сохранить значение по умолчанию в словаре.

Предполагается, что вызывается с использованием синтаксиса блока do

get(dict, key) do
    # default value calculated here
    time()
end

get!(collection, key, default)

Возвращает значение, сохранённое для данного ключа, или, если сопоставления для ключа нет, сохраняет key => default, и возвращает default.

get!(f::Function, collection, key)

Возвращает значение, сохранённое для данного ключа, или, если сопоставления для ключа нет, сохраняет key => f(), и возвращает f().

Предполагается, что вызывается с использованием синтаксиса блока do:

get!(dict, key) do
    # default value calculated here
    time()
end

getkey(collection, key, default)

Возвращает ключ, соответствующий аргументу key, если он существует в collection, в противном случае возвращает default.

delete!(collection, key)

Удаляет сопоставление для данного ключа в коллекции и возвращает коллекцию.

pop!(collection, key[, default])

Удаляет и возвращает сопоставление для key, если оно существует в collection, в противном случае возвращает default, или генерирует ошибку, если значение по умолчанию не указано.

keys(collection)

Возвращает итератор по всем ключам в коллекции. collect(keys(d)) возвращает массив ключей.

values(collection)

Возвращает итератор по всем значениям в коллекции. collect(values(d)) возвращает массив значений.

merge(collection, others...)

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

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String,Float64} with 2 entries:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String,Int64} with 2 entries:
  "bar" => 4711
  "baz" => 17

julia> merge(a, b)
Dict{String,Float64} with 3 entries:
  "bar" => 4711.0
  "baz" => 17.0
  "foo" => 0.0

julia> merge(b, a)
Dict{String,Float64} with 3 entries:
  "bar" => 42.0
  "baz" => 17.0
  "foo" => 0.0

merge!(collection, others...)

Обновляет коллекцию парами из других коллекций.

sizehint!(s, n)

Предлагает коллекции s зарезервировать емкость как минимум на n элементов. Это может улучшить производительность.

keytype(type)

Получает тип ключа ассоциативного типа коллекции. Ведёт себя аналогично eltype.

valtype(type)

Получает тип значения ассоциативного типа коллекции. Ведёт себя аналогично eltype.

Полностью реализовано для:

• ObjectIdDict
• Dict
• WeakKeyDict

Частично реализовано для:

• IntSet
• Set
• EnvHash
• Array
• BitArray

Множества

Set([itr])

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

IntSet([itr])

Создаёт отсортированное множество положительных Int чисел, сгенерированных заданным итерируемым объектом, или пустое множество. Реализовано как битовое строковое представление, поэтому предназначено для плотных множеств целых чисел. Хранятся только Int числа, большие 0. Если множество будет разреженным (например, содержащим несколько очень больших целых чисел), используйте Set вместо этого.

union(s1, s2...)

∪(s1, s2...)

Создаёт объединение двух или более множеств. Сохраняет порядок с массивами.

union!(s, iterable)

Объединяет каждый элемент iterable в множество s на месте.

intersect(s1, s2...)

∩(s1, s2)

Создаёт пересечение двух или более множеств. Сохраняет порядок и кратность первого аргумента для массивов и диапазонов.

setdiff(a, b)

Создаёт множество элементов в a, но не в b. Сохраняет порядок с массивами. Обратите внимание, что оба аргумента должны быть коллекциями, и по обоим будет пройдено итерирование. В частности, setdiff(set,element) где element — потенциальный член set, не будет работать в общем случае.

julia> setdiff([1,2,3],[3,4,5])
2-element Array{Int64,1}:
 1
 2

setdiff!(s, iterable)

Удаляет каждый элемент iterable из множества s на месте.

symdiff(a, b, rest...)

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

julia> symdiff([1,2,3],[3,4,5],[4,5,6])
3-element Array{Int64,1}:
 1
 2
 6

symdiff!(s, n)

Множество s изменяется с целью переключения включения целого числа n.

symdiff!(s, itr)

Для каждого элемента в itr переключает включение его в множество s.

symdiff!(s1, s2)

Создаёт симметрическую разность множеств s1 и s2, сохраняя результат в s1.

intersect!(s1, s2)

Пересекает множества s1 и s2 и перезаписывает множество s1 результатом. При необходимости s1 будет расширено до размера s2.

issubset(A, S) → Bool

⊆(A, S) → Bool

Возвращает true , если A является подмножеством или равно S.

Полностью реализовано для:

• IntSet
• Set

Частично реализовано для:

• Array

Очереди

push!(collection, items...) → collection

Вставляет один или несколько items в конец collection.

julia> push!([1, 2, 3], 4, 5, 6)
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6

Используйте append!(), чтобы добавить все элементы другой коллекции в collection. Результат предыдущего примера эквивалентен append!([1, 2, 3], [4, 5, 6]).

pop!(collection) → item

Удаляет последний элемент в collection и возвращает его.

julia> A=[1, 2, 3, 4, 5, 6]
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6

julia> pop!(A)
6

julia> A
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

unshift!(collection, items...) → collection

Вставляет один или несколько items в начало collection.

julia> unshift!([1, 2, 3, 4], 5, 6)
6-element Array{Int64,1}:
 5
 6
 1
 2
 3
 4

shift!(collection) → item

Удаляет первый item из collection.

julia> A = [1, 2, 3, 4, 5, 6]
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6

julia> shift!(A)
1

julia> A
5-element Array{Int64,1}:
 2
 3
 4
 5
 6

insert!(collection, index, item)

Вставляет item в collection по указанному index . index - индекс item в результирующем collection.

julia> insert!([6, 5, 4, 2, 1], 4, 3)
6-element Array{Int64,1}:
 6
 5
 4
 3
 2
 1

deleteat!(a::Vector, i::Integer)

Удаляет элемент по указанному i и возвращает изменённую a . Последующие элементы смещаются, чтобы заполнить образовавшийся пробел.

julia> deleteat!([6, 5, 4, 3, 2, 1], 2)
5-element Array{Int64,1}:
 6
 4
 3
 2
 1

deleteat!(a::Vector, inds)

Удаляет элементы по индексам, заданным в inds , и возвращает изменённую a . Последующие элементы смещаются, чтобы заполнить образовавшиеся пробелы. inds должен быть отсортирован и уникален.

julia> deleteat!([6, 5, 4, 3, 2, 1], 1:2:5)
3-element Array{Int64,1}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], (2, 2))
ERROR: ArgumentError: indices must be unique and sorted
 in deleteat!(::Array{Int64,1}, ::Tuple{Int64,Int64}) at ./array.jl:614
 ...

splice!(collection, index[, replacement]) → item

Удаляет элемент по указанному индексу и возвращает удалённый элемент. Последующие элементы смещаются вниз, чтобы заполнить образовавшийся пробел. Если указано, значения замещения из упорядоченной коллекции будут вставлены вместо удалённого элемента.

julia> A = [6, 5, 4, 3, 2, 1]; splice!(A, 5)
2

julia> A
5-element Array{Int64,1}:
 6
 5
 4
 3
 1

julia> splice!(A, 5, -1)
1

julia> A
5-element Array{Int64,1}:
  6
  5
  4
  3
 -1

julia> splice!(A, 1, [-1, -2, -3])
6

julia> A
7-element Array{Int64,1}:
 -1
 -2
 -3
  5
  4
  3
 -1

Чтобы вставить replacement перед индексом n без удаления каких-либо элементов, используйте splice!(collection, n:n-1, replacement).

splice!(collection, range[, replacement]) → items

Удаляет элементы в указанном диапазоне индексов и возвращает коллекцию, содержащую удалённые элементы. Последующие элементы смещаются вниз, чтобы заполнить образовавшиеся пробелы. Если указано, значения замещения из упорядоченной коллекции будут вставлены вместо удалённых элементов.

Чтобы вставить replacement перед индексом n без удаления каких-либо элементов, используйте splice!(collection, n:n-1, replacement).

julia> splice!(A, 4:3, 2)
0-element Array{Int64,1}

julia> A
8-element Array{Int64,1}:
 -1
 -2
 -3
  2
  5
  4
  3
 -1

resize!(collection, n) → collection

Изменить размер collection так, чтобы он содержал n элементов. Если n меньше текущей длины коллекции, будут сохранены первые n элементы. Если n больше, новые элементы не гарантированно будут инициализированы.

julia> resize!([6, 5, 4, 3, 2, 1], 3)
3-element Array{Int64,1}:
 6
 5
 4

julia> resize!([6, 5, 4, 3, 2, 1], 8)
8-element Array{Int64,1}:
 6
 5
 4
 3
 2
 1
 0
 0

append!(collection, collection2) → collection.

Добавить элементы из collection2 в конец collection.

julia> append!([1],[2,3])
3-element Array{Int64,1}:
 1
 2
 3

julia> append!([1, 2, 3], [4, 5, 6])
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6

Используйте push!(), чтобы добавлять отдельные элементы в collection, которые сами не являются коллекциями. Результат предыдущего примера эквивалентен push!([1, 2, 3], 4, 5, 6).

prepend!(collection, items) → collection

Вставить элементы из items в начало collection.

julia> prepend!([3],[1,2])
3-element Array{Int64,1}:
 1
 2
 3

Полностью реализовано в:

• Vector (также известен как одномерный Array)
• BitVector (также известен как одномерный BitArray)

Очередь с приоритетами

Тип PriorityQueue доступен из модуля Collections. Он предоставляет базовую реализацию очереди с приоритетами, позволяющую использовать произвольные типы ключей и приоритетов. Не допускаются несколько одинаковых ключей, но приоритет существующих ключей может быть эффективно изменён.

PriorityQueue(K, V[, ord])

Создать новую PriorityQueue с ключами типа K и значениями/приоритетами типа V. Если порядок не задан, очередь с приоритетами упорядочивается по возрастанию приоритетов, используя стандартное сравнение для V.

Очередь с приоритетами похожа на Dict, сопоставляющую значения с их приоритетами, с добавлением функции dequeue! для удаления элемента с наименьшим приоритетом.

julia> a = Base.Collections.PriorityQueue(["a","b","c"],[2,3,1],Base.Order.Forward)
Base.Collections.PriorityQueue{String,Int64,Base.Order.ForwardOrdering} with 3 entries:
  "c" => 1
  "b" => 3
  "a" => 2

enqueue!(pq, k, v)

Вставить ключ k в очередь с приоритетами pq с приоритетом v.

julia> a = Base.Collections.PriorityQueue(["a","b","c"],[2,3,1],Base.Order.Forward)
Base.Collections.PriorityQueue{String,Int64,Base.Order.ForwardOrdering} with 3 entries:
  "c" => 1
  "b" => 3
  "a" => 2

julia> Base.Collections.enqueue!(a, "d", 4)
Base.Collections.PriorityQueue{String,Int64,Base.Order.ForwardOrdering} with 4 entries:
  "c" => 1
  "b" => 3
  "a" => 2
  "d" => 4

dequeue!(pq)

Удалить и вернуть ключ с наименьшим приоритетом из очереди с приоритетами.

julia> a = Base.Collections.PriorityQueue(["a","b","c"],[2,3,1],Base.Order.Forward)
Base.Collections.PriorityQueue{String,Int64,Base.Order.ForwardOrdering} with 3 entries:
  "c" => 1
  "b" => 3
  "a" => 2

julia> Base.Collections.dequeue!(a)
"c"

julia> a
Base.Collections.PriorityQueue{String,Int64,Base.Order.ForwardOrdering} with 2 entries:
  "b" => 3
  "a" => 2

peek(pq)

Возвратить ключ с наименьшим приоритетом из очереди с приоритетами, не удаляя этот ключ из очереди.

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

julia> # Julia code
       pq = Collections.PriorityQueue();

julia> # Insert keys with associated priorities
       pq["a"] = 10; pq["b"] = 5; pq["c"] = 15; pq
Base.Collections.PriorityQueue{Any,Any,Base.Order.ForwardOrdering} with 3 entries:
  "c" => 15
  "b" => 5
  "a" => 10

julia> # Change the priority of an existing key
       pq["a"] = 0; pq
Base.Collections.PriorityQueue{Any,Any,Base.Order.ForwardOrdering} with 3 entries:
  "c" => 15
  "b" => 5
  "a" => 0

Функции кучи

Наряду с типом PriorityQueue, модуль Collections предоставляет функции низкого уровня для выполнения операций с бинарной кучей над массивами. Каждая функция принимает необязательный аргумент ordering. Если он не задан, используется порядок по умолчанию, поэтому элементы, извлечённые из кучи, упорядочиваются по возрастанию.

heapify(v, ord::Ordering=Forward)

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

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

julia> Base.Collections.heapify(a)
5-element Array{Int64,1}:
 1
 2
 4
 5
 3

julia> Base.Collections.heapify(a, Base.Order.Reverse)
5-element Array{Int64,1}:
 5
 3
 4
 1
 2

heapify!(v, ord::Ordering=Forward)

Встраивание heapify().

isheap(v, ord::Ordering=Forward)

Возвращает true если массив упорядочен как куча в соответствии с заданным порядком.

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

julia> Base.Collections.isheap(a,Base.Order.Forward)
true

julia> Base.Collections.isheap(a,Base.Order.Reverse)
false

heappush!(v, x[, ord])

Дано упорядоченное по бинарной куче массив, добавить новый элемент x, сохраняя свойство кучи. Для эффективности эта функция не проверяет, что массив действительно упорядочен по куче.

heappop!(v[, ord])

Дано упорядоченный по бинарной куче массив, удалить и вернуть элемент с наименьшим порядком. Для эффективности эта функция не проверяет, что массив действительно упорядочен по куче.