Массивы

AbstractArray{T,N}

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

См. также: AbstractVector, AbstractMatrix, eltype, ndims.

AbstractVector{T}

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

AbstractMatrix{T}

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

AbstractVecOrMat{T}

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

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

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

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

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

Примеры

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

julia> B = Array{Float64}(undef, 4) # N determined by the input
4-element Vector{Float64}:
   2.360075077e-314
 NaN
   2.2671131793e-314
   2.299821756e-314

julia> similar(B, 2, 4, 1) # use typeof(B), and the given size
2×4×1 Array{Float64, 3}:
[:, :, 1] =
 2.26703e-314  2.26708e-314  0.0           2.80997e-314
 0.0           2.26703e-314  2.26708e-314  0.0

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

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

Примеры

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

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

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

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

Примеры

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

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

UndefInitializer

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

Примеры

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

undef

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

См. также: missing, similar.

Примеры

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

Vector{T} <: AbstractVector{T}

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

См. также empty, similar и zero для создания векторов.

Vector{T}(undef, n)

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

Примеры

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

Vector{T}(nothing, m)

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

Примеры

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

Vector{T}(missing, m)

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

Примеры

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

Matrix{T} <: AbstractMatrix{T}

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

См. также fill, zeros, undef и similar для создания матриц.

Matrix{T}(undef, m, n)

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

Примеры

julia> Matrix{Float64}(undef, 2, 3)
2×3 Array{Float64, 2}:
 2.36365e-314  2.28473e-314    5.0e-324
 2.26704e-314  2.26711e-314  NaN

julia> similar(ans, Int32, 2, 2)
2×2 Matrix{Int32}:
 490537216  1277177453
         1  1936748399

Matrix{T}(nothing, m, n)

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

Примеры

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

Matrix{T}(missing, m, n)

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

Примеры

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

VecOrMat{T}

Объединение типов Vector{T} и Matrix{T}, позволяющее функциям принимать как матрицу, так и вектор.

Примеры

julia> Vector{Float64} <: VecOrMat{Float64}
true

julia> Matrix{Float64} <: VecOrMat{Float64}
true

julia> Array{Float64, 3} <: VecOrMat{Float64}
false

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

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

DenseVector{T}

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

DenseMatrix{T}

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

DenseVecOrMat{T}

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

StridedArray{T, N}

Жестко заданное Union общих типов массивов, которые следуют интерфейсу стридовых массивов, с элементами типа T и N измерениями.

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

StridedVector{T}

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

StridedMatrix{T}

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

StridedVecOrMat{T}

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

Slices{P,SM,AX,S,N} <: AbstractSlices{S,N}

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

Их обычно создают eachslice, eachcol или eachrow.

parent(s::Slices) вернёт родительский массив.

RowSlices{M,AX,S}

Частный случай Slices, представляющий собой вектор срезов строк матрицы, созданный с помощью eachrow.

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

ColumnSlices{M,AX,S}

Частный случай Slices, представляющий собой вектор срезов столбцов матрицы, созданный с помощью eachcol.

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

getindex(type[, elements...])

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

Примеры

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

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

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

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

Примеры

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

Примеры

julia> BitArray(undef, 2, 2)
2×2 BitMatrix:
 0  0
 0  0

julia> BitArray(undef, (3, 1))
3×1 BitMatrix:
 0
 0
 0

BitArray(itr)

Создайте BitArray, сгенерированный заданным итерируемым объектом. Форма выводится из объекта itr.

Примеры

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

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

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

trues(dims)

Создайте BitArray со всеми значениями, установленными в true.

Примеры

julia> trues(2,3)
2×3 BitMatrix:
 1  1  1
 1  1  1

falses(dims)

Создайте BitArray со всеми значениями, установленными в false.

Примеры

julia> falses(2,3)
2×3 BitMatrix:
 0  0  0
 0  0  0

fill(value, dims::Tuple)
fill(value, dims...)

Создайте массив размера dims с каждым элементом, установленным в value.

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

Длины измерений dims могут быть указаны как кортеж или последовательность аргументов. Кортеж длины N или N аргументов, следующих за value , определяют N-мерный массив. Таким образом, распространенным способом создания нульмерного массива с его единственной позицией, установленной в x , является fill(x).

Каждая позиция возвращаемого массива устанавливается в (и, следовательно, === к) переданному value. Это означает, что если value сам изменится, все элементы массива fill отразит это изменение, потому что они по-прежнему являются этим самым value. Это не вызывает беспокойства при работе с fill(1.0, (5,5)), поскольку value 1.0 неизменяем и не может быть изменен сам по себе, но может быть неожиданным с изменяемыми значениями, как, например, — чаще всего — массивы. Например, fill([], 3) помещает один и тот же пустой массив во все три позиции возвращаемого вектора:

julia> v = fill([], 3)
3-element Vector{Vector{Any}}:
 []
 []
 []

julia> v[1] === v[2] === v[3]
true

julia> value = v[1]
Any[]

julia> push!(value, 867_5309)
1-element Vector{Any}:
 8675309

julia> v
3-element Vector{Vector{Any}}:
 [8675309]
 [8675309]
 [8675309]

Чтобы создать массив многих независимых внутренних массивов, используйте понимание вместо этого. Это создает новый и отдельный массив на каждой итерации цикла:

julia> v2 = [[] for _ in 1:3]
3-element Vector{Vector{Any}}:
 []
 []
 []

julia> v2[1] === v2[2] === v2[3]
false

julia> push!(v2[1], 8675309)
1-element Vector{Any}:
 8675309

julia> v2
3-element Vector{Vector{Any}}:
 [8675309]
 []
 []

