Массивы

Конструкторы и типы

Core.AbstractArrayТип

AbstractArray{T,N}

Супертип для многомерных массивов (или массивоподобных типов) с элементами типа T. Array и другие типы являются подтипами этого. См. раздел руководства по AbstractArray интерфейсу.

Base.AbstractVectorТип

AbstractVector{T}

Супертип для одномерных массивов (или массивоподобных типов) с элементами типа T. Псевдоним для AbstractArray{T,1}.

Base.AbstractMatrixТип

AbstractMatrix{T}

Супертип для двумерных массивов (или массивоподобных типов) с элементами типа T. Псевдоним для AbstractArray{T,2}.

Base.AbstractVecOrMatКонстанта

AbstractVecOrMat{T}

Объединение типов AbstractVector{T} и AbstractMatrix{T}.

Core.ArrayТип

Array{T,N} <: AbstractArray{T,N}

Многомерный плотный массив с элементами типа T.

Core.ArrayМетод

Array{T}(undef, dims)
Array{T,N}(undef, dims)

Создаёт неинициализированный многомерный Array с элементами типа T. N может быть явно указан, как в Array{T,N}(undef, dims), или определён длиной или количеством dims. dims может быть кортежем или серией целочисленных аргументов, соответствующих длинам каждой размерности. Если ранг N задаётся явно, он должен совпадать с длиной или числом dims. См. undef.

Примеры

julia> A = Array{Float64,2}(undef, 2, 3) # N given explicitly
2×3 Array{Float64,2}:
 6.90198e-310  6.90198e-310  6.90198e-310
 6.90198e-310  6.90198e-310  0.0

julia> B = Array{Float64}(undef, 2) # N determined by the input
2-element Array{Float64,1}:
 1.87103e-320
 0.0

Core.ArrayМетод

Array{T}(nothing, dims)
Array{T,N}(nothing, dims)

Создаёт многомерный Array с элементами типа T, инициализированный значениями nothing. Тип элементов T должен быть совместим с этими значениями, т.е. Nothing <: T.

Примеры

julia> Array{Union{Nothing, String}}(nothing, 2)
2-element Array{Union{Nothing, String},1}:
 nothing
 nothing

julia> Array{Union{Nothing, Int}}(nothing, 2, 3)
2×3 Array{Union{Nothing, Int64},2}:
 nothing  nothing  nothing
 nothing  nothing  nothing

Core.ArrayМетод

Array{T}(missing, dims)
Array{T,N}(missing, dims)

Создаёт многомерный Array с элементами типа T, инициализированный значениями missing. Тип элементов T должен быть совместим с этими значениями, т.е. Missing <: T.

Примеры

julia> Array{Union{Missing, String}}(missing, 2)
2-element Array{Union{Missing, String},1}:
 missing
 missing

julia> Array{Union{Missing, Int}}(missing, 2, 3)
2×3 Array{Union{Missing, Int64},2}:
 missing  missing  missing
 missing  missing  missing

Core.UndefInitializerТип

UndefInitializer

Тип-синглетон, используемый при инициализации массивов, указывающий, что вызывающий конструктор массива хочет неинициализированный массив. Также см. undef, псевдоним для UndefInitializer().

Примеры

julia> Array{Float64,1}(UndefInitializer(), 3)
3-element Array{Float64,1}:
 2.2752528595e-314
 2.202942107e-314
 2.275252907e-314

Core.undefКонстанта

undef

Псевдоним для UndefInitializer(), который создаёт экземпляр типа-синглетона UndefInitializer, используемого при инициализации массивов для указания желания неинициализированного массива.

Примеры

julia> Array{Float64,1}(undef, 3)
3-element Array{Float64,1}:
 2.2752528595e-314
 2.202942107e-314
 2.275252907e-314

Base.VectorТип

Vector{T} <: AbstractVector{T}

Одномерный плотный массив с элементами типа T, часто используемый для представления математического вектора. Псевдоним для Array{T,1}.

Base.VectorМетод

Vector{T}(undef, n)

Создаёт неинициализированный Vector{T} длины n. См. undef.

Примеры

julia> Vector{Float64}(undef, 3)
3-element Array{Float64,1}:
 6.90966e-310
 6.90966e-310
 6.90966e-310

Base.VectorМетод

Vector{T}(nothing, m)

Создаёт Vector{T} длины m, инициализированный значениями nothing. Тип элементов T должен быть совместим с этими значениями, т.е. Nothing <: T.

Примеры

julia> Vector{Union{Nothing, String}}(nothing, 2)
2-element Array{Union{Nothing, String},1}:
 nothing
 nothing

Base.VectorМетод

Vector{T}(missing, m)

Создаёт Vector{T} длины m, инициализированный значениями missing. Тип элементов T должен быть совместим с этими значениями, т.е. Missing <: T.

Примеры

julia> Vector{Union{Missing, String}}(missing, 2)
2-element Array{Union{Missing, String},1}:
 missing
 missing

Base.MatrixТип

Matrix{T} <: AbstractMatrix{T}

Двумерный плотный массив с элементами типа T, часто используемый для представления математической матрицы. Псевдоним для Array{T,2}.

Base.MatrixМетод

Matrix{T}(undef, m, n)

Создаёт неинициализированную Matrix{T} размера m×n. См. undef.

Примеры

julia> Matrix{Float64}(undef, 2, 3)
2×3 Array{Float64,2}:
 6.93517e-310  6.93517e-310  6.93517e-310
 6.93517e-310  6.93517e-310  1.29396e-320

Base.MatrixМетод

Matrix{T}(nothing, m, n)

Создаёт Matrix{T} размера m×n, инициализированный значениями nothing. Тип элементов T должен быть совместим с этими значениями, т.е. Nothing <: T.

Примеры

julia> Matrix{Union{Nothing, String}}(nothing, 2, 3)
2×3 Array{Union{Nothing, String},2}:
 nothing  nothing  nothing
 nothing  nothing  nothing

Base.MatrixМетод

Matrix{T}(missing, m, n)

Создаёт Matrix{T} размера m×n, инициализированный значениями missing. Тип элементов T должен быть совместим с этими значениями, т.е. Missing <: T.

Примеры

julia> Matrix{Union{Missing, String}}(missing, 2, 3)
2×3 Array{Union{Missing, String},2}:
 missing  missing  missing
 missing  missing  missing

Base.VecOrMatКонстанта

VecOrMat{T}

Объединение типов Vector{T} и Matrix{T}.

Core.DenseArrayТип

DenseArray{T, N} <: AbstractArray{T,N}

Многомерный плотный массив с элементами типа T. Элементы плотного массива хранятся смежно в памяти.

Base.DenseVectorТип

DenseVector{T}

Одномерный DenseArray с элементами типа T. Псевдоним для DenseArray{T,1}.

Base.DenseMatrixТип

DenseMatrix{T}

Двумерный DenseArray с элементами типа T. Псевдоним для DenseArray{T,2}.

Base.DenseVecOrMatКонстанта

DenseVecOrMat{T}

Объединение типов DenseVector{T} и DenseMatrix{T}.

Base.StridedArrayКонстанта

StridedArray{T, N}

N-мерный шагированный массив с элементами типа T. Эти массивы следуют интерфейсу шагированных массивов. Если A является StridedArray, то его элементы хранятся в памяти со смещениями, которые могут меняться между измерениями, но остаются постоянными в пределах измерения. Например, A может иметь шаг 2 в измерении 1 и шаг 3 в измерении 2. Увеличение A по измерению d переходит в памяти на [strides(A, d)] ячеек. Шагированные массивы особенно важны и полезны, поскольку их иногда можно напрямую передавать в качестве указателей внешним библиотекам, таким как BLAS.

Base.StridedVectorКонстанта

StridedVector{T}

Одномерный StridedArray с элементами типа T.

Base.StridedMatrixКонстанта

StridedMatrix{T}

Двумерный StridedArray с элементами типа T.

Base.StridedVecOrMatКонстанта

StridedVecOrMat{T}

Объединение типов StridedVector и StridedMatrix с элементами типа T.

Base.getindexМетод

getindex(type[, elements...])

Создает одномерный массив заданного типа. Обычно вызывается со синтаксисом Type[]. Значения элементов могут быть указаны с помощью Type[a,b,c,...].

Примеры

julia> Int8[1, 2, 3]
3-element Array{Int8,1}:
 1
 2
 3

julia> getindex(Int8, 1, 2, 3)
3-element Array{Int8,1}:
 1
 2
 3

Base.zerosФункция

zeros([T=Float64,] dims...)

Создаёт Array, с типом элементов T, заполненный нулями размером, указанным dims. См. также fill, ones.

Примеры

julia> zeros(1)
1-element Array{Float64,1}:
 0.0

julia> zeros(Int8, 2, 3)
2×3 Array{Int8,2}:
 0  0  0
 0  0  0

Base.onesФункция

ones([T=Float64,] dims...)

Создаёт Array, с типом элементов T, заполненный единицами размером, указанным dims. См. также: fill, zeros.

Примеры

