Массивы

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 перескакивает в памяти на [stride(A, d)] слота. Строго типизированные массивы особенно важны и полезны, потому что их можно иногда напрямую передавать как указатели в библиотеки на других языках, таких как BLAS.

StridedVector{T}

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

StridedMatrix{T}

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

StridedVecOrMat{T}

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

GenericMemory{kind::Symbol, T, addrspace=Core.CPU} <: DenseVector{T}

Массив фиксированного размера DenseVector{T}.

kind в настоящее время может быть либо :not_atomic, либо :atomic. Подробную информацию о том, что подразумевает :atomic, см. в AtomicMemory.

addrspace в настоящее время может быть только Core.CPU. Он предназначен для расширения другими системами, такими как графические процессоры, которые могут определить такие значения, как:

module CUDA
const Generic = bitcast(Core.AddrSpace{CUDA}, 0)
const Global = bitcast(Core.AddrSpace{CUDA}, 1)
end

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

Memory{T} == GenericMemory{:not_atomic, T, Core.CPU}

Массив фиксированного размера DenseVector{T}.

`memoryref(::GenericMemory)`

Создать GenericMemoryRef из объекта памяти. Это не вызывает ошибок, но полученная память будет указывать за пределы границ, если и только если память пуста.

memoryref(::GenericMemory, index::Integer)
memoryref(::GenericMemoryRef, index::Integer)

Создать GenericMemoryRef из объекта памяти и смещения (индекса 1-основания), которое также может быть отрицательным. Это всегда возвращает объект в пределах границ, и выбросит ошибку, если это невозможно (потому что индекс приведет к сдвигу за пределы границ базовой памяти).

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

Создать Array, с типом элемента 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...)

Создайте Array, с типом элемента 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}

Эффективное по памяти 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 для описания их расположения. Часто используются специальные типы массивов LinearIndices и CartesianIndices для эффективного представления этих массивов целых чисел и CartesianIndex соответственно.

Обратите внимание, что keys массива может быть не самым эффективным типом индексов; для максимальной производительности используйте 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] поскольку 1 + 2*(3 - 1) = 5.

См. также IndexCartesian.

IndexCartesian()

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

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

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

Вычисление декартовых индексов из линейного индекса значительно дороже, чем обратный процесс. Первый операция требует деления — очень дорогостоящей операции — в то время как последний использует только умножение и сложение и является практически бесплатным. Эта асимметрия означает, что использование линейной индексации с 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. Единичные и отсутствующие измерения расширяются для соответствия размерам других аргументов путем виртуального повторения значения. По умолчанию только ограниченное количество типов считаются скалярными, включая Number, String , Symbol , Type , Function и некоторые общие единичные значения, такие как 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 не является AbstractArray, но поддерживает axes, индексирование, и его тип поддерживает 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.

Каждый индекс может быть любым поддерживаемым типом индекса, например, Integer, CartesianIndex, диапазоном или массивом поддерживаемых индексов. : может использоваться для выбора всех элементов по определенной размерности, а булевый массив (например, Array{Bool} или BitArray) может использоваться для фильтрации элементов, где соответствующий индекс true.

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

Подробности см. в разделе руководства по индексированию массивов.

Примеры

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

julia> getindex(A, 2, 1)
3

julia> getindex(A, CartesianIndex(2, 1))
3

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

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

julia> getindex(A, A .> 2)
2-element Vector{Int64}:
 3
 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

nextind(A, i)

Возвращает индекс, следующий за i в A.

Возвращаемый индекс часто эквивалентен i + 1 для целочисленного i. Эта функция может быть полезна для обобщенного кода.

См. также: prevind.

Примеры

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

julia> nextind(x, 1) # valid result
2

julia> nextind(x, 4) # invalid result
5

julia> nextind(x, CartesianIndex(1, 1)) # valid result
CartesianIndex(2, 1)

julia> nextind(x, CartesianIndex(2, 2)) # invalid result
CartesianIndex(1, 3)

prevind(A, i)

Возвращает индекс, предшествующий i в A.

Возвращаемый индекс часто эквивалентен i - 1 для целочисленного i. Эта функция может быть полезна для обобщенного кода.

См. также: nextind.

Примеры

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

julia> prevind(x, 4) # valid result
3

julia> prevind(x, 1) # invalid result
0

julia> prevind(x, CartesianIndex(2, 2)) # valid result
CartesianIndex(1, 2)

julia> prevind(x, CartesianIndex(1, 1)) # invalid result
CartesianIndex(2, 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.

I::CartesianIndex рассматривается как «скаляр» (не контейнер) для broadcast. Для итерации по компонентам CartesianIndex, преобразуйте его в кортеж с помощью Tuple(I).

Примеры

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). Однако для 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

to_indices(A, I::Tuple)

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

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

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

Более сложные типы индексов могут потребовать больше контекста о размерности, в которую они индексируют. Для поддержки этих случаев 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 по заданному индексу или индексам inds вместо того, чтобы жадно извлекать элементы или строить скопированное подмножество. Вызов 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 is a view, not a copy
           b .= row      # assign every element to the row index
       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, SubString, 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{Out}, x::In)

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

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

julia> reinterpret(NTuple{2, UInt8}, 0x1234)
(0x34, 0x12)

julia> reinterpret(UInt16, (0x34, 0x12))
0x1234

julia> reinterpret(Tuple{UInt16, UInt8}, (0x01, 0x0203))
(0x0301, 0x02)

reinterpret(T::DataType, A::AbstractArray)

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

Эта функция также работает с «ленивыми» массивами, элементы которых не вычисляются, пока явно не будут получены. Например, reinterpret на диапазоне 1:6 работает аналогично на плотной векторе collect(1:6):