См. также: fill!, zeros, ones, similar.

Примеры

julia> fill(1.0, (2,3))
2×3 Matrix{Float64}:
 1.0  1.0  1.0
 1.0  1.0  1.0

julia> fill(42)
0-dimensional Array{Int64, 0}:
42

julia> A = fill(zeros(2), 2) # sets both elements to the same [0.0, 0.0] vector
2-element Vector{Vector{Float64}}:
 [0.0, 0.0]
 [0.0, 0.0]

julia> A[1][1] = 42; # modifies the filled value to be [42.0, 0.0]

julia> A # both A[1] and A[2] are the very same vector
2-element Vector{Vector{Float64}}:
 [42.0, 0.0]
 [42.0, 0.0]

fill!(A, x)

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

Примеры

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

julia> fill!(A, 2.)
2×3 Matrix{Float64}:
 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 Vector{Vector{Int64}}:
 [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 Vector{Int64}:
 1
 1
 1

empty(x::Tuple)

Вернуть пустой кортеж, ().

empty(v::AbstractVector, [eltype])

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

См. также: empty!, isempty, isassigned.

Примеры

julia> empty([1.0, 2.0, 3.0])
Float64[]

julia> empty([1.0, 2.0, 3.0], String)
String[]

empty(a::AbstractDict, [index_type=keytype(a)], [value_type=valtype(a)])

Создать пустой AbstractDict контейнер, который может принимать индексы типа index_type и значения типа value_type. Второй и третий аргументы необязательны и по умолчанию принимают keytype и valtype, соответственно. (Если указан только один из двух типов, считается, что это value_type, и index_type по умолчанию равно keytype(a)).

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

similar(A::AbstractSparseMatrixCSC{Tv,Ti}, [::Type{TvNew}, ::Type{TiNew}, m::Integer, n::Integer]) where {Tv,Ti}

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

Выходной массив имеет нули в тех же позициях, что и входной, но неинициализированные значения для ненулевых позиций.

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

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

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

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

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

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

julia> similar(trues(10,10), 2)
2-element BitVector:
 0
 0

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

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

См. также: undef, isassigned.

similar(storagetype, axes)

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

Примеры:

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

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

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

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

ndims(A::AbstractArray) -> Integer

Вернуть число измерений A.

См. также: size, axes.

Примеры

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

julia> ndims(A)
3

size(A::AbstractArray, [dim])

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

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

См. также: length, ndims, eachindex, sizeof.

Примеры

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

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

julia> size(A, 2)
3

axes(A)

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

См. также: size, keys, eachindex.

Примеры

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

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

axes(A, d)

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

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

Примеры

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

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

julia> axes(A, 4) == 1:1  # all dimensions d > ndims(A) have size 1
true

Примечание по использованию

Каждый из индексов должен быть AbstractUnitRange{<:Integer}, но в то же время может быть типом, использующим настраиваемые индексы. Например, если вам нужен подмножество, используйте обобщённые конструкции индексирования, такие как begin/end или firstindex/lastindex:

ix = axes(v, 1)
ix[2:end]          # will work for eg Vector, but may fail in general
ix[(begin+1):end]  # works for generalized indexes

length(A::AbstractArray)

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

Примеры

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

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

keys(a::AbstractArray)

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

Ключи одномерных массивов (векторов) — целые числа, в то время как все остальные N-мерные массивы используют CartesianIndex для описания своих местоположений. Часто для эффективного представления этих массивов целых чисел и CartesianIndex используются специальные типы массивов LinearIndices и CartesianIndices, соответственно.

Обратите внимание, что ключи массива могут не быть самым эффективным типом индекса; для максимальной производительности используйте eachindex вместо этого.

Примеры

julia> keys([4, 5, 6])
3-element LinearIndices{1, Tuple{Base.OneTo{Int64}}}:
 1
 2
 3

julia> keys([4 5; 6 7])
CartesianIndices((2, 2))

eachindex(A...)
eachindex(::IndexStyle, A::AbstractArray...)

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

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

В общем случае eachindex принимает произвольные итерируемые объекты, включая строки и словари, и возвращает объект-итератор, поддерживающий произвольные типы индексов (например, неравномерно расположенные или нецелые индексы).

Если A является AbstractArray, можно явно указать стиль индексов, которые должны возвращаться eachindex, передав значение типа IndexStyle в качестве первого аргумента (обычно IndexLinear(), если требуются линейные индексы, или IndexCartesian(), если нужен картезианский диапазон).

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

См. также pairs(A) для итерации по индексам и значениям вместе, и axes(A, 2) для допустимых индексов по одному измерению.

Примеры

julia> A = [10 20; 30 40];

julia> for i in eachindex(A) # linear indexing
           println("A[", i, "] == ", A[i])
       end
A[1] == 10
A[2] == 30
A[3] == 20
A[4] == 40

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

IndexStyle(A)
IndexStyle(typeof(A))

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

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

По умолчанию IndexCartesian().

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

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

IndexLinear()

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

Стиль линейного индексирования использует один целочисленный индекс для описания позиции в массиве (даже если это многомерный массив), а для эффективного доступа к элементам используется порядок следования по столбцам. Это означает, что запрос eachindex из массива, который IndexLinear, вернёт простой одномерный диапазон, даже если он многомерный.

Настраиваемый массив, который сообщает о своём IndexStyle как IndexLinear, должен реализовать индексирование (и присвоение индексом) только с одним Int индексом; все остальные выражения индексирования, включая многомерный доступ, будут пересчитаны в линейный индекс. Например, если A был 2×3 настраиваемой матрицей с линейным индексированием, и мы ссылались на A[1, 3], это будет пересчитано в эквивалентный линейный индекс и вызовет A[5], так как 2*1 + 3 = 5.

См. также IndexCartesian.

IndexCartesian()

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

Стиль картезианского индексирования использует несколько целочисленных индексов для описания позиции в многомерном массиве, с ровно одним индексом на измерение. Это означает, что запрос eachindex из массива, который IndexCartesian, вернёт диапазон CartesianIndices.

N-мерный настраиваемый массив, который сообщает о своём IndexStyle как IndexCartesian, должен реализовать индексирование (и присвоение индексом) ровно с N Int индексами; все другие выражения индексирования, включая линейное индексирование, будут пересчитаны в эквивалентную картезианскую позицию. Например, если A был 2×3 настраиваемой матрицей с картезианским индексированием, и мы ссылались на A[5], это будет пересчитано в эквивалентный картезианский индекс и вызовет A[1, 3], так как 5 = 2*1 + 3.

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

См. также IndexLinear.

conj!(A)

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

См. также conj.

Примеры

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

julia> conj!(A);

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

stride(A, k::Integer)

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

См. также: strides.

Примеры

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

julia> stride(A,2)
3

julia> stride(A,3)
12

strides(A)

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

См. также: stride.

Примеры

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

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

broadcast(f, As...)

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

Вещание применяет функцию f к элементам аргументов контейнеров и самих скаляров в As. Одноэлементные и отсутствующие измерения расширяются, чтобы соответствовать размерам других аргументов, путем виртуального повторения значения. По умолчанию только ограниченное число типов рассматриваются как скаляры, включая Numbers, Strings, Symbols, Types, Functions и некоторые распространенные одиночные значения, такие как missing и nothing. Все остальные аргументы перебираются или индексируются поэлементно.

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

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

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

Примеры

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

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

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

julia> parse.(Int, ["1", "2"])
2-element Vector{Int64}:
 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 Vector{Vector{Int64}}:
 [1, 1]
 [2, 2]

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

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 Vector{Float64}:
  1.0
 -2.0

julia> A
2-element Vector{Float64}:
 1.0
 0.0

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

julia> A
2-element Vector{Float64}:
  1.0
 -2.0

@. 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 Vector{Float64}:
 3.5244129544236893
 4.727892280477045
 3.4233600241796016

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

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

Затем необходимо написать метод(ы) (по крайней мере, similar) для работы с Broadcasted{MyContainerStyle}. Также существуют несколько предопределенных подтипов BroadcastStyle, которые вы можете использовать; см. главу Интерфейсы для получения дополнительной информации.

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.

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

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

Broadcast.broadcastable(x)

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

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

Если x не является массивом, но поддерживает итерацию, индексирование, и его тип поддерживает ndims, то broadcastable(::typeof(x)) может быть реализовано, чтобы просто вернуть себя. Кроме того, если x определяет свой собственный BroadcastStyle, то он должен определить свой метод broadcastable , чтобы вернуть себя, чтобы пользовательский стиль имел какой-либо эффект.

Примеры

julia> Broadcast.broadcastable([1,2,3]) # like `identity` since arrays already support axes and indexing
3-element Vector{Int64}:
 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")

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)
()