julia> ones(1,2)
1×2 Array{Float64,2}:
 1.0  1.0

julia> ones(ComplexF64, 2, 3)
2×3 Array{Complex{Float64},2}:
 1.0+0.0im  1.0+0.0im  1.0+0.0im
 1.0+0.0im  1.0+0.0im  1.0+0.0im

Base.BitArrayТип

BitArray{N} <: AbstractArray{Bool, N}

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

BitArray упаковывают до 64 значений в каждые 8 байт, что приводит к 8-кратному повышению эффективности по сравнению с Array{Bool, N} и позволяет некоторым операциям работать сразу с 64 значениями.

По умолчанию Julia возвращает BitArrays от операций векторизации, генерирующих булевы элементы (включая точечные сравнения, например, .==) а также от функций trues и falses.

Base.BitArrayМетод

BitArray(undef, dims::Integer...)
BitArray{N}(undef, dims::NTuple{N,Int})

Создает незаданный BitArray с заданными измерениями. Ведёт себя идентично конструктору Array. См. undef.

Примеры

julia> BitArray(undef, 2, 2)
2×2 BitArray{2}:
 false  false
 false  true

julia> BitArray(undef, (3, 1))
3×1 BitArray{2}:
 false
 true
 false

Base.BitArrayМетод

BitArray(itr)

Создаёт BitArray на основе переданного объекта итерации. Форма определяется из объекта itr.

Примеры

julia> BitArray([1 0; 0 1])
2×2 BitArray{2}:
 1  0
 0  1

julia> BitArray(x+y == 3 for x = 1:2, y = 1:3)
2×3 BitArray{2}:
 0  1  0
 1  0  0

julia> BitArray(x+y == 3 for x = 1:2 for y = 1:3)
6-element BitArray{1}:
 0
 1
 0
 1
 0
 0

Base.truesФункция

trues(dims)

Создаёт BitArray со всеми значениями true.

Примеры

julia> trues(2,3)
2×3 BitArray{2}:
 1  1  1
 1  1  1

Base.falsesФункция

falses(dims)

Создаёт BitArray со всеми значениями false.

Примеры

julia> falses(2,3)
2×3 BitArray{2}:
 0  0  0
 0  0  0

Base.fillФункция

fill(x, dims)

Создаёт массив, заполненный значением x. Например, fill(1.0, (5,5)) возвращает 5×5 массив с плавающей точкой, где каждый элемент инициализирован 1.0.

Примеры

julia> fill(1.0, (5,5))
5×5 Array{Float64,2}:
 1.0  1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0  1.0

Если x — ссылка на объект, все элементы будут ссылаться на тот же объект. fill(Foo(), dims) вернёт массив, заполненный результатом вычисления Foo() один раз.

Base.fill!Функция

fill!(A, x)

Заполняет массив A значением x. Если x — ссылка на объект, все элементы будут ссылаться на тот же объект. fill!(A, Foo()) вернёт A заполненный результатом вычисления Foo() один раз.

Примеры

julia> A = zeros(2,3)
2×3 Array{Float64,2}:
 0.0  0.0  0.0
 0.0  0.0  0.0

julia> fill!(A, 2.)
2×3 Array{Float64,2}:
 2.0  2.0  2.0
 2.0  2.0  2.0

julia> a = [1, 1, 1]; A = fill!(Vector{Vector{Int}}(undef, 3), a); a[1] = 2; A
3-element Array{Array{Int64,1},1}:
 [2, 1, 1]
 [2, 1, 1]
 [2, 1, 1]

julia> x = 0; f() = (global x += 1; x); fill!(Vector{Int}(undef, 3), f())
3-element Array{Int64,1}:
 1
 1
 1

Base.similarФункция

similar(array, [element_type=eltype(array)], [dims=size(array)])

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

Подтипы AbstractArray могут выбрать, какой тип массива лучше всего подходит для заданного типа элемента и размерности. Если они не специализируют этот метод, по умолчанию используется Array{element_type}(undef, dims...).

Например, similar(1:10, 1, 4) возвращает неинициализированный Array{Int,2}, так как диапазоны не изменяемы и не поддерживают 2 измерения:

julia> similar(1:10, 1, 4)
1×4 Array{Int64,2}:
 4419743872  4374413872  4419743888  0

В противоположность этому, similar(trues(10,10), 2) возвращает неинициализированный BitVector с двумя элементами, поскольку BitArray оба изменяемые и могут поддерживать одномерные массивы:

julia> similar(trues(10,10), 2)
2-element BitArray{1}:
 0
 0

Так как BitArray могут хранить только элементы типа Bool, однако, если вы запрашиваете другой тип элементов, он создаст обычный Array вместо этого:

julia> similar(falses(10), Float64, 2, 4)
2×4 Array{Float64,2}:
 2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314
 2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314

similar(storagetype, axes)

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

Примеры:

similar(Array{Int}, axes(A))

создаёт массив, который «ведёт себя как» Array{Int} (и, возможно, на самом деле им поддерживается), но индексируется идентично A. Если A имеет стандартную индексацию, это будет идентично Array{Int}(undef, size(A)), но если A имеет нестандартную индексацию, то индексы результата будут соответствовать A.

similar(BitArray, (axes(A, 2),))

создаст одномерный логический массив, индексы которого соответствуют столбцам A.

Основные функции

Base.ndimsФункция

ndims(A::AbstractArray) -> Integer

Возвращает количество измерений A.

Примеры

julia> A = fill(1, (3,4,5));

julia> ndims(A)
3

Base.sizeФункция

size(A::AbstractArray, [dim])

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

Обратите внимание, что size может быть не определён для массивов с нестандартной индексацией, в этом случае может быть полезно axes. См. главу руководства по массивам с пользовательскими индексами.

Примеры

julia> A = fill(1, (2,3,4));

julia> size(A)
(2, 3, 4)

julia> size(A, 2)
3

Base.axesМетод

axes(A)

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

Примеры

julia> A = fill(1, (5,6,7));

julia> axes(A)
(Base.OneTo(5), Base.OneTo(6), Base.OneTo(7))

Base.axesМетод

axes(A, d)

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

См. также size и главу руководства по массивам с пользовательскими индексами.

Примеры

julia> A = fill(1, (5,6,7));

julia> axes(A, 2)
Base.OneTo(6)

Base.lengthМетод

length(A::AbstractArray)

Возвращает количество элементов в массиве, по умолчанию prod(size(A)).

Примеры

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

julia> length([1 2; 3 4])
4

Base.eachindexФункция

eachindex(A...)

Создаёт итерируемый объект для посещения каждого индекса AbstractArray A эффективным способом. Для типов массивов, которые выбрали быструю линейную индексацию (например, Array), это просто диапазон 1:length(A). Для других типов массивов возвращается специализированный декартов диапазон для эффективной индексации массива с индексами, заданными для каждой размерности. Для других итерируемых объектов, включая строки и словари, возвращается объект-итератор, поддерживающий произвольные типы индексов (например, неравномерные или нецелочисленные индексы).

Если вы предоставляете более одного AbstractArray аргумента, eachindex создаст итерируемый объект, который будет быстрым для всех аргументов (диапазон UnitRange, если у всех входных данных есть быстрая линейная индексация, в противном случае - CartesianIndices). Если массивы имеют разные размеры и/или размерности, eachindex вернёт итерируемый объект, охватывающий максимальный диапазон по каждой размерности.

Примеры

julia> A = [1 2; 3 4];

julia> for i in eachindex(A) # linear indexing
           println(i)
       end
1
2
3
4

julia> for i in eachindex(view(A, 1:2, 1:1)) # Cartesian indexing
           println(i)
       end
CartesianIndex(1, 1)
CartesianIndex(2, 1)

Base.IndexStyleТип

IndexStyle(A)
IndexStyle(typeof(A))

IndexStyle определяет «родной стиль индексации» для массива A. При определении нового типа AbstractArray можно реализовать линейную индексацию (с IndexLinear) или декартову индексацию. Если вы решите реализовать линейную индексацию, то вы должны установить этот признак для вашего типа массива:

Base.IndexStyle(::Type{<:MyArray}) = IndexLinear()

По умолчанию используется IndexCartesian().

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

Если вы определите оба стиля индексации для вашего AbstractArray, этот признак можно использовать для выбора наиболее производительного стиля индексации. Некоторые методы проверяют этот признак на своих входах и применяют различные алгоритмы в зависимости от наиболее эффективного способа доступа. В частности, eachindex создаёт итератор, тип которого зависит от значения этого признака.

Base.IndexLinearТип

IndexLinear()

Подтип IndexStyle, используемый для описания массивов, которые оптимально индексируются одним линейным индексом.

Стиль линейной индексации использует одно целое число для описания позиции в массиве (даже если это многомерный массив), используется строка «столбец-major» для доступа к элементам. Например, если A был типом пользовательской матрицы (2, 3) с линейной индексацией, и мы ссылались на A[5] (используя линейный стиль), это было бы эквивалентно ссылке на A[1, 3] (так как 2*1 + 3 = 5). См. также IndexCartesian.