julia> reinterpret(Float32, UInt32[1 2 3 4 5])
1×5 reinterpret(Float32, ::Matrix{UInt32}):
 1.0f-45  3.0f-45  4.0f-45  6.0f-45  7.0f-45

julia> reinterpret(Complex{Int}, 1:6)
3-element reinterpret(Complex{Int64}, ::UnitRange{Int64}):
 1 + 2im
 3 + 4im
 5 + 6im

Если расположение битов заполнения не совпадает между T и eltype(A), полученный массив будет только для чтения или только для записи, чтобы предотвратить запись или чтение недопустимых битов соответственно.

julia> a = reinterpret(Tuple{UInt8, UInt32}, UInt32[1, 2])
1-element reinterpret(Tuple{UInt8, UInt32}, ::Vector{UInt32}):
 (0x01, 0x00000002)

julia> a[1] = 3
ERROR: Padding of type Tuple{UInt8, UInt32} is not compatible with type UInt32.

julia> b = reinterpret(UInt32, Tuple{UInt8, UInt32}[(0x01, 0x00000002)]); # showing will error

julia> b[1]
ERROR: Padding of type UInt32 is not compatible with type Tuple{UInt8, UInt32}.

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 имеет значение true для типов, которые поддерживают быструю линейную индексацию, и 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> a = [1 2 3]
1×3 Matrix{Int64}:
 1  2  3

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

julia> cat(a, b; dims=1)
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> cat(a, b; dims=2)
1×6 Matrix{Int64}:
 1  2  3  4  5  6

julia> cat(a, b; dims=(1, 2))
2×6 Matrix{Int64}:
 1  2  3  0  0  0
 0  0  0  4  5  6

Дополнительная помощь

Конкатенация 3D массивов:

julia> a = ones(2, 2, 3);

julia> b = ones(2, 2, 4);

julia> c = cat(a, b; dims=3);

julia> size(c) == (2, 2, 7)
true

Конкатенация массивов разных размеров:

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

julia> a = "aaa";

julia> b = "bbb";

julia> cat(a, b; dims=1)
2-element Vector{String}:
 "aaa"
 "bbb"

julia> cat(a, b; dims=2)
1×2 Matrix{String}:
 "aaa"  "bbb"

julia> a * b
"aaabbb"

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 определяет величину сдвига в каждом измерении.

См. также 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 если не найдено. Это работает для массивов, строк и большинства других коллекций, которые поддерживают getindex, keys(A) и nextind.

Индексы имеют тот же тип, что и те, которые возвращаются 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)

julia> findnext(isspace, "a b c", 3)
4

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 возвращает true, или nothing, если не найдено. Это работает для массивов, строк и большинства других коллекций, поддерживающих getindex, keys(A) и nextind.

Индексы имеют тот же тип, что и возвращаемые 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)

julia> findprev(isspace, "a b c", 3)
2

permutedims(A::AbstractArray, perm)
permutedims(A::AbstractMatrix)

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

Если A является 2-мерным массивом (AbstractMatrix), то perm по умолчанию равно (2,1), меняя местами две оси A (строки и столбцы матрицы). Это отличается от transpose тем, что операция не рекурсивна, что особенно полезно для массивов с нечисловыми значениями (где рекурсивная transpose вызовет ошибку) и/или 2-мерных массивов, которые не представляют линейные операторы.

Для 1-мерных массивов см. permutedims(v::AbstractVector), который возвращает 1-строчную «матрицу».

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

Примеры

2-мерные массивы:

В отличие от transpose, permutedims можно использовать для перестановки строк и столбцов 2-мерных массивов с произвольными нечисловыми элементами, такими как строки:

julia> A = ["a" "b" "c"
            "d" "e" "f"]
2×3 Matrix{String}:
 "a"  "b"  "c"
 "d"  "e"  "f"

julia> permutedims(A)
3×2 Matrix{String}:
 "a"  "d"
 "b"  "e"
 "c"  "f"

И permutedims даёт результаты, которые отличаются от 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]

Многомерные массивы

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(v::AbstractVector)

Преобразует вектор v в 1 × length(v) строчную матрицу. Отличается от transpose тем, что операция не рекурсивная, что особенно полезно для массивов с нечисловыми значениями (где рекурсивная transpose может выдать ошибку).

Примеры

В отличие от transpose, permutedims может применяться к векторам с произвольными нечисловыми элементами, такими как строки:

julia> permutedims(["a", "b", "c"])
1×3 Matrix{String}:
 "a"  "b"  "c"

Для векторов чисел permutedims(v) работает почти так же, как transpose(v), за исключением того, что тип возвращаемого значения отличается (используется reshape, а не LinearAlgebra.Transpose представление, хотя оба совместно используют память с исходным массивом v):

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

julia> p = permutedims(v)
1×4 Matrix{Int64}:
 1  2  3  4

julia> r = transpose(v)
1×4 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3  4

julia> p == r
true

julia> typeof(r)
Transpose{Int64, Vector{Int64}}

julia> p[1] = 5; r[2] = 6; # mutating p or r also changes v

julia> v # shares memory with both p and r
4-element Vector{Int64}:
 5
 6
 3
 4

Однако permutedims даёт результаты, которые отличаются от transpose для векторов, элементы которых сами являются числовыми матрицами:

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); еще быстрее записать в предварительно выделенный выходной массив с помощью u .= @view v[p].

(Хотя permute! перезаписывает v на месте, для отслеживания перемещённых элементов внутренне требуется некоторое выделение памяти).

См. также 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!, но применяется обратная перестановка.

Обратите внимание, что если у вас есть предварительно выделенный выходной массив (например, u = similar(v)), то быстрее использовать u[p] = v.

(invpermute! внутренне выделяет копию данных).

Примеры

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.