combine_styles(cs...) -> BroadcastStyle

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

Примеры

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

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}()

getindex(A, inds...)

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

Примеры

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

julia> getindex(A, 1)
1

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

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

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

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

Примеры

julia> A = zeros(2,2);

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

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

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

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

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

Примеры

julia> A = zeros(5, 5);

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

julia> Ainds = CartesianIndices((2:3, 2:3));

julia> Binds = CartesianIndices(B);

julia> copyto!(A, Ainds, B, Binds)
5×5 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0
 0.0  1.0  2.0  0.0  0.0
 0.0  3.0  4.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0

copy!(dst, src) -> dst

Вспомогательная copy массива src в массив dst, удаляя при этом все ранее существующие элементы в dst. Если dst и src одного типа, то dst == src должен сохраняться после вызова. Если dst и src многомерные массивы, они должны иметь одинаковые axes.

См. также copyto!.

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 Vector{Foo}:
 #undef
 #undef
 #undef

julia> isassigned(v, 1)
false

Colon()

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

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

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

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

CartesianIndices(sz::Dims) -> R
CartesianIndices((istart:[istep:]istop, jstart:[jstep:]jstop, ...)) -> R

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

for j = jstart:jstep:jstop
    for i = istart:istep: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)))
CartesianIndices((2, 3))

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

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

julia> cartesian = CartesianIndices((1:3, 1:2))
CartesianIndices((1:3, 1:2))

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

julia> cartesian = CartesianIndices((1:2:5, 1:2))
CartesianIndices((1:2:5, 1:2))

julia> cartesian[2, 2]
CartesianIndex(3, 2)

Расширение

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

julia> CIs = CartesianIndices((2:3, 5:6))
CartesianIndices((2:3, 5:6))

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

julia> CIs .+ CI
CartesianIndices((5:6, 9:10))

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

Dims{N}

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

LinearIndices(A::AbstractArray)

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

Для массивов с обычным индексированием (индексы начинаются с 1) или любого многомерного массива линейные индексы изменяются от 1 до length(A). Однако, для массивов с нестандартным индексированием линейные индексы 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

to_indices(A, I::Tuple)

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

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

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

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

Примеры

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

julia> to_indices(A, (1,1,2,2))
(1, 1, 2, 2)

julia> to_indices(A, (1,1,2,20)) # no bounds checking
(1, 1, 2, 20)

julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # exotic index
(1, 2, 3, 4)

julia> to_indices(A, ([1,1], 1:2, 3, 4))
([1, 1], 1:2, 3, 4)