Base.IndexCartesianТип

IndexCartesian()

Подтип IndexStyle, используемый для описания массивов, которые оптимально индексируются декартовым индексом.

Стиль декартовой индексации использует несколько целых чисел/индексов для описания позиции в массиве. Например, если A была пользовательской матрицей типа (2, 3, 4) с декартовой индексацией, мы могли бы сослаться на A[2, 1, 3], и Julia автоматически преобразует это в правильное место в базовой памяти. См. также IndexLinear.

Base.conj!Функция

conj!(A)

Преобразует массив в его комплексно-сопряжённый вид на месте.

См. также conj.

Примеры

julia> A = [1+im 2-im; 2+2im 3+im]
2×2 Array{Complex{Int64},2}:
 1+1im  2-1im
 2+2im  3+1im

julia> conj!(A);

julia> A
2×2 Array{Complex{Int64},2}:
 1-1im  2+1im
 2-2im  3-1im

Base.strideФункция

stride(A, k::Integer)

Возвращает расстояние в памяти (в количестве элементов) между соседними элементами по размерности k.

Примеры

julia> A = fill(1, (3,4,5));

julia> stride(A,2)
3

julia> stride(A,3)
12

Base.stridesФункция

strides(A)

Возвращает кортеж смещений в памяти по каждой размерности.

Примеры

julia> A = fill(1, (3,4,5));

julia> strides(A)
(1, 3, 12)

Трансляция и векторизация

См. также символ точки для векторизации функций; например, f.(args...) неявно вызывает broadcast(f, args...). Вместо того, чтобы полагаться на «векторизованные» методы функций, таких как sin для работы с массивами, следует использовать sin.(a) для векторизации с помощью broadcast.

Base.Broadcast.broadcastФункция

broadcast(f, As...)

Транслирует функцию f по массивам, кортежам, коллекциям, Ref и/или скалярам As.

Трансляция применяет функцию f к элементам контейнерных аргументов и самим скалярам в As. Одноэлементные и отсутствующие размерности расширяются до соответствия размерам других аргументов путём виртуального повторения значения. По умолчанию только ограниченное число типов рассматриваются как скаляры, включая Numberы, Stringы, Symbolы, Typeы, Functionы и некоторые общие единичные значения, такие как missing и nothing. Все остальные аргументы итерируются или индексируются по элементам.

Тип результирующего контейнера определяется следующими правилами:

• Если все аргументы являются скалярами или нульмерными массивами, то возвращается необработанный скаляр.
• Если хотя бы один аргумент является кортежем, а все остальные — скалярами или нульмерными массивами, то возвращается кортеж.
• Все остальные комбинации аргументов по умолчанию возвращают Array, но пользовательские типы контейнеров могут определить собственную реализацию и правила повышения, чтобы настроить результат, когда они появляются в качестве аргументов.

Существует специальный синтаксис для трансляции: f.(args...) эквивалентно broadcast(f, args...), а вложенные f.(g.(args...)) вызовы объединяются в один цикл трансляции.

Примеры

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

julia> B = [1 2; 3 4; 5 6; 7 8; 9 10]
5×2 Array{Int64,2}:
 1   2
 3   4
 5   6
 7   8
 9  10

julia> broadcast(+, A, B)
5×2 Array{Int64,2}:
  2   3
  5   6
  8   9
 11  12
 14  15

julia> parse.(Int, ["1", "2"])
2-element Array{Int64,1}:
 1
 2

julia> abs.((1, -2))
(1, 2)

julia> broadcast(+, 1.0, (0, -2.0))
(1.0, -1.0)

julia> (+).([[0,2], [1,3]], Ref{Vector{Int}}([1,-1]))
2-element Array{Array{Int64,1},1}:
 [1, 1]
 [2, 2]

julia> string.(("one","two","three","four"), ": ", 1:4)
4-element Array{String,1}:
 "one: 1"
 "two: 2"
 "three: 3"
 "four: 4"

Base.Broadcast.broadcast!Функция

broadcast!(f, dest, As...)

Подобно broadcast, но хранит результат broadcast(f, As...) в массиве dest. Обратите внимание, что dest используется только для хранения результата и не предоставляет аргументы f, если они не указаны также в As, как в broadcast!(f, A, A, B) для выполнения A[:] = broadcast(f, A, B).

Примеры

julia> A = [1.0; 0.0]; B = [0.0; 0.0];

julia> broadcast!(+, B, A, (0, -2.0));

julia> B
2-element Array{Float64,1}:
  1.0
 -2.0

julia> A
2-element Array{Float64,1}:
 1.0
 0.0

julia> broadcast!(+, A, A, (0, -2.0));

julia> A
2-element Array{Float64,1}:
  1.0
 -2.0

Base.Broadcast.@__dot__Макрос

@. expr

Преобразует каждый вызов функции или оператор в expr в "вызов с точкой" (например, преобразовать f(x) в f.(x)) и каждый оператор присваивания в expr в "присваивание с точкой" (например, преобразовать += в .+=).

Если вы хотите избежать добавления точек для определённых вызовов функций в expr, вставьте эти вызовы с помощью $. Например, @. sqrt(abs($sort(x))) эквивалентно sqrt.(abs.(sort(x))) (без точки для sort).

(@. эквивалентно вызову @__dot__.)

Примеры

julia> x = 1.0:3.0; y = similar(x);

julia> @. y = x + 3 * sin(x)
3-element Array{Float64,1}:
 3.5244129544236893
 4.727892280477045
 3.4233600241796016

Для специализации трансляции на пользовательских типах см.

Base.Broadcast.BroadcastStyleТип

BroadcastStyle — абстрактный тип и функция-аттрибут, используемая для определения поведения объектов при трансляции. BroadcastStyle(typeof(x)) возвращает стиль, связанный с x.

Чтобы настроить поведение трансляции типа, можно объявить стиль, определив пару тип/метод

struct MyContainerStyle <: BroadcastStyle end
Base.BroadcastStyle(::Type{<:MyContainer}) = MyContainerStyle()

Затем вы пишете метод(ы) (по крайней мере, similar) для работы с Broadcasted{MyContainerStyle}.

Также существует несколько предопределённых подтипов BroadcastStyle, которые вы можете использовать; см. главу «Интерфейсы» для получения дополнительной информации.

Base.Broadcast.AbstractArrayStyleТип

Broadcast.AbstractArrayStyle{N} <: BroadcastStyle — абстрактный супертип для любого стиля, связанного с типом AbstractArray.

Параметр N — размерность, что может быть полезно для типов AbstractArray, которые поддерживают только определённые размерности:

struct SparseMatrixStyle <: Broadcast.AbstractArrayStyle{2} end
Base.BroadcastStyle(::Type{<:SparseMatrixCSC}) = SparseMatrixStyle()

Для типов AbstractArray, которые поддерживают произвольную размерность, N можно установить в Any:

struct MyArrayStyle <: Broadcast.AbstractArrayStyle{Any} end
Base.BroadcastStyle(::Type{<:MyArray}) = MyArrayStyle()

В случаях, когда вы хотите иметь возможность смешивать несколько AbstractArrayStyle и отслеживать размерность, ваш стиль должен поддерживать конструктор Val:

struct MyArrayStyleDim{N} <: Broadcast.AbstractArrayStyle{N} end
(::Type{<:MyArrayStyleDim})(::Val{N}) where N = MyArrayStyleDim{N}()

Обратите внимание, что если два или более подтипа AbstractArrayStyle конфликтуют, механизм трансляции будет использовать Array в качестве результата. Если этого нежелательно, вам может потребоваться определить двоичные правила трансляции BroadcastStyle для управления типом вывода.

См. также Broadcast.DefaultArrayStyle.

Base.Broadcast.ArrayStyleТип

Broadcast.ArrayStyle{MyArrayType}() — BroadcastStyle, указывающий, что объект ведёт себя как массив при трансляции. Он предоставляет простой способ построения Broadcast.AbstractArrayStyle для конкретных типов контейнеров. При этом стили трансляции, созданные таким образом, теряют отслеживание размерности; если отслеживание важно для вашего типа, вы должны создать свой собственный пользовательский Broadcast.AbstractArrayStyle.

Base.Broadcast.DefaultArrayStyleТип

Broadcast.DefaultArrayStyle{N}() — BroadcastStyle, указывающий, что объект ведёт себя как N-мерный массив при трансляции. В частности, DefaultArrayStyle используется для любого типа AbstractArray, который не определил специализированный стиль, и при отсутствии переопределений от других аргументов broadcast, результирующий тип вывода — Array. Когда есть несколько входных значений для broadcast, DefaultArrayStyle уступает любому другому Broadcast.ArrayStyle.

Base.Broadcast.broadcastableФункция

Broadcast.broadcastable(x)

Возвращает либо x, либо объект, подобный x, так что он поддерживает axes, индексирование, и его тип поддерживает ndims.

Если x поддерживает итерацию, возвращаемое значение должно иметь то же самое поведение итерации и индексирования, что и collect(x).

