Arrays

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 задан явно
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 определяется по входным данным
4-element Vector{Float64}:
   2.360075077e-314
 NaN
   2.2671131793e-314
   2.299821756e-314

julia> similar(B, 2, 4, 1) # используйте typeof(B) и заданный размер
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}

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. Он предназначен для расширения другими системами, такими как GPU, которые могут определять такие значения, как:

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

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

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}

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

Обычно их следует создавать с помощью 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 из операций broadcasting, которые генерируют булевы элементы (включая точечные сравнения, такие как .==), а также из функций trues и falses.

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

Создает undef 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]

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

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) # устанавливает оба элемента в один и тот же [0.0, 0.0] вектор
2-element Vector{Vector{Float64}}:
 [0.0, 0.0]
 [0.0, 0.0]

julia> A[1][1] = 42; # изменяет заполненное значение на [42.0, 0.0]

julia> A # и A[1], и A[2] — это один и тот же вектор
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.

аналогичный(A::AbstractSparseMatrixCSC{Tv,Ti}, [::Type{TvNew}, ::Type{TiNew}, m::Integer, n::Integer]) где {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 являются изменяемыми и могут поддерживать 1-мерные массивы:

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  # все размерности d > ndims(A) имеют размер 1
true

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

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

ix = axes(v, 1)
ix[2:end]          # будет работать, например, для Vector, но может не сработать в общем случае
ix[(begin+1):end]  # работает для обобщенных индексов

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) # линейная индексация
           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)) # декартовская индексация
           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 целочисленными индексами; все другие выражения индексирования — включая линейное индексирование — будут пересчитаны в эквивалентное декартово местоположение. Например, если 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. Одиночные и отсутствующие размеры расширяются, чтобы соответствовать размерам других аргументов, виртуально повторяя значение. По умолчанию только ограниченное количество типов считается скалярами, включая Numbers, Strings, Symbols, Types, Functions и некоторые общие одиночные значения, такие как missing и nothing. Все остальные аргументы обрабатываются поэлементно.

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

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

Существует специальный синтаксис для широковещательного применения: 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 поддерживает итерацию, возвращаемое значение должно иметь такие же поведения axes и индексации, как и collect(x).

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

Примеры

julia> Broadcast.broadcastable([1,2,3]) # как `identity`, так как массивы уже поддерживают axes и индексацию
3-element Vector{Int64}:
 1
 2
 3

julia> Broadcast.broadcastable(Int) # Типы не поддерживают axes, индексацию или итерацию, но обычно используются как скаляры
Base.RefValue{Type{Int64}}(Int64)

julia> Broadcast.broadcastable("hello") # Строки нарушают соглашение о соответствии итерации и ведут себя как скаляр
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) # допустимый результат
2

julia> nextind(x, 4) # недопустимый результат
5

julia> nextind(x, CartesianIndex(1, 1)) # допустимый результат
CartesianIndex(2, 1)

julia> nextind(x, CartesianIndex(2, 2)) # недопустимый результат
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) # допустимый результат
3

julia> prevind(x, 1) # недопустимый результат
0

julia> prevind(x, CartesianIndex(2, 2)) # допустимый результат
CartesianIndex(1, 2)

julia> prevind(x, CartesianIndex(1, 1)) # недопустимый результат
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. Он выдаст ошибку при встрече с новым типом индекса, который не знает, как обрабатывать.

Для простых типов индексов он обращается к неэкспортируемой функции Base.to_index(A, i), чтобы обработать каждый индекс 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)) # без проверки границ
(1, 1, 2, 20)

julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # экзотический индекс
(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)) # без проверки формы
(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 # Обратите внимание, что A изменился, даже несмотря на то, что мы изменили b
2×2 Matrix{Int64}:
 0  2
 0  4

julia> view(2:5, 2:3) # возвращает диапазон, так как тип неизменяемый
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 выражение

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

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

!!! примечание Макрос @views затрагивает только выражения array[...], которые явно присутствуют в данном выражении, а не срезы массива, которые происходят в функциях, вызываемых этим кодом.

!!! совместимость "Julia 1.5" Использование begin в выражении индексации для обращения к первому индексу было реализовано в Julia 1.4, но поддерживалось @views только начиная с Julia 1.5.

Примеры

julia> A = zeros(3, 3);

julia> @views for row in 1:3
           b = A[row, :] # b является представлением, а не копией
           b .= row      # присвоить каждому элементу индекс строки
       end

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

parent(A)

Вернуть основной объект родителя представления. Этот родитель объектов типов SubArray, 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)    # результат - вектор
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)             # результат - матрица
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 истинно для типов, которые поддерживают быстрый линейный индекс, и ложно в противном случае.