julia> to_indices(A, (1,2)) # no shape checking
(1, 2)

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.

checkindex(Bool, inds::AbstractUnitRange, index)

Возвращает true если данный index находится в пределах границ inds. Пользовательские типы, которые хотели бы выступать в роли индексов для всех массивов, могут расширить этот метод, чтобы реализовать специализированную проверку границ.

См. также checkbounds.

Примеры

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

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

elsize(type)

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

Примеры

julia> Base.elsize(rand(Float32, 10))
4

view(A, inds...)

Подобно getindex, но возвращает лёгкий массив, который лениво ссылается (или фактически является представлением в) родительский массив A по указанному индексу или индексам getindex вместо того, чтобы жадно извлекать элементы или строить скопированный подмножество. Вызов getindex или setindex! на возвращаемом значении (часто SubArray) вычисляет индексы для доступа или изменения родительского массива на лету. Поведение не определено, если форма родительского массива изменяется после вызова view, потому что нет проверки границ для родительского массива; например, это может привести к ошибке сегментации.

Некоторые неизменяемые родительские массивы (например, диапазоны) могут выбрать просто вычисление нового массива в некоторых обстоятельствах вместо возврата SubArray если это эффективно и обеспечивает совместимые семантики.

Примеры

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

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

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

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

julia> view(2:5, 2:3) # returns a range as type is immutable
3:4

@view A[inds...]

Преобразовать выражение индексирования A[inds...] в эквивалентный вызов view.

Это можно применять только непосредственно к одному выражению индексирования и особенно полезно для выражений, которые включают специальные begin или end синтаксисы индексирования, такие как A[begin, 2:end-1] (поскольку они не поддерживаются обычной функцией view).

Обратите внимание, что @view не может использоваться в качестве целевого объекта для обычной операции присваивания (например, @view(A[1, 2:end]) = ...), ни не-декорированное индексированное присваивание (A[1, 2:end] = ...) или широковещательное индексированное присваивание (A[1, 2:end] .= ...) не создаст копию. Однако, он может быть полезен для обновления широковещательных присваиваний, таких как @view(A[1, 2:end]) .+= 1, поскольку это простой синтаксис для @view(A[1, 2:end]) .= @view(A[1, 2:end]) + 1, а выражение индексирования в правой части в противном случае создало бы копию без @view.

См. также @views для переключения всего блока кода на использование представлений для нескалярного индексирования.

Примеры

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

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

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

julia> A
2×2 Matrix{Int64}:
 0  2
 0  4

@views expression

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

Аналогично, @views преобразует слайсы строк в представления SubString.

Примеры

julia> A = zeros(3, 3);

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

julia> A
3×3 Matrix{Float64}:
 1.0  1.0  1.0
 2.0  2.0  2.0
 3.0  3.0  3.0

parent(A)

Возвращает базовый «родительский массив». Этот родительский массив объектов типов SubArray, ReshapedArray или LinearAlgebra.Transpose — это то, что передавалось в качестве аргумента в view, reshape, transpose и т. д. при создании объекта. Если вход не является обернутым объектом, возвращает сам вход. Если вход обернут несколько раз, удаляется только самый внешний оберток.

Примеры

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

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

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

parentindices(A)

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

Примеры

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

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

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

selectdim(A, d::Integer, i)

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

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

См. также: eachslice.

Примеры

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

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

julia> selectdim(A, 2, 3:4)
2×2 view(::Matrix{Int64}, :, 3:4) with eltype Int64:
 3  4
 7  8

reinterpret(type, A)

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

Примеры

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

reinterpret(reshape, T, A::AbstractArray{S}) -> B

Изменяет интерпретацию A, потребляя или добавляя "измерение канала".

Если sizeof(T) = n*sizeof(S) для n>1, первое измерение A должно иметь размер n, и у B отсутствует первое измерение A. И наоборот, если sizeof(S) = n*sizeof(T) для n>1, у B появляется новое первое измерение размером n. Размеры измерений остаются неизменными, если sizeof(T) == sizeof(S).

Примеры

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

julia> reinterpret(reshape, Complex{Int}, A)    # the result is a vector
2-element reinterpret(reshape, Complex{Int64}, ::Matrix{Int64}) with eltype Complex{Int64}:
 1 + 3im
 2 + 4im

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

julia> reinterpret(reshape, Int, a)             # the result is a matrix
3×2 reinterpret(reshape, Int64, ::Vector{Tuple{Int64, Int64, Int64}}) with eltype Int64:
 1  4
 2  5
 3  6

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

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

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

Общее число элементов не должно меняться.

Примеры

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

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

julia> reshape(A, 2, :)
2×8 Matrix{Int64}:
 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

dropdims(A; dims)

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

size(A,d) должно быть равно 1 для каждого d в dims, а повторяющиеся измерения или числа вне 1:ndims(A) запрещены.

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

См. также: reshape, vec.

Примеры

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

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

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

vec(a::AbstractArray) -> AbstractVector

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

Примеры

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

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

julia> vec(1:3)
1:3

См. также reshape, dropdims.

SubArray{T,N,P,I,L} <: AbstractArray{T,N}

N-мерное представление в родительском массиве (типа P) с типом элемента T, ограниченного кортежем индексов (типа I). L является истинным для типов, которые поддерживают быструю линейную индексацию, и false в противном случае.

Создайте SubArray с помощью функции view.

cat(A...; dims)

Конкатенирует входные массивы вдоль измерений, указанных в dims.

Вдоль измерения d in dims, размер результирующего массива равен sum(size(a,d) for a in A).

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

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