Если x не является AbstractArray, но поддерживает итерацию, индексирование, и его тип поддерживает ndims, то broadcastable(::typeof(x)) может быть реализовано так, чтобы просто возвращать себя.

Кроме того, если x определяет собственный BroadcastStyle, то он должен определить метод broadcastable для возврата себя, чтобы пользовательский стиль имел какой-либо эффект.

Примеры

julia> Broadcast.broadcastable([1,2,3]) # like `identity` since arrays already support axes and indexing
3-element Array{Int64,1}:
 1
 2
 3

julia> Broadcast.broadcastable(Int) # Types don't support axes, indexing, or iteration but are commonly used as scalars
Base.RefValue{Type{Int64}}(Int64)

julia> Broadcast.broadcastable("hello") # Strings break convention of matching iteration and act like a scalar instead
Base.RefValue{String}("hello")

Base.Broadcast.combine_axesФункция

combine_axes(As...) -> Tuple

Определяет оси результата для трансляции по всем значениям в As.

julia> Broadcast.combine_axes([1], [1 2; 3 4; 5 6])
(Base.OneTo(3), Base.OneTo(2))

julia> Broadcast.combine_axes(1, 1, 1)
()

Base.Broadcast.combine_stylesФункция

combine_styles(cs...) -> BroadcastStyle

Определяет, какой BroadcastStyle использовать для любого количества аргументов-значений. Использует BroadcastStyle для получения стиля каждого аргумента и result_style для объединения стилей.

Примеры

julia> Broadcast.combine_styles([1], [1 2; 3 4])
Base.Broadcast.DefaultArrayStyle{2}()

Base.Broadcast.result_styleФункция

result_style(s1::BroadcastStyle[, s2::BroadcastStyle]) -> BroadcastStyle

Принимает один или два BroadcastStyle и объединяет их с помощью BroadcastStyle для определения общего BroadcastStyle.

Примеры

julia> Broadcast.result_style(Broadcast.DefaultArrayStyle{0}(), Broadcast.DefaultArrayStyle{3}())
Base.Broadcast.DefaultArrayStyle{3}()

julia> Broadcast.result_style(Broadcast.Unknown(), Broadcast.DefaultArrayStyle{1}())
Base.Broadcast.DefaultArrayStyle{1}()

Индексирование и присваивание

Base.getindexМетод

getindex(A, inds...)

Возвращает подмножество массива A в соответствии с inds, где каждый ind может быть Int, AbstractRange или Vector. Подробности см. в разделе документации по индексированию массивов.

Примеры

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

julia> getindex(A, 1)
1

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

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

Base.setindex!Метод

setindex!(A, X, inds...)
A[inds...] = X

Хранит значения из массива X в подмножестве A в соответствии с inds. Синтаксис A[inds...] = X эквивалентен setindex!(A, X, inds...).

Примеры

julia> A = zeros(2,2);

julia> setindex!(A, [10, 20], [1, 2]);

julia> A[[3, 4]] = [30, 40];

julia> A
2×2 Array{Float64,2}:
 10.0  30.0
 20.0  40.0

Base.copyto!Метод

copyto!(dest, Rdest::CartesianIndices, src, Rsrc::CartesianIndices) -> dest

Скопируйте блок src в диапазоне Rsrc до блока dest в диапазоне Rdest. Размеры двух областей должны совпадать.

Base.isassignedФункция

isassigned(array, i) -> Bool

Проверьте, содержит ли заданный массив значение, связанное с индексом i. Верните false, если индекс выходит за пределы границ или имеет неопределённую ссылку.

Примеры

julia> isassigned(rand(3, 3), 5)
true

julia> isassigned(rand(3, 3), 3 * 3 + 1)
false

julia> mutable struct Foo end

julia> v = similar(rand(3), Foo)
3-element Array{Foo,1}:
 #undef
 #undef
 #undef

julia> isassigned(v, 1)
false

Base.ColonТип

Colon()

Двоеточия (:) используются для обозначения индексирования целых объектов или измерений сразу.

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

Также одиночный экземпляр Colon является функцией, используемой для построения диапазонов; см. :.

Base.IteratorsMD.CartesianIndexТип

CartesianIndex(i, j, k...)   -> I
CartesianIndex((i, j, k...)) -> I

Создайте многомерный индекс I, который можно использовать для индексирования многомерного массива A. В частности, A[I] эквивалентно A[i,j,k...]. Можно свободно смешивать целочисленные и CartesianIndex индексы; например, A[Ipre, i, Ipost] (где Ipre и Ipost являются CartesianIndex индексами, а i — Int) может быть полезным выражением при написании алгоритмов, работающих вдоль одного измерения массива произвольной размерности.

CartesianIndex иногда генерируется функцией eachindex, и всегда при итерации с явным CartesianIndices.

Примеры

julia> A = reshape(Vector(1:16), (2, 2, 2, 2))
2×2×2×2 Array{Int64,4}:
[:, :, 1, 1] =
 1  3
 2  4

[:, :, 2, 1] =
 5  7
 6  8

[:, :, 1, 2] =
  9  11
 10  12

[:, :, 2, 2] =
 13  15
 14  16

julia> A[CartesianIndex((1, 1, 1, 1))]
1

julia> A[CartesianIndex((1, 1, 1, 2))]
9

julia> A[CartesianIndex((1, 1, 2, 1))]
5

Base.IteratorsMD.CartesianIndicesТип

CartesianIndices(sz::Dims) -> R
CartesianIndices((istart:istop, jstart:jstop, ...)) -> R

Определите область R, охватывающую многомерный прямоугольный диапазон целочисленных индексов. Они чаще всего встречаются в контексте итерации, где for I in R ... end вернёт CartesianIndex индексы I, эквивалентные вложенным циклам

for j = jstart:jstop
    for i = istart:istop
        ...
    end
end

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

CartesianIndices(A::AbstractArray) -> R

Для удобства, создание CartesianIndices из массива создаёт диапазон его индексов.

Примеры

julia> foreach(println, CartesianIndices((2, 2, 2)))
CartesianIndex(1, 1, 1)
CartesianIndex(2, 1, 1)
CartesianIndex(1, 2, 1)
CartesianIndex(2, 2, 1)
CartesianIndex(1, 1, 2)
CartesianIndex(2, 1, 2)
CartesianIndex(1, 2, 2)
CartesianIndex(2, 2, 2)

julia> CartesianIndices(fill(1, (2,3)))
2×3 CartesianIndices{2,Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)  CartesianIndex(1, 3)
 CartesianIndex(2, 1)  CartesianIndex(2, 2)  CartesianIndex(2, 3)

Преобразование между линейными и декартовыми индексами

Преобразование линейного индекса в декартов индекс использует тот факт, что CartesianIndices является AbstractArray и может быть индексирован линейно:

julia> cartesian = CartesianIndices((1:3, 1:2))
3×2 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)
 CartesianIndex(2, 1)  CartesianIndex(2, 2)
 CartesianIndex(3, 1)  CartesianIndex(3, 2)

julia> cartesian[4]
CartesianIndex(1, 2)

Трансляция

CartesianIndices поддерживает трансляцию арифметических операций (+ и -) с CartesianIndex.

julia> CIs = CartesianIndices((2:3, 5:6))
2×2 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
 CartesianIndex(2, 5)  CartesianIndex(2, 6)
 CartesianIndex(3, 5)  CartesianIndex(3, 6)

julia> CI = CartesianIndex(3, 4)
CartesianIndex(3, 4)

julia> CIs .+ CI
2×2 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
 CartesianIndex(5, 9)  CartesianIndex(5, 10)
 CartesianIndex(6, 9)  CartesianIndex(6, 10)

Для преобразования декартовых индексов в линейные см. LinearIndices.

Base.DimsТип

Dims{N}

Массив NTuple N Int используется для представления измерений AbstractArray.

Base.LinearIndicesТип

LinearIndices(A::AbstractArray)

Возвращает массив LinearIndices с той же формой и axes, что и у A, содержащий линейный индекс каждой записи в A. Индексирование этого массива декартовыми индексами позволяет сопоставлять их с линейными индексами.

Для массивов с обычным индексированием (индексы начинаются с 1) или любого многомерного массива линейные индексы варьируются от 1 до length(A). Однако для AbstractVector линейные индексы axes(A, 1), и поэтому не начинаются с 1 для векторов с нестандартным индексированием.

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

Примеры

julia> A = fill(1, (5,6,7));

julia> b = LinearIndices(A);

julia> extrema(b)
(1, 210)

LinearIndices(inds::CartesianIndices) -> R
LinearIndices(sz::Dims) -> R
LinearIndices((istart:istop, jstart:jstop, ...)) -> R

Возвращает массив LinearIndices с заданной формой или axes.

Пример

Основное назначение этого конструктора — интуитивное преобразование декартовых индексов в линейные:

julia> linear = LinearIndices((1:3, 1:2))
3×2 LinearIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
 1  4
 2  5
 3  6

julia> linear[1,2]
4

Base.to_indicesФункция

to_indices(A, I::Tuple)