Создавайте 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)  # то же самое, что и 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))  # блочно-диагональная
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])  # принимает числа
true

julia> v == [1; 2; [3,4]]  # синтаксис для той же операции
true

julia> summary(ComplexF64[1; 2; [3,4]])  # синтаксис для указания типа элемента
"4-element Vector{ComplexF64}"

julia> vcat(range(1, 2, length=3))  # собирает ленивые диапазоны
3-element Vector{Float64}:
 1.0
 1.5
 2.0

julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # строковый вектор и матрица
([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)  # более эффективно, чем 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]')  # принимает числа
1×7 Matrix{Int64}:
 1  2  30  40  5  6  7

julia> ans == [1 2 [30 40] [5, 6, 7]']  # синтаксис для той же операции
true

julia> Float32[1 2 [30 40] [5, 6, 7]']  # синтаксис для указания 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)  # более эффективно, чем 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  # не согласуется с вектором матриц
"2×2×3 Array{Float64, 3}"

julia> hcat(Int[], Int[], Int[])  # пустые векторы, каждый размером (0,)
0×3 Matrix{Int64}

julia> hcat([1.1, 9.9], Matrix(undef, 2, 0))  # hcat с пустой 2×0 матрицей
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 = элементы в каждой строке (2, 1, 1)
 _______     _
 3           1 = элементы в каждом столбце (3, 1)
 _____________
 4             = элементы в каждом 3d срезе (4,)
 _____________
 4             = элементы в каждом 4d срезе (4,)
⇒ shape = ((2, 1, 1), (3, 1), (4,), (4,)) с `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))  # принимает любые итераторы итераторов
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)  # в отличие от любой функции cat, 1-я ось vecs[1] является 2-й осью результата
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)  # обратное к eachslice
true

Примеры с более высокими измерениями:

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

julia> E = eachslice(A, dims=2);  # вектор матриц

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  # сохраняет все размеры
(2, 3, 5, 7)

julia> stack(M; dims=1) |> size  # vec(container) вдоль dims=1
(35, 2, 3)

julia> hvcat(5, M...) |> size  # hvcat ставит матрицы рядом друг с другом
(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!(a::AbstractVector, shift::Integer)

Циркулярно сдвинуть или повернуть данные в векторе a на shift позиций.

Примеры

julia> circshift!([1, 2, 3, 4, 5], 2)
5-element Vector{Int64}:
 4
 5
 1
 2
 3

julia> circshift!([1, 2, 3, 4, 5], -2)
5-element Vector{Int64}:
 3
 4
 5
 1
 2

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 истинных индексов или ключей 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)) # возвращает nothing, но не выводится в 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) # возвращает nothing, но не выводится в 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, если в A нет значения true.

Индексы или ключи имеют тот же тип, что и те, которые возвращаются функциями 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) # возвращает nothing, но не выводится в 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) # возвращает nothing, но не выводится в 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) # возвращает nothing, но не выводится в 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) # возвращает nothing, но не выводится в 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) # возвращает nothing, но не выводится в 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) # возвращает nothing, но не выводится в 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 — это 2d массив (AbstractMatrix), то perm по умолчанию равно (2,1), меняя местами две оси A (строки и столбцы матрицы). Это отличается от transpose тем, что операция не является рекурсивной, что особенно полезно для массивов нечисловых значений (где рекурсивный transpose вызовет ошибку) и/или 2d массивов, которые не представляют линейные операторы.

Для 1d массивов см. permutedims(v::AbstractVector), который возвращает "матрицу" с 1 строкой.

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

Примеры

2d массивы:

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

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); # поместить последнее измерение первым

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)) # обратная перестановка
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; # изменение p или r также изменяет v

julia> v # разделяет память с обоими p и 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) с типом 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);  # возвращает матрицу 1×4

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];  # возвращает число

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 (категория Ll: буква, строчная)
 'd': ASCII/Unicode U+0064 (категория Ll: буква, строчная)
 'c': ASCII/Unicode U+0063 (категория Ll: буква, строчная)
 'a': ASCII/Unicode U+0061 (категория Ll: буква, строчная)

julia> B[invperm(v)]
4-element Vector{Char}:
 'a': ASCII/Unicode U+0061 (категория Ll: буква, строчная)
 'b': ASCII/Unicode U+0062 (категория Ll: буква, строчная)
 'c': ASCII/Unicode U+0063 (категория Ll: буква, строчная)
 'd': ASCII/Unicode U+0064 (категория Ll: буква, строчная)

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.