Специальный случай dims=1 — vcat, а dims=2 — hcat. См. также hvcat, hvncat, stack, repeat.

Ключевое слово также принимает Val(dims).

Примеры

julia> cat([1 2; 3 4], [pi, pi], fill(10, 2,3,1); dims=2)  # same as hcat
2×6×1 Array{Float64, 3}:
[:, :, 1] =
 1.0  2.0  3.14159  10.0  10.0  10.0
 3.0  4.0  3.14159  10.0  10.0  10.0

julia> cat(true, trues(2,2), trues(4)', dims=(1,2))  # block-diagonal
4×7 Matrix{Bool}:
 1  0  0  0  0  0  0
 0  1  1  0  0  0  0
 0  1  1  0  0  0  0
 0  0  0  1  1  1  1

julia> cat(1, [2], [3;;]; dims=Val(2))
1×3 Matrix{Int64}:
 1  2  3

vcat(A...)

Конкатенирует массивы или числа вертикально. Эквивалентно cat(A...; dims=1), и синтаксису [a; b; c].

Для конкатенации большого вектора массивов, reduce(vcat, A) использует эффективный метод, когда A isa AbstractVector{<:AbstractVecOrMat}, а не работает попарно.

См. также hcat, Iterators.flatten, stack.

Примеры

julia> v = vcat([1,2], [3,4])
4-element Vector{Int64}:
 1
 2
 3
 4

julia> v == vcat(1, 2, [3,4])  # accepts numbers
true

julia> v == [1; 2; [3,4]]  # syntax for the same operation
true

julia> summary(ComplexF64[1; 2; [3,4]])  # syntax for supplying the element type
"4-element Vector{ComplexF64}"

julia> vcat(range(1, 2, length=3))  # collects lazy ranges
3-element Vector{Float64}:
 1.0
 1.5
 2.0

julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # row vector and a matrix
([10 20 30], [4.0 5.0 6.0; 7.0 8.0 9.0])

julia> vcat(two...)
3×3 Matrix{Float64}:
 10.0  20.0  30.0
  4.0   5.0   6.0
  7.0   8.0   9.0

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

julia> reduce(vcat, vs)  # more efficient than vcat(vs...)
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

julia> ans == collect(Iterators.flatten(vs))
true

hcat(A...)

Конкатенирует массивы или числа горизонтально. Эквивалентно cat(A...; dims=2), и синтаксису [a b c] или [a;; b;; c].

Для большого вектора массивов, reduce(hcat, A) использует эффективный метод, когда A isa AbstractVector{<:AbstractVecOrMat}. Для вектора векторов, это также может быть записано как stack(A).

См. также vcat, hvcat.

Примеры

julia> hcat([1,2], [3,4], [5,6])
2×3 Matrix{Int64}:
 1  3  5
 2  4  6

julia> hcat(1, 2, [30 40], [5, 6, 7]')  # accepts numbers
1×7 Matrix{Int64}:
 1  2  30  40  5  6  7

julia> ans == [1 2 [30 40] [5, 6, 7]']  # syntax for the same operation
true

julia> Float32[1 2 [30 40] [5, 6, 7]']  # syntax for supplying the eltype
1×7 Matrix{Float32}:
 1.0  2.0  30.0  40.0  5.0  6.0  7.0

julia> ms = [zeros(2,2), [1 2; 3 4], [50 60; 70 80]];

julia> reduce(hcat, ms)  # more efficient than hcat(ms...)
2×6 Matrix{Float64}:
 0.0  0.0  1.0  2.0  50.0  60.0
 0.0  0.0  3.0  4.0  70.0  80.0

julia> stack(ms) |> summary  # disagrees on a vector of matrices
"2×2×3 Array{Float64, 3}"

julia> hcat(Int[], Int[], Int[])  # empty vectors, each of size (0,)
0×3 Matrix{Int64}

julia> hcat([1.1, 9.9], Matrix(undef, 2, 0))  # hcat with empty 2×0 Matrix
2×1 Matrix{Any}:
 1.1
 9.9

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

Горизонтальная и вертикальная конкатенация в одном вызове. Эта функция вызывается для синтаксиса блочных матриц. Первый аргумент задаёт количество аргументов для конкатенации в каждой блочной строке. Если первый аргумент — целое число n, то все блочные строки предполагаются с n блочными столбцами.

Примеры

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 Matrix{Int64}:
 1  2  3
 4  5  6

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

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

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

hvncat(dim::Int, row_first, values...)
hvncat(dims::Tuple{Vararg{Int}}, row_first, values...)
hvncat(shape::Tuple{Vararg{Tuple}}, row_first, values...)

Горизонтальное, вертикальное и n-мерное конкатенация многих values в одном вызове.

Эта функция вызывается для синтаксиса блочных матриц. Первый аргумент либо определяет форму конкатенации, аналогично hvcat, как кортеж кортежей, либо размеры, которые указывают количество элементов вдоль каждой оси, и используется для определения размеров выходных данных. Формат dims более производителен и используется по умолчанию, когда операция конкатенации имеет одинаковое количество элементов вдоль каждой оси (например, [a b; c d;;; e f ; g h]). Формат shape используется, когда количество элементов вдоль каждой оси не сбалансировано (например, [a b ; c]). Несбалансированный синтаксис требует дополнительных затрат на проверку. Формат dim является оптимизацией для конкатенации только по одной размерности. row_first указывает, как values упорядочены. Значения первого и второго элементов shape также меняются местами в зависимости от row_first.

Примеры

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]
1×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  2  3

[:, :, 2] =
 4  5  6

julia> hvncat((2,1,3), false, a,b,c,d,e,f)
2×1×3 Array{Int64, 3}:
[:, :, 1] =
 1
 2

[:, :, 2] =
 3
 4

[:, :, 3] =
 5
 6

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

[:, :, 2] =
 3  4

[:, :, 3] =
 5  6

julia> hvncat(((3, 3), (3, 3), (6,)), true, a, b, c, d, e, f)
1×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  2  3

[:, :, 2] =
 4  5  6

Примеры для построения аргументов

[a b c ; d e f ;;;
 g h i ; j k l ;;;
 m n o ; p q r ;;;
 s t u ; v w x]
⇒ dims = (2, 3, 4)

[a b ; c ;;; d ;;;;]
 ___   _     _
 2     1     1 = elements in each row (2, 1, 1)
 _______     _
 3           1 = elements in each column (3, 1)
 _____________
 4             = elements in each 3d slice (4,)
 _____________
 4             = elements in each 4d slice (4,)
⇒ shape = ((2, 1, 1), (3, 1), (4,), (4,)) with `row_first` = true

stack(iter; [dims])

Объединяет набор массивов (или других итерируемых объектов) равного размера в один больший массив, располагая их вдоль одной или нескольких новых размерностей.

По умолчанию оси элементов размещаются первыми, что даёт size(result) = (size(first(iter))..., size(iter)...). Это имеет тот же порядок элементов, что и Iterators.flatten(iter).

С ключевым словом dims::Integer, вместо этого i-й элемент iter становится слайсом selectdim(result, dims, i), так что size(result, dims) == length(iter). В этом случае stack обращает действие eachslice с тем же dims.

Различные функции cat также объединяют массивы. Однако все они расширяют уже существующие (возможно, тривиальные) размерности массивов, а не размещают массивы вдоль новых размерностей. Они также принимают массивы в качестве отдельных аргументов, а не одного набора.

Примеры

julia> vecs = (1:2, [30, 40], Float32[500, 600]);

julia> mat = stack(vecs)
2×3 Matrix{Float32}:
 1.0  30.0  500.0
 2.0  40.0  600.0

julia> mat == hcat(vecs...) == reduce(hcat, collect(vecs))
true

julia> vec(mat) == vcat(vecs...) == reduce(vcat, collect(vecs))
true

julia> stack(zip(1:4, 10:99))  # accepts any iterators of iterators
2×4 Matrix{Int64}:
  1   2   3   4
 10  11  12  13

julia> vec(ans) == collect(Iterators.flatten(zip(1:4, 10:99)))
true

julia> stack(vecs; dims=1)  # unlike any cat function, 1st axis of vecs[1] is 2nd axis of result
3×2 Matrix{Float32}:
   1.0    2.0
  30.0   40.0
 500.0  600.0

julia> x = rand(3,4);

julia> x == stack(eachcol(x)) == stack(eachrow(x), dims=1)  # inverse of eachslice
true

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

julia> A = rand(5, 7, 11);

julia> E = eachslice(A, dims=2);  # a vector of matrices

julia> (element = size(first(E)), container = size(E))
(element = (5, 11), container = (7,))

julia> stack(E) |> size
(5, 11, 7)

julia> stack(E) == stack(E; dims=3) == cat(E...; dims=3)
true

julia> A == stack(E; dims=2)
true

julia> M = (fill(10i+j, 2, 3) for i in 1:5, j in 1:7);

julia> (element = size(first(M)), container = size(M))
(element = (2, 3), container = (5, 7))

julia> stack(M) |> size  # keeps all dimensions
(2, 3, 5, 7)

julia> stack(M; dims=1) |> size  # vec(container) along dims=1
(35, 2, 3)

julia> hvcat(5, M...) |> size  # hvcat puts matrices next to each other
(14, 15)

stack(f, args...; [dims])

Применяет функцию к каждому элементу набора и stack результат. Или к нескольким наборам, zip вместе.

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

См. также mapslices, eachcol.

Примеры

julia> stack(c -> (c, c-32), "julia")
2×5 Matrix{Char}:
 'j'  'u'  'l'  'i'  'a'
 'J'  'U'  'L'  'I'  'A'

julia> stack(eachrow([1 2 3; 4 5 6]), (10, 100); dims=1) do row, n
         vcat(row, row .* n, row ./ n)
       end
2×9 Matrix{Float64}:
 1.0  2.0  3.0   10.0   20.0   30.0  0.1   0.2   0.3
 4.0  5.0  6.0  400.0  500.0  600.0  0.04  0.05  0.06

vect(X...)

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

Примеры

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

circshift(A, shifts)

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

См. также: circshift!, circcopy!, bitrotate, <<.

Примеры

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

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

julia> circshift(b, (-1,0))
4×4 Matrix{Int64}:
 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 BitVector:
 1
 1
 0
 0
 1

julia> circshift(a, 1)
5-element BitVector:
 1
 1
 1
 0
 0

julia> circshift(a, -1)
5-element BitVector:
 1
 0
 0
 1
 1

circshift!(dest, src, shifts)

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

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

См. также circshift.

circcopy!(dest, src)

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

См. также: circshift.

Примеры

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

findall(A)

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

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

См. также: findfirst, searchsorted.

Примеры

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

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

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

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

julia> findall(falses(3))
Int64[]

findall(f::Function, A)

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

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

Примеры

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

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

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

julia> findall(!iszero, A)
4-element Vector{CartesianIndex{2}}:
 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 Vector{Symbol}:
 :A
 :C

findfirst(A)

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

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

См. также: findall, findnext, findlast, searchsortedfirst.

Примеры

julia> A = [false, false, true, false]
4-element Vector{Bool}:
 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 Matrix{Bool}:
 0  0
 1  0

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

findfirst(predicate::Function, A)

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

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

Примеры

julia> A = [1, 4, 2, 2]
4-element Vector{Int64}:
 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 Matrix{Int64}:
 1  4
 2  2

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

findlast(A)

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

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

См. также: findfirst, findprev, findall.

Примеры

julia> A = [true, false, true, false]
4-element Vector{Bool}:
 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 Matrix{Bool}:
 1  0
 1  0

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

findlast(predicate::Function, A)

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

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

Примеры

julia> A = [1, 2, 3, 4]
4-element Vector{Int64}:
 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 Matrix{Int64}:
 1  2
 3  4

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

findnext(A, i)

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

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

Примеры

julia> A = [false, false, true, false]
4-element Vector{Bool}:
 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 Matrix{Bool}:
 0  0
 1  0

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

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)

findprev(A, i)

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

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

См. также: findnext, findfirst, findall.

Примеры

julia> A = [false, false, true, true]
4-element Vector{Bool}:
 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 Matrix{Bool}:
 0  0
 1  1

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

findprev(predicate::Function, A, i)

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

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

Примеры

julia> A = [4, 6, 1, 2]
4-element Vector{Int64}:
 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 Matrix{Int64}:
 4  6
 1  2

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

permutedims(A::AbstractArray, perm)

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

См. также permutedims!, PermutedDimsArray, transpose, invperm.

Примеры

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> perm = (3, 1, 2); # put the last dimension first

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

[:, :, 2] =
 3  4
 7  8

julia> A == permutedims(B, invperm(perm)) # the inverse permutation
true

Для каждой размерности i массива B = permutedims(A, perm), соответствующая размерность массива A будет perm[i]. Это означает, что выполняется равенство size(B, i) == size(A, perm[i]).

julia> A = randn(5, 7, 11, 13);

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

julia> B = permutedims(A, perm);

julia> size(B)
(13, 5, 11, 7)

julia> size(A)[perm] == ans
true

permutedims(m::AbstractMatrix)

Меняет местами размерности матрицы m, переставляя элементы по диагонали матрицы. Отличается от LinearAlgebra's 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 Matrix{Matrix{Int64}}:
 [1 2; 3 4]     [5 6; 7 8]
 [9 10; 11 12]  [13 14; 15 16]

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

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

permutedims(v::AbstractVector)

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

Примеры

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

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

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

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

permutedims!(dest, src, perm)

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

См. также permutedims.

PermutedDimsArray(A, perm) -> B

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

См. также permutedims, invperm.

Примеры

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

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)

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

Накопительная операция op по размерности dims массива A (необязательный параметр dims для векторов). Изначальное значение init может быть предоставлено в качестве ключевого аргумента. См. также accumulate! для использования предварительно выделенного выходного массива, что повышает производительность и позволяет управлять точностью выходных данных (например, чтобы избежать переполнения).

Для стандартных операций существуют специализированные варианты accumulate, см. cumsum, cumprod. Для ленивой версии см. Iterators.accumulate.

Примеры

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

julia> accumulate(min, (1, -2, 3, -4, 5), init=0)
(0, -2, -2, -4, -4)

julia> accumulate(/, (2, 4, Inf), init=100)
(50.0, 12.5, 0.0)

julia> accumulate(=>, i^2 for i in 1:3)
3-element Vector{Any}:
          1
        1 => 4
 (1 => 4) => 9

julia> accumulate(+, fill(1, 3, 4))
3×4 Matrix{Int64}:
 1  4  7  10
 2  5  8  11
 3  6  9  12

julia> accumulate(+, fill(1, 2, 5), dims=2, init=100.0)
2×5 Matrix{Float64}:
 101.0  102.0  103.0  104.0  105.0
 101.0  102.0  103.0  104.0  105.0

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

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

См. также accumulate, cumsum!, cumprod!.

Примеры

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

julia> y = rand(5);

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

julia> y
5-element Vector{Float64}:
 1.0
 1.0
 3.0
 3.0
 6.0

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

julia> B = similar(A);

julia> accumulate!(-, B, A, dims=1)
2×3 Matrix{Int64}:
  1   2   3
 -3  -3  -3

julia> accumulate!(*, B, A, dims=2, init=10)
2×3 Matrix{Int64}:
 10   20    60
 40  200  1200

cumprod(A; dims::Integer)

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

Примеры

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

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

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

cumprod(itr)

Кумуляционное произведение итератора.

См. также cumprod!, accumulate, cumsum.

Примеры

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

julia> cumprod((1, 2, 1, 3, 1))
(1, 2, 2, 6, 6)

julia> cumprod("julia")
5-element Vector{String}:
 "j"
 "ju"
 "jul"
 "juli"
 "julia"

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

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

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

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

cumsum(A; dims::Integer)

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

Примеры

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

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

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

julia> cumsum(Int8[100, 28])
2-element Vector{Int64}:
 100
 128

julia> accumulate(+,Int8[100, 28])
2-element Vector{Int8}:
  100
 -128

cumsum(itr)

Кумулятивная сумма итератора.

См. также accumulate для применения функций, отличных от +.

Примеры

julia> cumsum(1:3)
3-element Vector{Int64}:
 1
 3
 6

julia> cumsum((true, false, true, false, true))
(1, 1, 2, 2, 3)

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

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

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

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

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

Примеры

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

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

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

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

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

См. также: fill, Iterators.repeated, Iterators.cycle.

Примеры

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

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

repeat(A::AbstractArray; inner=ntuple(Returns(1), ndims(A)), outer=ntuple(Returns(1), ndims(A)))

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

Примеры

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

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

julia> repeat([1 2; 3 4], inner=(2, 1), outer=(1, 3))
4×6 Matrix{Int64}:
 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"

rot180(A)

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

Примеры

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

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

rot180(A, k)

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

Примеры

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

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

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

rotl90(A)

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

Примеры

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

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

rotl90(A, k)

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

Примеры

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

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

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

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

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

rotr90(A)

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

Примеры

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

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

rotr90(A, k)

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

Примеры

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

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

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

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

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

mapslices(f, A; dims)

Преобразуйте заданные размеры массива A, применяя функцию f к каждому срезу в форме A[..., :, ..., :, ...], с двоеточием в каждом d в dims. Результаты конкатенируются вдоль оставшихся измерений.

Например, если dims = [1,2] и A имеют 4 измерения, тогда f вызывается на x = A[:,:,i,j] для всех i и j, и f(x) становится R[:,:,i,j] в результате R.

См. также eachcol или eachslice, используемые с map или stack.

Примеры

julia> A = reshape(1:30,(2,5,3))
2×5×3 reshape(::UnitRange{Int64}, 2, 5, 3) with eltype Int64:
[:, :, 1] =
 1  3  5  7   9
 2  4  6  8  10

[:, :, 2] =
 11  13  15  17  19
 12  14  16  18  20

[:, :, 3] =
 21  23  25  27  29
 22  24  26  28  30

julia> f(x::Matrix) = fill(x[1,1], 1,4);  # returns a 1×4 matrix

julia> B = mapslices(f, A, dims=(1,2))
1×4×3 Array{Int64, 3}:
[:, :, 1] =
 1  1  1  1

[:, :, 2] =
 11  11  11  11

[:, :, 3] =
 21  21  21  21

julia> f2(x::AbstractMatrix) = fill(x[1,1], 1,4);

julia> B == stack(f2, eachslice(A, dims=3))
true

julia> g(x) = x[begin] // x[end-1];  # returns a number

julia> mapslices(g, A, dims=[1,3])
1×5×1 Array{Rational{Int64}, 3}:
[:, :, 1] =
 1//21  3//23  1//5  7//27  9//29

julia> map(g, eachslice(A, dims=2))
5-element Vector{Rational{Int64}}:
 1//21
 3//23
 1//5
 7//27
 9//29

julia> mapslices(sum, A; dims=(1,3)) == sum(A; dims=(1,3))
true

Обратите внимание, что в eachslice(A; dims=2), указанное измерение — это то, в котором нет двоеточия в срезе. Это view(A,:,i,:), тогда как mapslices(f, A; dims=(1,3)) использует A[:,i,:]. Функция f может изменять значения в срезе без влияния на A.

eachrow(A::AbstractVecOrMat) <: AbstractVector

Создать объект RowSlices, который является вектором строк матрицы или вектора A. Срезы строк возвращаются в виде AbstractVector представлений A.

Для обратного преобразования, см. stack(rows; dims=1).

См. также eachcol, eachslice и mapslices.

Пример

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

julia> s = eachrow(a)
2-element RowSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}}:
 [1, 2]
 [3, 4]