Преобразуйте кортеж I в кортеж индексов для использования при индексировании массива A.

Возвращаемый кортеж должен содержать только Int или AbstractArray скалярных индексов, которые поддерживаются массивом A. При встрече нового типа индекса, который он не знает, как обработать, произойдёт ошибка.

Для простых типов индексов используется недокументированная функция Base.to_index(A, i) для обработки каждого индекса i. Хотя эта внутренняя функция не предназначена для прямого вызова, Base.to_index может быть расширена настраиваемыми типами массивов или индексов для предоставления настраиваемых правил индексирования.

Более сложные типы индексов могут потребовать больше контекста о том измерении, в котором они индексируются. Для поддержки таких случаев to_indices(A, I) вызывает to_indices(A, axes(A), I), который затем рекурсивно проходит по кортежу заданных индексов и индексам измерений массива A совместно. Таким образом, не все типы индексов гарантировано распространяются на Base.to_index.

Base.checkboundsФункция

checkbounds(Bool, A, I...)

Возвращает true, если указанные индексы I находятся в пределах границ для данного массива A. Подтипы AbstractArray должны специализировать этот метод, если им нужно обеспечить настраиваемые правила проверки границ; однако во многих случаях можно полагаться на индексы A и checkindex.

См. также checkindex.

Примеры

julia> A = rand(3, 3);

julia> checkbounds(Bool, A, 2)
true

julia> checkbounds(Bool, A, 3, 4)
false

julia> checkbounds(Bool, A, 1:3)
true

julia> checkbounds(Bool, A, 1:3, 2:4)
false

checkbounds(A, I...)

Выбрасывает ошибку, если указанные индексы I не находятся в пределах границ для данного массива A.

Base.checkindexФункция

checkindex(Bool, inds::AbstractUnitRange, index)

Возвращает true, если данный index находится в пределах границ inds.

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

Примеры

julia> checkindex(Bool, 1:20, 8)
true

julia> checkindex(Bool, 1:20, 21)
false

Просмотры (SubArrays и другие типы просмотров)

Base.viewФункция

view(A, inds...)

Подобно getindex, но возвращает просмотр родительского массива A с заданными индексами вместо создания копии. Вызов getindex или setindex! на возвращаемом SubArray вычисляет индексы родительского массива на лету без проверки границ.

Примеры

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

julia> b = view(A, :, 1)
2-element view(::Array{Int64,2}, :, 1) with eltype Int64:
 1
 3

julia> fill!(b, 0)
2-element view(::Array{Int64,2}, :, 1) with eltype Int64:
 0
 0

julia> A # Note A has changed even though we modified b
2×2 Array{Int64,2}:
 0  2
 0  4

Base.@viewМакрос

@view A[inds...]

Создаёт просмотр SubArray из выражения индексирования. Это можно применить только напрямую к выражению ссылки (например, @view A[1,2:end]), и не следует использовать в качестве целевого выражения присваивания (например, @view(A[1,2:end]) = ...). Также см. @views для переключения всего блока кода на использование просмотров для срезов.

Примеры

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

julia> b = @view A[:, 1]
2-element view(::Array{Int64,2}, :, 1) with eltype Int64:
 1
 3

julia> fill!(b, 0)
2-element view(::Array{Int64,2}, :, 1) with eltype Int64:
 0
 0

julia> A
2×2 Array{Int64,2}:
 0  2
 0  4

Base.@viewsМакрос

@views expression

Преобразуйте каждую операцию среза массива в данном выражении (которое может быть блоком begin/end, циклом, функцией и т. д.) для возвращения представления. Скалярные индексы, не массивоподобные типы и явные вызовы getindex (в отличие от array[...]) не затрагиваются.

Примеры

julia> A = zeros(3, 3);

julia> @views for row in 1:3
           b = A[row, :]
           b[:] .= row
       end

julia> A
3×3 Array{Float64,2}:
 1.0  1.0  1.0
 2.0  2.0  2.0
 3.0  3.0  3.0

Base.parentФункция

parent(A)

Возвращает «родительский массив» типа представления массива (например, SubArray), или сам массив, если он не является представлением.

Примеры

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

julia> V = view(A, 1:2, :)
2×2 view(::Array{Int64,2}, 1:2, :) with eltype Int64:
 1  2
 3  4

julia> parent(V)
2×2 Array{Int64,2}:
 1  2
 3  4

Base.parentindicesФункция

parentindices(A)

Возвращает индексы в parent, которые соответствуют представлению массива A.

Примеры

julia> A = [1 2; 3 4];

julia> V = view(A, 1, :)
2-element view(::Array{Int64,2}, 1, :) with eltype Int64:
 1
 2

julia> parentindices(V)
(1, Base.Slice(Base.OneTo(2)))

Base.selectdimФункция

selectdim(A, d::Integer, i)

Возвращает представление всех данных A , где индекс для измерения d равен i.

Эквивалентно view(A,:,:,...,i,:,:,...), где i находится в позиции d.

Примеры

julia> A = [1 2 3 4; 5 6 7 8]
2×4 Array{Int64,2}:
 1  2  3  4
 5  6  7  8

julia> selectdim(A, 2, 3)
2-element view(::Array{Int64,2}, :, 3) with eltype Int64:
 3
 7

Base.reinterpretФункция

reinterpret(type, A)

Изменяет интерпретацию типа блока памяти. Для массивов это создает представление массива с теми же двоичными данными, что и заданный массив, но с указанным типом элемента. Например, reinterpret(Float32, UInt32(7)) интерпретирует 4 байта, соответствующие UInt32(7) , как Float32.

Примеры

julia> reinterpret(Float32, UInt32(7))
1.0f-44

julia> reinterpret(Float32, UInt32[1 2 3 4 5])
1×5 reinterpret(Float32, ::Array{UInt32,2}):
 1.4013e-45  2.8026e-45  4.2039e-45  5.60519e-45  7.00649e-45

Base.reshapeФункция

reshape(A, dims...) -> AbstractArray
reshape(A, dims) -> AbstractArray

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

Новые размеры могут быть указаны либо как список аргументов, либо как кортеж формы. Максимально одно измерение может быть указано с помощью :, в этом случае его длина вычисляется так, чтобы его произведение со всеми указанными измерениями было равно длине исходного массива A . Общее количество элементов не должно меняться.

Примеры

julia> A = Vector(1:16)
16-element Array{Int64,1}:
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16

julia> reshape(A, (4, 4))
4×4 Array{Int64,2}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> reshape(A, 2, :)
2×8 Array{Int64,2}:
 1  3  5  7   9  11  13  15
 2  4  6  8  10  12  14  16

julia> reshape(1:6, 2, 3)
2×3 reshape(::UnitRange{Int64}, 2, 3) with eltype Int64:
 1  3  5
 2  4  6

Base.dropdimsФункция

dropdims(A; dims)

Удаляет измерения, указанные dims , из массива A. Элементы dims должны быть уникальными и находиться в диапазоне 1:ndims(A) . size(A,i) должен быть равен 1 для всех i в dims.

Примеры

julia> a = reshape(Vector(1:4),(2,2,1,1))
2×2×1×1 Array{Int64,4}:
[:, :, 1, 1] =
 1  3
 2  4

julia> dropdims(a; dims=3)
2×2×1 Array{Int64,3}:
[:, :, 1] =
 1  3
 2  4

Base.vecФункция

vec(a::AbstractArray) -> AbstractVector

Изменяет форму массива a в одномерный столбец-вектор. Возвращает a , если он уже является AbstractVector . Результирующий массив разделяет те же исходные данные, что и a, поэтому он будет изменяемым только тогда, когда a изменяемый, в противном случае изменение одного также изменит другой.

Примеры

julia> a = [1 2 3; 4 5 6]
2×3 Array{Int64,2}:
 1  2  3
 4  5  6

julia> vec(a)
6-element Array{Int64,1}:
 1
 4
 2
 5
 3
 6

julia> vec(1:3)
1:3

См. также reshape.

Конкатенация и перестановка

Base.catФункция

cat(A...; dims=dims)

Конкатенирует входные массивы по указанным измерениям в итерируемом dims . Для измерений, не входящих в dims , все входные массивы должны иметь одинаковый размер, который также будет размером выходного массива по этому измерению. Для измерений в dims размер выходного массива равен сумме размеров входных массивов по этому измерению. Если dims - это одно число, различные массивы плотно укладываются по этому измерению. Если dims - это итерируемый объект, содержащий несколько измерений, это позволяет строить блочно-диагональные матрицы и их аналоги более высоких измерений, одновременно увеличивая несколько измерений для каждого нового входного массива и помещая нулевые блоки в остальных местах. Например, cat(matrices...; dims=(1,2)) строит блочно-диагональную матрицу, т. е. блочную матрицу с matrices[1], matrices[2], ... как диагональные блоки и соответствующие нулевые блоки вне диагонали.

Base.vcatФункция

vcat(A...)

Конкатенация по измерению 1.

Примеры

julia> a = [1 2 3 4 5]
1×5 Array{Int64,2}:
 1  2  3  4  5

julia> b = [6 7 8 9 10; 11 12 13 14 15]
2×5 Array{Int64,2}:
  6   7   8   9  10
 11  12  13  14  15

julia> vcat(a,b)
3×5 Array{Int64,2}:
  1   2   3   4   5
  6   7   8   9  10
 11  12  13  14  15

julia> c = ([1 2 3], [4 5 6])
([1 2 3], [4 5 6])

julia> vcat(c...)
2×3 Array{Int64,2}:
 1  2  3
 4  5  6

Base.hcatФункция

hcat(A...)

Конкатенация по измерению 2.

Примеры

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

julia> b = [6 7; 8 9; 10 11; 12 13; 14 15]
5×2 Array{Int64,2}:
  6   7
  8   9
 10  11
 12  13
 14  15

julia> hcat(a,b)
5×3 Array{Int64,2}:
 1   6   7
 2   8   9
 3  10  11
 4  12  13
 5  14  15

julia> c = ([1; 2; 3], [4; 5; 6])
([1, 2, 3], [4, 5, 6])

julia> hcat(c...)
3×2 Array{Int64,2}:
 1  4
 2  5
 3  6

Base.hvcatФункция

hvcat(rows::Tuple{Vararg{Int}}, values...)

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

Примеры

julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
(1, 2, 3, 4, 5, 6)

julia> [a b c; d e f]
2×3 Array{Int64,2}:
 1  2  3
 4  5  6

julia> hvcat((3,3), a,b,c,d,e,f)
2×3 Array{Int64,2}:
 1  2  3
 4  5  6

julia> [a b;c d; e f]
3×2 Array{Int64,2}:
 1  2
 3  4
 5  6

julia> hvcat((2,2,2), a,b,c,d,e,f)
3×2 Array{Int64,2}:
 1  2
 3  4
 5  6

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

Base.vectФункция

vect(X...)

Создает Vector с типом элемента, вычисляемым из promote_typeof аргумента, содержащего список аргументов.

Примеры

julia> a = Base.vect(UInt8(1), 2.5, 1//2)
3-element Array{Float64,1}:
 1.0
 2.5
 0.5

Base.circshiftФункция

circshift(A, shifts)

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

Примеры

julia> b = reshape(Vector(1:16), (4,4))
4×4 Array{Int64,2}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> circshift(b, (0,2))
4×4 Array{Int64,2}:
  9  13  1  5
 10  14  2  6
 11  15  3  7
 12  16  4  8

julia> circshift(b, (-1,0))
4×4 Array{Int64,2}:
 2  6  10  14
 3  7  11  15
 4  8  12  16
 1  5   9  13

julia> a = BitArray([true, true, false, false, true])
5-element BitArray{1}:
 1
 1
 0
 0
 1

julia> circshift(a, 1)
5-element BitArray{1}:
 1
 1
 1
 0
 0

julia> circshift(a, -1)
5-element BitArray{1}:
 1
 0
 0
 1
 1

См. также circshift!.

Base.circshift!Функция

circshift!(dest, src, shifts)

Циклически сдвигает, т. е. вращает, данные в src, сохраняя результат в dest. shifts указывает величину сдвига в каждом измерении.

Массив dest должен быть отличен от массива src (они не могут ссылаться друг на друга).

См. также circshift.

Base.circcopy!Функция

circcopy!(dest, src)

Копирует src в dest, индексируя каждое измерение по модулю его длины. src и dest должны иметь одинаковый размер, но могут быть смещены по своим индексам; любое смещение приводит к (циклическому) переходу. Если массивы имеют перекрывающиеся индексы, то в области перекрытия dest совпадает с src.

Примеры

julia> src = reshape(Vector(1:16), (4,4))
4×4 Array{Int64,2}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> dest = OffsetArray{Int}(undef, (0:3,2:5))

julia> circcopy!(dest, src)
OffsetArrays.OffsetArray{Int64,2,Array{Int64,2}} with indices 0:3×2:5:
 8  12  16  4
 5   9  13  1
 6  10  14  2
 7  11  15  3

julia> dest[1:3,2:4] == src[1:3,2:4]
true

Base.findallМетод

findall(A)

Возвращает вектор I индексов или ключей true A . Если таких элементов A нет, возвращает пустой массив. Для поиска других типов значений передайте предикат в качестве первого аргумента.

Индексы или ключи имеют тот же тип, что и те, которые возвращаются keys(A) и pairs(A).

Примеры

julia> A = [true, false, false, true]
4-element Array{Bool,1}:
 1
 0
 0
 1

julia> findall(A)
2-element Array{Int64,1}:
 1
 4

julia> A = [true false; false true]
2×2 Array{Bool,2}:
 1  0
 0  1

julia> findall(A)
2-element Array{CartesianIndex{2},1}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 2)

julia> findall(falses(3))
0-element Array{Int64,1}

Base.findallМетод

findall(f::Function, A)

Возвращает вектор I индексов или ключей A , где f(A[I]) возвращает true. Если таких элементов в A нет, возвращает пустой массив.

Индексы или ключи имеют тот же тип, что и те, которые возвращаются keys(A) и pairs(A).

Примеры

julia> x = [1, 3, 4]
3-element Array{Int64,1}:
 1
 3
 4

julia> findall(isodd, x)
2-element Array{Int64,1}:
 1
 2

julia> A = [1 2 0; 3 4 0]
2×3 Array{Int64,2}:
 1  2  0
 3  4  0
julia> findall(isodd, A)
2-element Array{CartesianIndex{2},1}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)

julia> findall(!iszero, A)
4-element Array{CartesianIndex{2},1}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)
 CartesianIndex(1, 2)
 CartesianIndex(2, 2)

julia> d = Dict(:A => 10, :B => -1, :C => 0)
Dict{Symbol,Int64} with 3 entries:
  :A => 10
  :B => -1
  :C => 0

julia> findall(x -> x >= 0, d)
2-element Array{Symbol,1}:
 :A
 :C

Base.findfirstМетод

findfirst(A)

Возвращает индекс или ключ первого true значения в A. Возвращает nothing , если такое значение не найдено. Для поиска других типов значений передайте предикат в качестве первого аргумента.

Индексы или ключи имеют тот же тип, что и те, которые возвращаются keys(A) и pairs(A).

Примеры

julia> A = [false, false, true, false]
4-element Array{Bool,1}:
 0
 0
 1
 0

julia> findfirst(A)
3

julia> findfirst(falses(3)) # returns nothing, but not printed in the REPL

julia> A = [false false; true false]
2×2 Array{Bool,2}:
 0  0
 1  0

julia> findfirst(A)
CartesianIndex(2, 1)

Base.findfirstМетод

findfirst(predicate::Function, A)

Возвращает индекс или ключ первого элемента A , для которого predicate возвращает true. Возвращает nothing , если такого элемента нет.

Индексы или ключи имеют тот же тип, что и те, которые возвращаются keys(A) и pairs(A).

Примеры

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

julia> findfirst(iseven, A)
2

julia> findfirst(x -> x>10, A) # returns nothing, but not printed in the REPL

julia> findfirst(isequal(4), A)
2

julia> A = [1 4; 2 2]
2×2 Array{Int64,2}:
 1  4
 2  2

julia> findfirst(iseven, A)
CartesianIndex(2, 1)

Base.findlastМетод

findlast(A)

Возвращает индекс или ключ последнего true значения в A. Возвращает nothing , если такого значения в true нет в A.

Индексы или ключи имеют тот же тип, что и те, которые возвращаются keys(A) и pairs(A).

Примеры

julia> A = [true, false, true, false]
4-element Array{Bool,1}:
 1
 0
 1
 0

julia> findlast(A)
3

julia> A = falses(2,2);

julia> findlast(A) # returns nothing, but not printed in the REPL

julia> A = [true false; true false]
2×2 Array{Bool,2}:
 1  0
 1  0

julia> findlast(A)
CartesianIndex(2, 1)

Base.findlastМетод

findlast(predicate::Function, A)

Возвращает индекс или ключ последнего элемента A , для которого predicate возвращает true. Возвращает nothing , если такого элемента нет.

Индексы или ключи имеют тот же тип, что и те, которые возвращаются keys(A) и pairs(A).

Примеры

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

julia> findlast(isodd, A)
3

julia> findlast(x -> x > 5, A) # returns nothing, but not printed in the REPL

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

julia> findlast(isodd, A)
CartesianIndex(2, 1)

Base.findnextМетод

findnext(A, i)

Находит следующий индекс после или включая i элемента true в A, или nothing , если не найден.

Индексы имеют тот же тип, что и те, которые возвращаются keys(A) и pairs(A).

Примеры

julia> A = [false, false, true, false]
4-element Array{Bool,1}:
 0
 0
 1
 0

julia> findnext(A, 1)
3

julia> findnext(A, 4) # returns nothing, but not printed in the REPL

julia> A = [false false; true false]
2×2 Array{Bool,2}:
 0  0
 1  0

julia> findnext(A, CartesianIndex(1, 1))
CartesianIndex(2, 1)