julia> s[1]
2-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2

eachcol(A::AbstractVecOrMat) <: AbstractVector

Создать объект ColumnSlices, который является вектором столбцов матрицы или вектора A. Срезы столбцов возвращаются в виде AbstractVector представлений A.

Для обратного преобразования, см. stack(cols) или reduce(hcat, cols).

См. также eachrow, eachslice и mapslices.

Пример

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

julia> s = eachcol(a)
2-element ColumnSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}}:
 [1, 3]
 [2, 4]

julia> s[1]
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

eachslice(A::AbstractArray; dims, drop=true)

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

Если drop = true (по умолчанию), внешний Slices будет опускать внутренние измерения, а порядок измерений будет соответствовать порядку в dims. Если drop = false, то Slices будет иметь такую же размерность, как и базовый массив, с внутренними измерениями размером 1.

См. stack(slices; dims) для обратного преобразования eachslice(A; dims::Integer).

См. также eachrow, eachcol, mapslices и selectdim.

Пример

julia> m = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> s = eachslice(m, dims=1)
3-element RowSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}}:
 [1, 2, 3]
 [4, 5, 6]
 [7, 8, 9]

julia> s[1]
3-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2
 3

julia> eachslice(m, dims=1, drop=false)
3×1 Slices{Matrix{Int64}, Tuple{Int64, Colon}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}, 2}:
 [1, 2, 3]
 [4, 5, 6]
 [7, 8, 9]

invperm(v)

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

См. также sortperm, invpermute!, isperm, permutedims.

Примеры

julia> p = (2, 3, 1);

julia> invperm(p)
(3, 1, 2)

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

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

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

julia> B = A[v]
4-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> B[invperm(v)]
4-element Vector{Char}:
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)

isperm(v) -> Bool

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

Примеры

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

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 Vector{Int64}:
 1
 4
 3
 1

invpermute!(v, p)

Как permute!, но применяется обратная перестановка.

Примеры

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

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

julia> invpermute!(A, perm);

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

reverse(A; dims=:)

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

Примеры

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

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

julia> reverse(b)
2×2 Matrix{Int64}:
 4  3
 2  1

reverseind(v, i)

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

Примеры

julia> s = "Julia🚀"
"Julia🚀"

julia> r = reverse(s)
"🚀ailuJ"

julia> for i in eachindex(s)
           print(r[reverseind(r, i)])
       end
Julia🚀

reverse!(v [, start=firstindex(v) [, stop=lastindex(v) ]]) -> v

Функция на месте для reverse.

Примеры

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

julia> reverse!(A);

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

reverse!(A; dims=:)

Как reverse, но работает на месте в A.