Base.findnextМетод

findnext(predicate::Function, A, i)

Находит следующий индекс после или включая i элемента A , для которого predicate возвращает true, или nothing , если не найден.

Индексы имеют тот же тип, что и те, которые возвращаются keys(A) и pairs(A).

Примеры

julia> A = [1, 4, 2, 2];

julia> findnext(isodd, A, 1)
1

julia> findnext(isodd, A, 2) # returns nothing, but not printed in the REPL

julia> A = [1 4; 2 2];

julia> findnext(isodd, A, CartesianIndex(1, 1))
CartesianIndex(1, 1)

Base.findprevМетод

findprev(A, i)

Находит предыдущий индекс до или включая i элемента true в A, или nothing , если не найден.

Индексы имеют тот же тип, что и те, которые возвращаются keys(A) и pairs(A).

Примеры

julia> A = [false, false, true, true]
4-element Array{Bool,1}:
 0
 0
 1
 1

julia> findprev(A, 3)
3

julia> findprev(A, 1) # returns nothing, but not printed in the REPL

julia> A = [false false; true true]
2×2 Array{Bool,2}:
 0  0
 1  1

julia> findprev(A, CartesianIndex(2, 1))
CartesianIndex(2, 1)

Base.findprevМетод

findprev(predicate::Function, A, i)

Находит предыдущий индекс до или включая i элемента A , для которого predicate возвращает true, или nothing , если не найден.

Индексы имеют тот же тип, что и те, которые возвращаются keys(A) и pairs(A).

Примеры

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

julia> findprev(isodd, A, 1) # returns nothing, but not printed in the REPL

julia> findprev(isodd, A, 3)
3

julia> A = [4 6; 1 2]
2×2 Array{Int64,2}:
 4  6
 1  2

julia> findprev(isodd, A, CartesianIndex(1, 2))
CartesianIndex(2, 1)

Base.permutedimsФункция

permutedims(A::AbstractArray, perm)

Переставляет размерности массива A. perm — вектор, определяющий перестановку длины ndims(A).

См. также: PermutedDimsArray.

Примеры

julia> A = reshape(Vector(1:8), (2,2,2))
2×2×2 Array{Int64,3}:
[:, :, 1] =
 1  3
 2  4

[:, :, 2] =
 5  7
 6  8

julia> permutedims(A, [3, 2, 1])
2×2×2 Array{Int64,3}:
[:, :, 1] =
 1  3
 5  7

[:, :, 2] =
 2  4
 6  8

permutedims(m::AbstractMatrix)

Переставляет размерности матрицы m, перевернув элементы относительно диагонали матрицы. Отличается от LinearAlgebra transpose тем, что операция не рекурсивна.

Примеры

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

julia> b = [5 6; 7 8];

julia> c = [9 10; 11 12];

julia> d = [13 14; 15 16];

julia> X = [[a] [b]; [c] [d]]
2×2 Array{Array{Int64,2},2}:
 [1 2; 3 4]     [5 6; 7 8]
 [9 10; 11 12]  [13 14; 15 16]

julia> permutedims(X)
2×2 Array{Array{Int64,2},2}:
 [1 2; 3 4]  [9 10; 11 12]
 [5 6; 7 8]  [13 14; 15 16]

julia> transpose(X)
2×2 Transpose{Transpose{Int64,Array{Int64,2}},Array{Array{Int64,2},2}}:
 [1 3; 2 4]  [9 11; 10 12]
 [5 7; 6 8]  [13 15; 14 16]

permutedims(v::AbstractVector)

Преобразует вектор v в матрицу с 1 × length(v) строками. Отличается от LinearAlgebra transpose тем, что операция не рекурсивна.

Примеры

julia> permutedims([1, 2, 3, 4])
1×4 Array{Int64,2}:
 1  2  3  4

julia> V = [[[1 2; 3 4]]; [[5 6; 7 8]]]
2-element Array{Array{Int64,2},1}:
 [1 2; 3 4]
 [5 6; 7 8]

julia> permutedims(V)
1×2 Array{Array{Int64,2},2}:
 [1 2; 3 4]  [5 6; 7 8]

julia> transpose(V)
1×2 Transpose{Transpose{Int64,Array{Int64,2}},Array{Array{Int64,2},1}}:
 [1 3; 2 4]  [5 7; 6 8]

Base.permutedims!Функция

permutedims!(dest, src, perm)

Переставляет размерности массива src и сохраняет результат в массиве dest. perm — вектор, определяющий перестановку длины ndims(src). Предварительно выделенный массив dest должен иметь size(dest) == size(src)[perm] и полностью перезаписывается. Поддержка перестановки на месте отсутствует, и будут получены неожиданные результаты, если src и dest имеют перекрывающиеся области памяти.

См. также permutedims.

Base.PermutedDimsArrays.PermutedDimsArrayТип

PermutedDimsArray(A, perm) -> B

Для данного AbstractArray A создаётся представление B , такое, что размерности кажутся переставленными. Аналогично permutedims, но копирование не происходит (B совместно использует хранилище с A).

См. также: permutedims.

Примеры

julia> A = rand(3,5,4);

julia> B = PermutedDimsArray(A, (3,1,2));

julia> size(B)
(4, 3, 5)

julia> B[3,1,2] == A[1,2,3]
true

Base.promote_shapeФункция

promote_shape(s1, s2)

Проверяет совместимость двух форм массивов, позволяя иметь фиктивные размерности, и возвращает ту форму, у которой больше измерений.

Примеры

julia> a = fill(1, (3,4,1,1,1));

julia> b = fill(1, (3,4));

julia> promote_shape(a,b)
(Base.OneTo(3), Base.OneTo(4), Base.OneTo(1), Base.OneTo(1), Base.OneTo(1))

julia> promote_shape((2,3,1,4), (2, 3, 1, 4, 1))
(2, 3, 1, 4, 1)

Функции массивов

Base.accumulateФункция

accumulate(op, A; dims::Integer, [init])

Кумулятивная операция op по размерности dims массива A (для векторов начальное значение dims задается по желанию). Также можно задать начальное значение init с помощью ключевого аргумента. См. также accumulate! для использования предопределенного выходного массива, что улучшает производительность и позволяет контролировать точность результата (например, для предотвращения переполнения). Для распространенных операций существуют специализированные варианты accumulate, см.: cumsum, cumprod

Примеры

julia> accumulate(+, [1,2,3])
3-element Array{Int64,1}:
 1
 3
 6

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

julia> accumulate(+, [1,2,3]; init=100)
3-element Array{Int64,1}:
 101
 103
 106

julia> accumulate(min, [1,2,-1]; init=0)
3-element Array{Int64,1}:
  0
  0
 -1

julia> accumulate(+, fill(1, 3, 3), dims=1)
3×3 Array{Int64,2}:
 1  1  1
 2  2  2
 3  3  3

julia> accumulate(+, fill(1, 3, 3), dims=2)
3×3 Array{Int64,2}:
 1  2  3
 1  2  3
 1  2  3

Base.accumulate!Функция

accumulate!(op, B, A; [dims], [init])

Кумулятивная операция op над A по размерности dims, сохраняя результат в B. Передача dims является необязательной для векторов. Если ключевой аргумент init задан, его значение используется для инициализации накопления. См. также accumulate.

Примеры

julia> x = [1, 0, 2, 0, 3];

julia> y = [0, 0, 0, 0, 0];

julia> accumulate!(+, y, x);

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

julia> A = [1 2; 3 4];

julia> B = [0 0; 0 0];

julia> accumulate!(-, B, A, dims=1);

julia> B
2×2 Array{Int64,2}:
  1   2
 -2  -2

julia> accumulate!(-, B, A, dims=2);

julia> B
2×2 Array{Int64,2}:
 1  -1
 3  -1

Base.cumprodФункция

cumprod(A; dims::Integer)

Кумулятивное произведение по размерности dim. См. также cumprod! для использования предопределённого выходного массива, что улучшает производительность и позволяет контролировать точность результата (например, для предотвращения переполнения).

Примеры

julia> a = [1 2 3; 4 5 6]
2×3 Array{Int64,2}:
 1  2  3
 4  5  6

julia> cumprod(a, dims=1)
2×3 Array{Int64,2}:
 1   2   3
 4  10  18

julia> cumprod(a, dims=2)
2×3 Array{Int64,2}:
 1   2    6
 4  20  120

cumprod(x::AbstractVector)

Кумулятивное произведение вектора. См. также cumprod! для использования предопределённого выходного массива, что улучшает производительность и позволяет контролировать точность результата (например, для предотвращения переполнения).

Примеры

julia> cumprod(fill(1//2, 3))
3-element Array{Rational{Int64},1}:
 1//2
 1//4
 1//8

julia> cumprod([fill(1//3, 2, 2) for i in 1:3])
3-element Array{Array{Rational{Int64},2},1}:
 [1//3 1//3; 1//3 1//3]
 [2//9 2//9; 2//9 2//9]
 [4//27 4//27; 4//27 4//27]

Base.cumprod!Функция

cumprod!(B, A; dims::Integer)

Кумулятивное произведение A по размерности dims, сохраняя результат в B. См. также cumprod.

cumprod!(y::AbstractVector, x::AbstractVector)

Кумулятивное произведение вектора x, сохраняя результат в y. См. также cumprod.

Base.cumsumФункция

cumsum(A; dims::Integer)

Кумулятивная сумма по размерности dims. См. также cumsum! для использования предопределённого выходного массива, что улучшает производительность и позволяет контролировать точность результата (например, для предотвращения переполнения).

Примеры

julia> a = [1 2 3; 4 5 6]
2×3 Array{Int64,2}:
 1  2  3
 4  5  6

julia> cumsum(a, dims=1)
2×3 Array{Int64,2}:
 1  2  3
 5  7  9

julia> cumsum(a, dims=2)
2×3 Array{Int64,2}:
 1  3   6
 4  9  15

cumsum(x::AbstractVector)

Кумулятивная сумма вектора. См. также cumsum! для использования предопределённого выходного массива, что улучшает производительность и позволяет контролировать точность результата (например, для предотвращения переполнения).

Примеры

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

julia> cumsum([fill(1, 2) for i in 1:3])
3-element Array{Array{Int64,1},1}:
 [1, 1]
 [2, 2]
 [3, 3]

Base.cumsum!Функция

cumsum!(B, A; dims::Integer)

Кумулятивная сумма A по размерности dims, сохраняя результат в B. См. также cumsum.

Base.diffФункция

diff(A::AbstractVector)
diff(A::AbstractArray; dims::Integer)

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

Примеры

julia> a = [2 4; 6 16]
2×2 Array{Int64,2}:
 2   4
 6  16

julia> diff(a, dims=2)
2×1 Array{Int64,2}:
  2
 10

julia> diff(vec(a))
3-element Array{Int64,1}:
  4
 -2
 12

Base.repeatФункция

repeat(A::AbstractArray, counts::Integer...)

Создание массива путём повторения массива A заданное количество раз в каждой размерности, задаваемое параметром counts.

Примеры

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

julia> repeat([1, 2, 3], 2, 3)
6×3 Array{Int64,2}:
 1  1  1
 2  2  2
 3  3  3
 1  1  1
 2  2  2
 3  3  3

repeat(A::AbstractArray; inner=ntuple(x->1, ndims(A)), outer=ntuple(x->1, ndims(A)))

Создание массива путём повторения элементов массива A. i-тый элемент inner указывает на количество повторений элементов i-той размерности массива A. i-тый элемент outer указывает на количество повторений среза по i-той размерности A. Если inner или outer опущены, повторение не выполняется.

Примеры

julia> repeat(1:2, inner=2)
4-element Array{Int64,1}:
 1
 1
 2
 2

julia> repeat(1:2, outer=2)
4-element Array{Int64,1}:
 1
 2
 1
 2

julia> repeat([1 2; 3 4], inner=(2, 1), outer=(1, 3))
4×6 Array{Int64,2}:
 1  2  1  2  1  2
 1  2  1  2  1  2
 3  4  3  4  3  4
 3  4  3  4  3  4

repeat(s::AbstractString, r::Integer)

Повторение строки r раз. Это можно записать как s^r.

См. также: ^

Примеры

julia> repeat("ha", 3)
"hahaha"

repeat(c::AbstractChar, r::Integer) -> String

Повторение символа r раз. Это эквивалентно вызову c^r.

Примеры

julia> repeat('A', 3)
"AAA"

Base.rot180Функция

rot180(A)

Поворот матрицы A на 180 градусов.

Примеры

julia> a = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> rot180(a)
2×2 Array{Int64,2}:
 4  3
 2  1

rot180(A, k)

Поворот матрицы A на 180 градусов целое число k раз. Если k чётное, это эквивалентно copy.

Примеры

julia> a = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> rot180(a,1)
2×2 Array{Int64,2}:
 4  3
 2  1

julia> rot180(a,2)
2×2 Array{Int64,2}:
 1  2
 3  4

Base.rotl90Функция

rotl90(A)

Поворот матрицы A влево на 90 градусов.

Примеры

julia> a = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> rotl90(a)
2×2 Array{Int64,2}:
 2  4
 1  3

rotl90(A, k)

Поворот матрицы A на 90 градусов против часовой стрелки целое число k раз. Если k кратно четырём (включая ноль), это эквивалентно copy.

Примеры

julia> a = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> rotl90(a,1)
2×2 Array{Int64,2}:
 2  4
 1  3

julia> rotl90(a,2)
2×2 Array{Int64,2}:
 4  3
 2  1

julia> rotl90(a,3)
2×2 Array{Int64,2}:
 3  1
 4  2

julia> rotl90(a,4)
2×2 Array{Int64,2}:
 1  2
 3  4

Base.rotr90Функция

rotr90(A)

Поворот матрицы A вправо на 90 градусов.

Примеры

julia> a = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> rotr90(a)
2×2 Array{Int64,2}:
 3  1
 4  2

rotr90(A, k)

Поворот матрицы A на 90 градусов по часовой стрелке целое число k раз. Если k кратно четырём (включая ноль), это эквивалентно copy.

Примеры

julia> a = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> rotr90(a,1)
2×2 Array{Int64,2}:
 3  1
 4  2

julia> rotr90(a,2)
2×2 Array{Int64,2}:
 4  3
 2  1

julia> rotr90(a,3)
2×2 Array{Int64,2}:
 2  4
 1  3

julia> rotr90(a,4)
2×2 Array{Int64,2}:
 1  2
 3  4

Base.mapslicesФункция

mapslices(f, A; dims)

Преобразование заданных размерностей массива A с использованием функции f. f вызывается для каждого среза массива A вида A[...,:,...,:,...]. dims — целочисленный вектор, указывающий, где стоят двоеточия в этом выражении. Результаты конкатенируются по оставшимся размерностям. Например, если dims равно [1,2] и A имеет 4 измерения, то f вызывается над A[:,:,i,j] для всех i и j.

Примеры

julia> a = reshape(Vector(1:16),(2,2,2,2))
2×2×2×2 Array{Int64,4}:
[:, :, 1, 1] =
 1  3
 2  4

[:, :, 2, 1] =
 5  7
 6  8

[:, :, 1, 2] =
  9  11
 10  12

[:, :, 2, 2] =
 13  15
 14  16

julia> mapslices(sum, a, dims = [1,2])
1×1×2×2 Array{Int64,4}:
[:, :, 1, 1] =
 10

[:, :, 2, 1] =
 26

[:, :, 1, 2] =
 42

[:, :, 2, 2] =
 58

Комбинаторика

Base.invpermФункция

invperm(v)

Возвращает обратную перестановку v. Если B = A[v], то A == B[invperm(v)].

Примеры

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

julia> invperm(v)
4-element Array{Int64,1}:
 4
 1
 3
 2

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

julia> B = A[v]
4-element Array{Char,1}:
 'b'
 'd'
 'c'
 'a'

julia> B[invperm(v)]
4-element Array{Char,1}:
 'a'
 'b'
 'c'
 'd'

Base.ispermФункция

isperm(v) -> Bool

Возвращает true, если v является корректной перестановкой.

Примеры

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

Base.permute!Метод

permute!(v, p)

Переставляет вектор v на месте в соответствии с перестановкой p. Проверка того, что p является перестановкой, не выполняется.

Для возвращения новой перестановки используйте v[p]. Обратите внимание, что это обычно быстрее, чем permute!(v,p) для больших векторов.

См. также invpermute!.

Примеры

julia> A = [1, 1, 3, 4];

julia> perm = [2, 4, 3, 1];

julia> permute!(A, perm);

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

Base.invpermute!Функция

invpermute!(v, p)

Аналогично permute!, но применяется обратная перестановка.

Примеры

julia> A = [1, 1, 3, 4];

julia> perm = [2, 4, 3, 1];

julia> invpermute!(A, perm);

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

Base.reverseМетод

reverse(v [, start=1 [, stop=length(v) ]] )

Возвращает копию v, перевёрнутую от начала до конца. См. также Iterators.reverse для итерации в обратном порядке без создания копии.

Примеры

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

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

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

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

reverse(A; dims::Integer)

Переворачивает A в измерении dims.

Примеры

julia> b = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> reverse(b, dims=2)
2×2 Array{Int64,2}:
 2  1
 4  3

Base.reverseindФункция

reverseind(v, i)

Для заданного индекса i в reverse(v), возвращает соответствующий индекс в v таким образом, что v[reverseind(v,i)] == reverse(v)[i]. (Это может быть нетривиально в случаях, когда v содержит не-ASCII символы.)

Примеры

julia> r = reverse("Julia")
"ailuJ"

julia> for i in 1:length(r)
           print(r[reverseind("Julia", i)])
       end
Julia

Base.reverse!Функция

reverse!(v [, start=1 [, stop=length(v) ]]) -> v

Функция-аналог reverse на месте.

Примеры

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

julia> reverse!(A);

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