Массивы
Конструкторы и типы
#
Core.AbstractArray
— Type
AbstractArray{T,N}
Супертип для N
-мерных массивов (или массивоподобных типов) с элементами типа T
. Array
и другие типы являются подтипами этого типа. См. раздел руководства, посвященный интерфейсу AbstractArray
.
См. также описание AbstractVector
, AbstractMatrix
, eltype
, ndims
.
#
Base.AbstractVector
— Type
AbstractVector{T}
Супертип для одномерных массивов (или массивоподобных типов) с элементами типа T
. Псевдоним для AbstractArray{T,1}
.
#
Base.AbstractMatrix
— Type
AbstractMatrix{T}
Супертип для двумерных массивов (или массивоподобных типов) с элементами типа T
. Псевдоним для AbstractArray{T,2}
.
#
Base.AbstractVecOrMat
— Type
AbstractVecOrMat{T}
Тип объединения AbstractVector{T}
и AbstractMatrix{T}
.
#
Core.Array
— Method
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
#
Core.Array
— Method
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
#
Core.Array
— Method
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
#
Core.UndefInitializer
— Type
UndefInitializer
Одинарный тип, используемый при инициализации массива и указывающий на то, что вызывающему объекту конструктора массива требуется неинициализированный массив. См. также описание константы undef
, псевдонима для UndefInitializer()
.
Примеры
julia> Array{Float64, 1}(UndefInitializer(), 3)
3-element Array{Float64, 1}:
2.2752528595e-314
2.202942107e-314
2.275252907e-314
#
Core.undef
— Constant
undef
Псевдоним для UndefInitializer()
, который создает экземпляр одинарного типа UndefInitializer
, используемого при инициализации массива для указания на то, что вызывающему объекту конструктора массива требуется неинициализированный массив.
Примеры
julia> Array{Float64, 1}(undef, 3)
3-element Vector{Float64}:
2.2752528595e-314
2.202942107e-314
2.275252907e-314
#
Base.Vector
— Type
Vector{T} <: AbstractVector{T}
Одномерный плотный массив с элементами типа T
, часто используемый для представления математического вектора. Псевдоним для Array{T,1}
.
#
Base.Vector
— Method
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
#
Base.Vector
— Method
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
#
Base.Matrix
— Method
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
#
Base.Matrix
— Method
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
#
Base.Matrix
— Method
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
#
Core.DenseArray
— Type
DenseArray{T, N} <: AbstractArray{T,N}
N
-мерный плотный массив с элементами типа T
. Элементы плотного массива хранятся в памяти в непрерывной последовательности.
#
Base.DenseVector
— Type
DenseVector{T}
Одномерный DenseArray
с элементами типа T
. Псевдоним для DenseArray{T,1}
.
#
Base.DenseMatrix
— Type
DenseMatrix{T}
Двумерный DenseArray
с элементами типа T
. Псевдоним для DenseArray{T,2}
.
#
Base.StridedArray
— Type
StridedArray{T, N}
Жестко закодированный тип Union
общих типов массивов, которые следуют интерфейсу массива с шагами, с элементами типа T
и измерениями N
.
Если A
представляет собой StridedArray
, то его элементы хранятся в памяти со смещениями, которые могут быть разными в разных измерениях, но являются постоянными в рамках одного измерения. Например, A
может иметь шаг массива 2 в измерении 1 и шаг массива 3 в измерении 2. При приращении A
в измерении d
происходит переход в памяти на [strides(A, d)
] слотов. Массивы с шагами особенно важны и полезны, поскольку иногда их можно передавать непосредственно как указатели на библиотеки на других языках, такие как BLAS.
#
Base.StridedVecOrMat
— Type
StridedVecOrMat{T}
Тип объединения StridedVector
и StridedMatrix
с элементами типа T
.
#
Base.Slices
— Type
Slices{P,SM,AX,S,N} <: AbstractSlices{S,N}
Массив AbstractArray
срезов родительского массива по заданному изменению (измерениям), возвращающий представления, которые выбирают все данные из другого измерения (измерений).
parent(s::Slices)
вернет родительский массив.
#
Base.getindex
— Method
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
#
Base.zeros
— Function
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
#
Base.ones
— Function
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
#
Base.BitArray
— Type
BitArray{N} <: AbstractArray{Bool, N}
Компактный N
-мерный логический массив, использующий всего один бит для каждого логического значения.
BitArray
упаковывают до 64 значений в каждые 8 байт, что дает 8-кратную эффективность использования пространства по сравнению с Array{Bool, N}
и позволяет некоторым операциям работать с 64 значениями одновременно.
По умолчанию Julia возвращает BitArrays
из операций трансляции, которые создают логические элементы (включая сравнения с пунктирными линиями, аналогичные .==
), а также из функций trues
и falses
.
Из-за упакованного формата хранения одновременный доступ к элементам |
#
Base.BitArray
— Method
BitArray(undef, dims::Integer...)
BitArray{N}(undef, dims::NTuple{N,Int})
Создает неопределенный BitArray
с заданными измерениями. Действует аналогично конструктору Array
. См. описание undef
.
Примеры
julia> BitArray(undef, 2, 2)
2×2 BitMatrix:
0 0
0 0
julia> BitArray(undef, (3, 1))
3×1 BitMatrix:
0
0
0
#
Base.BitArray
— Method
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
#
Base.trues
— Function
trues(dims)
Создает BitArray
со всеми значениями, равными true
.
Примеры
julia> trues(2,3)
2×3 BitMatrix:
1 1 1
1 1 1
#
Base.falses
— Function
falses(dims)
Создает BitArray
со всеми значениями, равными false
.
Примеры
julia> falses(2,3)
2×3 BitMatrix:
0 0 0
0 0 0
#
Base.fill
— Function
fill(value, dims::Tuple)
fill(value, dims...)
Создает массив размером dims
, где каждому расположению задано значение value
.
Например, fill(1.0, (5,5))
возвращает массив размером 5×5 из чисел с плавающей точкой и с 1.0
в каждом расположении массива.
Длина измерения dims
может быть задана как кортеж или последовательность аргументов. Кортеж длиной N
или аргументы N
после value
задают N
-мерный массив. Таким образом, распространенным методом для создания нульмерного массива с единственным расположением, заданным как x
, является fill(x)
.
Для каждого расположения возвращаемого массива задается (и, таким образом, ===
) value
, которое было передано. Это означает, что если само value
будет изменено, все элементы fill
массива будут отражать это изменение, потому что они все еще являются этим самым value
. Это не имеет отношения к fill(1.0, (5,5))
, поскольку value
1.0
неизменяемо и не может быть изменено само, но может иметь неожиданные изменяемые значения, такие как (чаще всего) массивы. Например, fill([], 3)
помещает тот же самый пустой массив во все три расположения возвращаемого вектора:
julia> v = fill([], 3)
3-element Vector{Vector{Any}}:
[]
[]
[]
julia> v[1] === v[2] === v[3]
true
julia> value = v[1]
Any[]
julia> push!(value, 867_5309)
1-element Vector{Any}:
8675309
julia> v
3-element Vector{Vector{Any}}:
[8675309]
[8675309]
[8675309]
Чтобы создать массив из множества независимых внутренних массивов, следует использовать включение. В этом случае при каждой итерации цикла создается новый и отдельный массив:
julia> v2 = [[] for _ in 1:3]
3-element Vector{Vector{Any}}:
[]
[]
[]
julia> v2[1] === v2[2] === v2[3]
false
julia> push!(v2[1], 8675309)
1-element Vector{Any}:
8675309
julia> v2
3-element Vector{Vector{Any}}:
[8675309]
[]
[]
Примеры
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]
#
Base.fill!
— Function
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
#
Base.empty
— Function
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
.
#
Base.similar
— Function
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}
, поскольку диапазоны не являются изменяемыми и не поддерживают два измерения:
julia> similar(1:10, 1, 4)
1×4 Matrix{Int64}:
4419743872 4374413872 4419743888 0
И наоборот, similar(trues(10,10), 2)
возвращает неинициализированный BitVector
с двумя элементами, поскольку BitArray
являются изменяемыми и могут поддерживать одномерные массивы:
julia> similar(trues(10,10), 2)
2-element BitVector:
0
0
Поскольку BitArray
могут хранить только элементы типа Bool
, если вы запросите другой тип элемента, будет создан обычный Array
:
julia> similar(falses(10), Float64, 2, 4)
2×4 Matrix{Float64}:
2.18425e-314 2.18425e-314 2.18425e-314 2.18425e-314
2.18425e-314 2.18425e-314 2.18425e-314 2.18425e-314
См. также описание undef
, isassigned
.
similar(storagetype, axes)
Создает неинициализированный изменяемый массив, аналогичный указанному с помощью storagetype
, но с axes
, заданным последним аргументом.
Примеры:
similar(Array{Int}, axes(A))
создает массив, который действует как Array{Int}
(и действительно может быть основан на нем), но индексируется идентично A
. Если A
имеет обычное индексирование, оно будет идентично Array{Int}(undef, size(A))
, но если A
имеет нетрадиционное индексирование, то индексы результата будут соответствовать A
.
similar(BitArray, (axes(A, 2),))
создаст одномерный логический массив, индексы которого совпадают с индексами столбцов A
.
similar(A::AbstractSparseMatrixCSC{Tv,Ti}, [::Type{TvNew}, ::Type{TiNew}, m::Integer, n::Integer]) where {Tv,Ti}
Создает неинициализированный изменяемый массив с заданным типом элементов, типом индексов и размером на основе заданного исходного SparseMatrixCSC
. Новая разреженная матрица сохраняет структуру исходной разреженной матрицы, за исключением случая, когда измерения выходной матрицы отличаются от выходных данных.
Выходная матрица имеет нули в тех же расположениях, что и входная, но имеет неинициализированные значения в ненулевых расположениях.
Основные функции
#
Base.size
— Function
size(A::AbstractArray, [dim])
Возвращает кортеж, содержащий измерения A
. По желанию можно указать измерение, чтобы получить длину только этого измерения.
Обратите внимание, что size
может быть не определен для массивов с нестандартными индексами. В этом случае метод axes
может оказаться полезным. См. главу руководства о массивах с пользовательскими индексами.
Примеры
julia> A = fill(1, (2,3,4));
julia> size(A)
(2, 3, 4)
julia> size(A, 2)
3
#
Base.axes
— Method
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] # будет работать для, например, Вектора, но может завершиться сбоем в общем случае
ix[(begin+1):end] # работает для обобщенных индексов
#
Base.length
— Method
length(A::AbstractArray)
Возвращает количество элементов в массиве, по умолчанию используется prod(size(A))
.
Примеры
julia> length([1, 2, 3, 4])
4
julia> length([1 2; 3 4])
4
#
Base.keys
— Method
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))
#
Base.eachindex
— Function
eachindex(A...)
eachindex(::IndexStyle, A::AbstractArray...)
Создает итерируемый объект для эффективного посещения каждого индекса AbstractArray
A
слева направо). Для типов массивов, которые выбрали быстрое линейное индексирование (таких как Array
), это просто диапазон 1:length(A)
, если они используют индексирование от единицы. Для типов массивов, которые не выбрали быстрое линейное индексирование, обычно возвращается специализированный декартов диапазон для эффективного индексирования массива с индексами, указанными для каждого измерения.
В общем случае 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)
#
Base.IndexStyle
— Type
IndexStyle(A)
IndexStyle(typeof(A))
IndexStyle
задает собственный стиль индексирования для массива A
. При определении нового типа AbstractArray
можно реализовать либо линейное индексирование (с помощью IndexLinear
), либо декартово индексирование. Если вы решили реализовать только линейное индексирование, вы должны указать этот момент для типа массива:
Base.IndexStyle(::Type{<:MyArray}) = IndexLinear()
По умолчанию используется IndexCartesian()
.
Внутренний механизм индексирования в Julia автоматически (и незаметно) пересчитает все операции индексирования в предпочтительный стиль. Это позволит пользователям получать доступ к элементам вашего массива, используя любой стиль индексирования, даже если явные методы не были предоставлены.
Если вы определили оба стиля индексирования для вашего AbstractArray
, этот признак можно использовать для выбора наиболее производительного стиля индексирования. Некоторые методы проверяют этот признак в своих входных данных и отправляют в различные алгоритмы в зависимости от наиболее эффективного шаблона доступа. В частности, eachindex
создает итератор, тип которого зависит от указания этого признака.
#
Base.IndexLinear
— Type
IndexLinear()
Подтип IndexStyle
, используемый для описания массивов, которые оптимально индексируются одним линейным индексом.
Стиль линейного индексирования использует один целочисленный индекс для описания позиции в массиве (даже если это многомерный массив), а для эффективного доступа к элементам используется упорядочение по столбцам. Это означает, что при запросе eachindex
из массива, являющегося IndexLinear
, будет возвращен простой одномерный диапазон, даже если он многомерный.
Пользовательский массив, который сообщает свой IndexStyle
как IndexLinear
, должен реализовать индексирование (и индексированное назначение) только с одним индексом Int
. Все другие выражения индексирования, включая многомерный доступ, будут пересчитаны в линейный индекс. Например, если бы A
был пользовательской матрицей 2×3
с линейным индексированием и мы обратились к A[1, 3]
, он был бы пересчитан в эквивалентный линейный индекс и вызвал бы A[5]
, поскольку 2*1 + 3 = 5
.
См. также описание IndexCartesian
.
#
Base.IndexCartesian
— Type
IndexCartesian()
Подтип IndexStyle
, используемый для описания массивов, которые оптимально индексируются декартовым индексом. Используется по умолчанию для новых пользовательских подтипов AbstractArray
.
Стиль декартова индексирования использует несколько целочисленных индексов для описания позиции в многомерном массиве с ровно одним индексом на измерение. Это означает, что при запросе eachindex
из массива, являющегося IndexCartesian
, будет возвращен диапазон CartesianIndices
.
Пользовательский N
-мерный массив, который сообщает свой IndexStyle
как IndexCartesian
, должен реализовать индексирование (и индексированное назначение) только с N
числом индексов Int
. Все другие выражения индексирования, включая линейное индексирование, будут пересчитаны в эквивалентное декартово расположение. Например, если бы A
был пользовательской матрицей 2×3
с декартовым индексированием и мы бы ссылались на A[5]
, он был бы пересчитан в эквивалентный декартов индекс и вызвал бы A[1, 3]
, поскольку 5 = 2*1 + 3
.
Вычислять декартовы индексы из линейного индекса значительно дороже. Для первой операции требуется деление (очень дорогостоящая операция), тогда как для второй используется только умножение и сложение, поэтому она, по сути, является бесплатной. Эта асимметрия означает, что использовать линейное индексирование с помощью массива IndexCartesian
гораздо дороже, чем использовать декартово индексирование с помощью массива IndexLinear
.
См. также описание IndexLinear
.
Трансляция и векторизация
См. также раздел Синтаксис через точку для функций векторизации. Например, f.(args...)
неявным образом вызывает broadcast(f, args...)
. Вместо того чтобы полагаться на «векторизированные» методы функций, например sin
, для работы с массивами, следует использовать sin.(a)
для векторизации посредством broadcast
.
#
Base.Broadcast.broadcast
— Function
broadcast(f, As...)
Транслирует функцию f
в массивах, кортежах, коллекциях, типах Ref
и (или) скалярах As
.
Трансляция применяет функцию f
к элементам аргументов контейнера и самим скалярам в As
. Одинарные и отсутствующие измерения расширяются в соответствии с размерами других аргументов, практически повторяя значение. По умолчанию только ограниченное число типов считаются скалярными, включая Number
, String
, Symbol
, Type
, Function
и некоторые другие распространенные одинарные экземпляры, такие как missing
и nothing
. Все остальные аргументы итерируются или индексируются поэлементно.
Результирующий тип контейнера определяется приведенными ниже правилами.
-
Если все аргументы являются скалярами или нульмерными массивами, возвращается скаляр без оболочки.
-
Если хотя бы один аргумент является кортежем, а все остальные — скалярами или нульмерными массивами, возвращается кортеж.
-
Все остальные комбинации аргументов по умолчанию возвращают
Array
, но пользовательские типы контейнеров могут определять собственные правила реализации и продвижения для настройки результата, когда они появляются в качестве аргументов.
Существует специальный синтаксис для трансляции: f.(args...)
эквивалентно broadcast(f, args...)
, и вложенные вызовы f.(g.(args...))
объединяются в один цикл трансляции.
Примеры
julia> A = [1, 2, 3, 4, 5]
5-element 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"
#
Base.Broadcast.broadcast!
— Function
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
#
Base.Broadcast.@__dot__
— Macro
@. 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
Сведения о специализированной трансляции для пользовательских типов см. в описании следующего типа:
#
Base.Broadcast.BroadcastStyle
— Type
BroadcastStyle
представляет собой абстрактный тип и трейт-функцию, используемую для определения поведения объектов в рамках трансляции. BroadcastStyle(typeof(x))
возвращает стиль, связанный с x
. Чтобы настроить поведение типа при трансляции, можно объявить стиль, определив пару «тип/метод».
struct MyContainerStyle <: BroadcastStyle end Base.BroadcastStyle(::Type{<:MyContainer}) = MyContainerStyle()
Затем создаются методы (как минимум similar
), которые работают в Broadcasted{MyContainerStyle}
. Существует несколько предопределенных подтипов BroadcastStyle
, доступных для использования. Дополнительные сведения можно найти в главе «Интерфейсы».
#
Base.Broadcast.AbstractArrayStyle
— Type
Broadcast.AbstractArrayStyle{N} <: BroadcastStyle
является абстрактным супертипом для любого стиля, связанного с типом AbstractArray
. Параметр N
представляет собой размерность, что может быть удобно для работы с типами AbstractArray, которые поддерживают только конкретные размерности:
struct SparseMatrixStyle <: Broadcast.AbstractArrayStyle{2} end Base.BroadcastStyle(::Type{<:SparseMatrixCSC}) = SparseMatrixStyle()
Для типов AbstractArray
, поддерживающих произвольную размерность, параметру N
можно задать значение Any
:
struct MyArrayStyle <: Broadcast.AbstractArrayStyle{Any} end Base.BroadcastStyle(::Type{<:MyArray}) = MyArrayStyle()
В случаях, когда вы хотите иметь возможность смешивать несколько AbstractArrayStyle
и контролировать размерность, ваш стиль должен поддерживать конструктор Val
:
struct MyArrayStyleDim{N} <: Broadcast.AbstractArrayStyle{N} end (::Type{<:MyArrayStyleDim})(::Val{N}) where N = MyArrayStyleDim{N}()
Обратите внимание, что если два или более подтипов AbstractArrayStyle
конфликтуют, механизм трансляции вернется к созданию Array
. Если это нежелательно, может понадобиться определить правила двоичного BroadcastStyle
для управления типом вывода.
См. также описание Broadcast.DefaultArrayStyle
.
#
Base.Broadcast.ArrayStyle
— Type
Broadcast.ArrayStyle{MyArrayType}()
является типом BroadcastStyle
, указывающим на то, что объект действует как массив для трансляции. Он представляет собой простой способ построения Broadcast.AbstractArrayStyle
для конкретных типов контейнеров AbstractArray
. Созданные таким образом стили трансляции теряют контроль над размерностью. Если сохранение контроля важно для вашего типа, следует создать пользовательский тип Broadcast.AbstractArrayStyle
.
#
Base.Broadcast.DefaultArrayStyle
— Type
Broadcast.DefaultArrayStyle{N}()
является типом BroadcastStyle
, указывающим на то, что объект действует как N
-мерный массив для трансляции. В частности, DefaultArrayStyle
используется для любого типа AbstractArray
, у которого отсутствует специализированный стиль, и при отсутствии переопределений от других аргументов broadcast
результирующим типом вывода является Array
. При наличии нескольких вводов для broadcast
DefaultArrayStyle
уступает любому другому Broadcast.ArrayStyle
.
#
Base.Broadcast.broadcastable
— Function
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]) # аналогично идентификатору, поскольку массивы уже поддерживают оси и индексирование
3-element Vector{Int64}:
1
2
3
julia> Broadcast.broadcastable(Int) # Типы не поддерживают оси, индексирование или итерацию, но обычно используются как скаляры
Base.RefValue{Type{Int64}}(Int64)
julia> Broadcast.broadcastable("hello") # Строки нарушают конвенцию итерации соответствия и действуют как скаляры
Base.RefValue{String}("hello")
#
Base.Broadcast.combine_axes
— Function
combine_axes(As...) -> Tuple
Определяет оси результатов для трансляции среди всех значений в As
.
julia> Broadcast.combine_axes([1], [1 2; 3 4; 5 6])
(Base.OneTo(3), Base.OneTo(2))
julia> Broadcast.combine_axes(1, 1, 1)
()
#
Base.Broadcast.combine_styles
— Function
combine_styles(cs...) -> BroadcastStyle
Решает, какой тип BroadcastStyle
использовать для любого количества аргументов значений. Использует тип BroadcastStyle
для получения стиля для каждого аргумента и использует функцию result_style
для комбинации стилей.
Примеры
julia> Broadcast.combine_styles([1], [1 2; 3 4])
Base.Broadcast.DefaultArrayStyle{2}()
#
Base.Broadcast.result_style
— Function
result_style(s1::BroadcastStyle[, s2::BroadcastStyle]) -> BroadcastStyle
Принимает один или два BroadcastStyle
и комбинирует их с помощью типа BroadcastStyle
для определения общего BroadcastStyle
.
Примеры
julia> Broadcast.result_style(Broadcast.DefaultArrayStyle{0}(), Broadcast.DefaultArrayStyle{3}())
Base.Broadcast.DefaultArrayStyle{3}()
julia> Broadcast.result_style(Broadcast.Unknown(), Broadcast.DefaultArrayStyle{1}())
Base.Broadcast.DefaultArrayStyle{1}()
Индексирование и присваивание
#
Base.getindex
— Method
getindex(A, inds...)
Возвращает подмножество массива A
, как задано с помощью inds
, где каждый ind
может быть, например, типом Int
, AbstractRange
или Vector
. Дополнительные сведения см. в разделе руководства, посвященном индексированию массивов.
Примеры
julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> getindex(A, 1)
1
julia> getindex(A, [2, 1])
2-element Vector{Int64}:
3
1
julia> getindex(A, 2:4)
3-element Vector{Int64}:
3
2
4
#
Base.setindex!
— Method
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
#
Base.copyto!
— Method
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
#
Base.copy!
— Function
copy!(dst, src) -> dst
copy
src
на месте в dst
с удалением всех уже имеющихся элементов в dst
. Если dst
и src
имеют одинаковый тип, dst == src
должно сохраняться после вызова. Если dst
и src
являются многомерными массивами, они должны иметь равный метод axes
.
См. также описание copyto!
.
Совместимость: Julia 1.1
Для этого метода требуется версия не ниже Julia 1.1. В Julia 1.0 этот метод доступен в стандартной библиотеке |
#
Base.isassigned
— Function
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
#
Base.Colon
— Type
Colon()
Двоеточие (:) используется для обозначения индексирования целых объектов или измерений одновременно.
Очень немногие операции определяются непосредственно для Двоеточий. Но функция to_indices
преобразует их в тип внутреннего вектора (Base.Slice
) для представления коллекции индексов, которые они охватывают, перед использованием.
Одинарный экземпляр Colon
также является функцией, используемой для построения диапазонов. См. описание :
.
#
Base.IteratorsMD.CartesianIndex
— Type
CartesianIndex(i, j, k...) -> I
CartesianIndex((i, j, k...)) -> I
Создает многомерный индекс I
, который можно использовать для индексирования многомерного массива A
. В частности, A[I]
эквивалентен A[i,j,k...]
. Можно легко смешивать целочисленные индексы и индексы CartesianIndex
. Например, A[Ipre, i, Ipost]
(где Ipre
и Ipost
являются индексами CartesianIndex
, а i
— Int
) может быть полезным выражением при написании алгоритмов, которые работают в одном измерении массива произвольной размерности.
CartesianIndex
иногда создается с помощью функции eachindex
и всегда при итерации с явным CartesianIndices
.
Примеры
julia> A = reshape(Vector(1:16), (2, 2, 2, 2))
2×2×2×2 Array{Int64, 4}:
[:, :, 1, 1] =
1 3
2 4
[:, :, 2, 1] =
5 7
6 8
[:, :, 1, 2] =
9 11
10 12
[:, :, 2, 2] =
13 15
14 16
julia> A[CartesianIndex((1, 1, 1, 1))]
1
julia> A[CartesianIndex((1, 1, 1, 2))]
9
julia> A[CartesianIndex((1, 1, 2, 1))]
5
#
Base.IteratorsMD.CartesianIndices
— Type
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 1.6
Для метода диапазона шагов |
Примеры
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 1.1
Для трансляции CartesianIndices требуется версия Julia не ниже 1.1. |
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
.
#
Base.Dims
— Type
Dims{N}
NTuple
из N
Int
используется для представления измерений типа AbstractArray
.
#
Base.LinearIndices
— Type
LinearIndices(A::AbstractArray)
Возвращает массив LinearIndices
с той же формой и axes
, что и для A
, где линейный индекс каждой записи находится в A
. Индексирование этого массива с помощью декартовых индексов позволяет сопоставлять их с линейными индексами.
Для массивов с обычным индексированием (индексы начинаются с 1) или любых многомерных массивов линейные индексы находятся в диапазоне от 1 до length(A)
. Однако для AbstractVector
линейные индексы являются axes(A, 1)
и поэтому не начинаются с 1 для векторов с нетрадиционным индексированием.
Вызов этой функции является безопасным способом написания алгоритмов, использующих линейное индексирование.
Примеры
julia> A = fill(1, (5,6,7));
julia> b = LinearIndices(A);
julia> extrema(b)
(1, 210)
LinearIndices(inds::CartesianIndices) -> R LinearIndices(sz::Dims) -> R LinearIndices((istart:istop, jstart:jstop, ...)) -> R
Возвращает массив LinearIndices
с указанной формой или axes
.
Пример
Основное назначение этого конструктора — интуитивное преобразование декартова индексирования в линейное:
julia> linear = LinearIndices((1:3, 1:2))
3×2 LinearIndices{2, Tuple{UnitRange{Int64}, UnitRange{Int64}}}:
1 4
2 5
3 6
julia> linear[1,2]
4
#
Base.to_indices
— Function
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)
#
Base.checkbounds
— Function
checkbounds(Bool, A, I...)
Возвращает true
, если указанные индексы I
находятся в границах заданного массива A
. Подтипы AbstractArray
должны специализировать этот метод, если им необходимо реализовать пользовательское поведение проверки границ. Однако во многих случаях можно использовать индексы A
и функцию checkindex
.
См. также описание checkindex
.
Примеры
julia> A = rand(3, 3);
julia> checkbounds(Bool, A, 2)
true
julia> checkbounds(Bool, A, 3, 4)
false
julia> checkbounds(Bool, A, 1:3)
true
julia> checkbounds(Bool, A, 1:3, 2:4)
false
checkbounds(A, I...)
Выдает ошибку, если указанные индексы I
находятся за пределами границ заданного массива A
.
#
Base.checkindex
— Function
checkindex(Bool, inds::AbstractUnitRange, index)
Возвращает true
, если заданный index
находится в границах inds
. Пользовательские типы, которые могли бы действовать как индексы для всех массивов, могут расширить этот метод, чтобы внедрить специализированную реализацию проверки границ.
См. также описание checkbounds
.
Примеры
julia> checkindex(Bool, 1:20, 8)
true
julia> checkindex(Bool, 1:20, 21)
false
Представления (подмассивы и другие типы представлений)
«Представление» — это структура данных, которая работает как массив (является подтипом AbstractArray
), хотя данные на самом деле берутся из другого массива.
Например, если x
— это массив и дано выражение v = @view x[1:10]
, то v
работает как массив из 10 элементов, хотя при доступе к данным на самом деле происходит обращение к первым 10 элементам x
. При записи в представление, например v[3] = 2
, данные записываются непосредственно в базовый массив x
(в данном случае изменяется элемент x[3]
).
При получении среза, например x[1:10]
, в Julia по умолчанию создается копия. Выражение @view x[1:10]
позволяет изменить это поведение и создать представление. Макрос @views
можно применять к целому блоку кода (например, @views function foo() .... end
или @views begin ... end
). При этом все операции взятия среза в этом блоке изменяются так, что создаются представления. Иногда может быть быстрее создать копию, а иногда — использовать представление, как описано в разделе Советы по производительности.
#
Base.view
— Function
view(A, inds...)
Аналогична getindex
, но возвращает упрощенный массив, который «лениво» ссылается (или фактически является представлением) на родительский массив A
по заданному индексу или индексам inds
вместо активного извлечения элементов или построения скопированного подмножества. При вызове getindex
или setindex!
для возвращаемого значения (часто SubArray
) вычисляются индексы для доступа к родительскому массиву или его динамического изменения. Поведение будет неопределенным, если форма родительского массива будет изменена после вызова view
, поскольку проверка границ родительского массива не выполняется. К примеру, может возникнуть ошибка сегментации.
Некоторые неизменяемые родительские массивы (например, диапазоны) при определенных обстоятельствах могут просто пересчитать новый массив вместо того, чтобы возвращать SubArray
, если это эффективно и обеспечивает совместимую семантику.
Совместимость: Julia 1.6
В Julia 1.6 или более поздних версиях |
Примеры
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
#
Base.@view
— Macro
@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 1.5
Для использования |
Примеры
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
#
Base.@views
— Macro
@views expression
Преобразует каждую операцию среза массива в заданном выражении (которое может быть блоком begin
/end
, циклом, функцией и т. д.) для возвращения представления. Скалярные индексы, типы, не относящиеся к массивам, и явные вызовы getindex
(в отличие от array[...]
) не затрагиваются.
Аналогично, @views
преобразует строковые срезы в представления SubString
.
Макрос |
Совместимость: Julia 1.5
Для использования |
Примеры
julia> A = zeros(3, 3);
julia> @views for row in 1:3
b = A[row, :]
b[:] .= row
end
julia> A
3×3 Matrix{Float64}:
1.0 1.0 1.0
2.0 2.0 2.0
3.0 3.0 3.0
#
Base.parent
— Function
parent(A)
Возвращает базовый родительский массив. Это родительский массив объектов типов SubArray
, ReshapedArray
или LinearAlgebra.Transpose
является тем, что было передано в качестве аргумента в view
, reshape
, transpose
и т. д. при создании объекта. Если входной объект не является заключенным в оболочку объектом, возвращается он сам. Если входной объект заключен в оболочку несколько раз, будет удален только самый крайний слой.
Примеры
julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> V = view(A, 1:2, :)
2×2 view(::Matrix{Int64}, 1:2, :) with eltype Int64:
1 2
3 4
julia> parent(V)
2×2 Matrix{Int64}:
1 2
3 4
#
Base.selectdim
— Function
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
#
Base.reinterpret
— Function
reinterpret(type, A)
Изменяет интерпретацию типа двоичных данных в примитивном типе A
на интерпретацию типа примитивного типа type
. Размер type
должен быть таким же, как у типа A
. Например, reinterpret(Float32, UInt32(7))
интерпретирует 4 байта, относящиеся к UInt32(7)
как Float32
.
Примеры
julia> reinterpret(Float32, UInt32(7))
1.0f-44
reinterpret(reshape, T, A::AbstractArray{S}) -> B
Изменяет интерпретацию типа A
при потреблении или добавлении «измерения канала».
Если sizeof(T) = n*sizeof(S)
для n>1
, то первое измерение A
должно иметь размер n
, а в B
отсутствует первое измерение A
. И наоборот, если sizeof(S) = n*sizeof(T)
для n>1
, B
получает новое первое измерение размером n
. Размерность не изменяется, если sizeof(T) == sizeof(S)
.
Совместимость: Julia 1.6
Для этого метода требуется версия не ниже Julia 1.6. |
Примеры
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
#
Base.reshape
— Function
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
#
Base.dropdims
— Function
dropdims(A; dims)
Возвращает массив с теми же данными, что и в A
, но с удаленными измерениями, заданными dims
. size(A,d)
должен быть равен 1 для каждого d
в dims
, а повторяющиеся измерения или числа за пределами 1:ndims(A)
запрещены.
Результат использует те же базовые данные, что и A
, поэтому результат является изменяемым тогда и только тогда, когда A
является изменяемым и установка элементов одного массива изменяет значения другого.
Примеры
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
#
Base.vec
— Function
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
#
Base.SubArray
— Type
SubArray{T,N,P,I,L} <: AbstractArray{T,N}
N
-мерное представление родительского массива (с типом P
) с типом элементов T
, ограниченное кортежем индексов (с типом I
). L
имеет значение true для типов, поддерживающих быстрое линейное индексирование, в противном случае — значение false
.
Создает SubArray
с помощью функции view
.
Конкатенация и перестановка
#
Base.cat
— Function
cat(A...; dims)
Выполняет конкатенацию входных массивов в измерениях, указанных в dims
.
В измерении d in dims
размером выходного массива является sum(size(a,d) for a in A)
. В других измерениях все входные массивы должны иметь одинаковый размер, который также будет размером выходного массива в этих измерениях.
Если dims
является одним числом, различные массивы плотно укладываются в этом измерении. Если dims
является итерируемым объектом, содержащим несколько измерений, то позиции вдоль этих измерений одновременно увеличиваются для каждого входного массива, заполняя нулем все остальные места. Это позволяет строить блочно-диагональные матрицы в виде cat(matrices...; dims=(1,2))
, и их аналоги с более высокими измерениями.
Ключевое слово также принимает Val(dims)
.
Совместимость: Julia 1.8
Для нескольких измерений в Julia 1.8 было добавлено |
Примеры
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
#
Base.vcat
— Function
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
#
Base.hcat
— Function
hcat(A...)
- Выполняет конкантенацию массивов или чисел по горизонтали. Эквивалентна
cat
(A...; dims=2)
и синтаксису[a b c]
или `[a -
b;; c]`.
Для конкатенации большого набора массивов reduce(hcat, A)
вызывает эффективный метод, если A isa AbstractVector{<:AbstractVecOrMat}
. Для набора векторов можно также записать в виде stack
(A)
.
Примеры
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]'] # синтаксис для указания типа элемента
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
#
Base.hvcat
— Function
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
#
Base.hvncat
— Function
hvncat(dim::Int, row_first, values...)
hvncat(dims::Tuple{Vararg{Int}}, row_first, values...)
hvncat(shape::Tuple{Vararg{Tuple}}, row_first, values...)
Горизонтальная, вертикальная и n-мерная конкатенация в одном вызове values
.
- Эта функция вызывается для синтаксиса блочной матрицы. Первый аргумент либо задает форму конкатенации, аналогично
hvcat
, в виде кортежа кортежей, либо измерения, задающие ключевое количество элементов по каждой оси, и используется для определения выходных измерений. Формаdims
является более производительной и используется по умолчанию, когда в операции конкатенации содержится одинаковое количество элементов по каждой оси (например, `[a b; c d; -
e f ; g h]
). Форма `shape
используется, когда количество элементов по каждой оси не сбалансировано (например,[a b ; c]
). Несбалансированный синтаксис требует дополнительных затрат на проверку. Формаdim
является оптимизацией для конкатенации только в одном измерении.row_first
указывает способ упорядоченияvalues
. Значения первого и второго элементовshape
также меняются местами на основеrow_first
.
Примеры
julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
(1, 2, 3, 4, 5, 6)
julia> [a b c;;; d e f]
1×3×2 Array{Int64, 3}:
[:, :, 1] =
1 2 3
[:, :, 2] =
4 5 6
julia> hvncat((2,1,3), false, a,b,c,d,e,f)
2×1×3 Array{Int64, 3}:
[:, :, 1] =
1
2
[:, :, 2] =
3
4
[:, :, 3] =
5
6
julia> [a b;;; c d;;; e f]
1×2×3 Array{Int64, 3}:
[:, :, 1] =
1 2
[:, :, 2] =
3 4
[:, :, 3] =
5 6
julia> hvncat(((3, 3), (3, 3), (6,)), true, a, b, c, d, e, f)
1×3×2 Array{Int64, 3}:
[:, :, 1] =
1 2 3
[:, :, 2] =
4 5 6
Примеры для конструирования аргументов
[a b c ; d e f ;;; g h i ; j k l ;;; m n o ; p q r ;;; s t u ; v w x] ⇒ dims = (2, 3, 4) [a b ; c ;;; d ;;;;] ___ _ _ 2 1 1 = elements in each row (2, 1, 1) _______ _ 3 1 = elements in each column (3, 1) _____________ 4 = elements in each 3d slice (4,) _____________ 4 = elements in each 4d slice (4,) ⇒ shape = ((2, 1, 1), (3, 1), (4,), (4,)) with `row_first` = true
#
Base.stack
— Function
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 1.9
Для этой функции требуется версия Julia не ниже 1.9. |
Примеры
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) # обратная величина каждого среза
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
(если задано) или по умолчанию по последнему измерению.
Примеры
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
#
Base.circshift
— Function
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
#
Base.circshift!
— Function
circshift!(dest, src, shifts)
Выполняет круговой сдвиг, т. е. поворот, данных в src
с сохранением результата в dest
. shifts
задает величину сдвига в каждом измерении.
Массив dest
должен отличаться от массива src
(они не могут быть псевдонимами друг друга).
См. также описание circshift
.
#
Base.circcopy!
— Function
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
#
Base.findall
— Method
findall(A)
Возвращает вектор I
индексов true
или ключей A
. Если такие элементы A
отсутствуют, возвращается пустой массив. Для поиска других видов значений следует передать предикат в качестве первого аргумента.
Индексы или ключи имеют тот же тип, что и индексы и ключи, возвращаемые методами keys(A)
и pairs(A)
.
См. также описание findfirst
, searchsorted
.
Примеры
julia> A = [true, false, false, true]
4-element Vector{Bool}:
1
0
0
1
julia> findall(A)
2-element Vector{Int64}:
1
4
julia> A = [true false; false true]
2×2 Matrix{Bool}:
1 0
0 1
julia> findall(A)
2-element Vector{CartesianIndex{2}}:
CartesianIndex(1, 1)
CartesianIndex(2, 2)
julia> findall(falses(3))
Int64[]
#
Base.findall
— Method
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
#
Base.findfirst
— Method
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)
#
Base.findfirst
— Method
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)
#
Base.findlast
— Method
findlast(A)
Возвращает индекс или ключ последнего значения true
в A
. Возвращает nothing
, если значение true
в A
отсутствует.
Индексы или ключи имеют тот же тип, что и индексы и ключи, возвращаемые методами keys(A)
и pairs(A)
.
Примеры
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)
#
Base.findlast
— Method
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)
#
Base.findnext
— Method
findnext(A, i)
Находит следующий индекс после i
элемента true
массива A
, или включая его, или nothing
, если индекс не найден.
Примеры
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)
#
Base.findnext
— Method
findnext(predicate::Function, A, i)
Находит следующий индекс после i
элемента A
, или включая его, для которого predicate
возвращает true
, или nothing
, если индекс не найден.
Примеры
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)
#
Base.findprev
— Method
findprev(A, i)
Находит предыдущий индекс до i
элемента true
массива A
, или включая его, или nothing
, если индекс не найден.
Примеры
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)
#
Base.findprev
— Method
findprev(predicate::Function, A, i)
Находит предыдущий индекс до i
элемента A
, или включая его, для которого predicate
возвращает true
, или nothing
, если индекс не найден.
Примеры
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)
#
Base.permutedims
— Function
permutedims(A::AbstractArray, perm)
Перестанавливает измерения массива A
. perm
представляет собой вектор или кортеж длиной ndims(A)
, указывающий перестановку.
См. также permutedims!
, PermutedDimsArray
, transpose
, invperm
.
Примеры
julia> A = reshape(Vector(1:8), (2,2,2))
2×2×2 Array{Int64, 3}:
[:, :, 1] =
1 3
2 4
[:, :, 2] =
5 7
6 8
julia> perm = (3, 1, 2); # последнее измерение размещается первым
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(m::AbstractMatrix)
Перестанавливает измерения матрицы m
путем переворота элементов по диагонали матрицы. Отличается от функции transpose
для LinearAlgebra
тем, что операция не является рекурсивной.
Примеры
julia> a = [1 2; 3 4];
julia> b = [5 6; 7 8];
julia> c = [9 10; 11 12];
julia> d = [13 14; 15 16];
julia> X = [[a] [b]; [c] [d]]
2×2 Matrix{Matrix{Int64}}:
[1 2; 3 4] [5 6; 7 8]
[9 10; 11 12] [13 14; 15 16]
julia> permutedims(X)
2×2 Matrix{Matrix{Int64}}:
[1 2; 3 4] [9 10; 11 12]
[5 6; 7 8] [13 14; 15 16]
julia> transpose(X)
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
[1 3; 2 4] [9 11; 10 12]
[5 7; 6 8] [13 15; 14 16]
permutedims(v::AbstractVector)
Изменяет форму вектора v
на строчную матрицу 1 × length(v)
. Отличается от функции transpose
для LinearAlgebra
тем, что операция не является рекурсивной.
Примеры
julia> permutedims([1, 2, 3, 4])
1×4 Matrix{Int64}:
1 2 3 4
julia> V = [[[1 2; 3 4]]; [[5 6; 7 8]]]
2-element Vector{Matrix{Int64}}:
[1 2; 3 4]
[5 6; 7 8]
julia> permutedims(V)
1×2 Matrix{Matrix{Int64}}:
[1 2; 3 4] [5 6; 7 8]
julia> transpose(V)
1×2 transpose(::Vector{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
[1 3; 2 4] [5 7; 6 8]
#
Base.permutedims!
— Function
permutedims!(dest, src, perm)
Перестанавливает измерения массива src
и сохраняет результат в массиве dest
. perm
является вектором, указывающим перестановку длиной ndims(src)
. Предварительно выделенный массив dest
должен иметь size(dest) == size(src)[perm]
и полностью перезаписывается. Перестановка на месте не поддерживается, и если src
и dest
имеют перекрывающиеся области памяти, следует ожидать непредвиденных результатов.
См. также описание permutedims
.
#
Base.PermutedDimsArrays.PermutedDimsArray
— Type
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
#
Base.promote_shape
— Function
promote_shape(s1, s2)
Проверяет две формы массива на совместимость, разрешая конечные одинарные измерения, и возвращает ту форму, которая имеет больше измерений.
Примеры
julia> a = fill(1, (3,4,1,1,1));
julia> b = fill(1, (3,4));
julia> promote_shape(a,b)
(Base.OneTo(3), Base.OneTo(4), Base.OneTo(1), Base.OneTo(1), Base.OneTo(1))
julia> promote_shape((2,3,1,4), (2, 3, 1, 4, 1))
(2, 3, 1, 4, 1)
Функции для работы с массивами
#
Base.accumulate
— Function
accumulate(op, A; dims::Integer, [init])
Кумулятивная операция op
в измерении dims
массива A
(предоставлять dims
для векторов необязательно). При необходимости можно указать начальное значение init
с помощью именованного аргумента. См. также раздел о accumulate!
со сведениями об использовании предварительно выделенного выходного массива для обеспечения надлежащей производительности и управления точностью выходных данных (например, чтобы избежать переполнения).
Для распространенных операций существуют специализированные варианты accumulate
. См. cumsum
, cumprod
. Сведения об отложенной версии см. в разделе Iterators.accumulate
.
Совместимость: Julia 1.5
Для |
Примеры
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
#
Base.accumulate!
— Function
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
#
Base.cumprod
— Function
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 1.5
Для |
Примеры
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"
#
Base.cumsum
— Function
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
Возвращаемым типом массива
В первом случае целочисленные значения расширяются до размера системного слова и, таким образом, результатом является |
cumsum(itr)
Совокупная сумма итератора.
См. также раздел о accumulate
со сведениями о применении функций, отличных от +
.
Совместимость: Julia 1.5
Для |
Примеры
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]
#
Base.diff
— Function
diff(A::AbstractVector)
diff(A::AbstractArray; dims::Integer)
Ограничивает разностный оператор в векторе или многомерном массиве A
. В последнем случае измерение, в котором нужно выполнять действия, следует указать с помощью именованного аргумента dims
.
Совместимость: Julia 1.1
Для массивов |
Примеры
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
#
Base.repeat
— Function
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"
#
Base.rot180
— Function
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
#
Base.rotl90
— Function
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
#
Base.rotr90
— Function
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
#
Base.mapslices
— Function
mapslices(f, A; dims)
Преобразует заданные измерения массива A
, применяя функцию f
к каждому срезу формы A[..., :, ..., :, ...]
, с двоеточием у каждого d
в dims
. Результаты конкатенируются в остальных измерениях.
Например, если dims = [1,2]
и A
являются четырехмерными, f
вызывается в x = A[:,:,i,j]
для всех i
и j
, и f(x)
становится R[:,:,i,j]
в результате R
.
Примеры
julia> A = reshape(1:30,(2,5,3))
2×5×3 reshape(::UnitRange{Int64}, 2, 5, 3) with eltype Int64:
[:, :, 1] =
1 3 5 7 9
2 4 6 8 10
[:, :, 2] =
11 13 15 17 19
12 14 16 18 20
[:, :, 3] =
21 23 25 27 29
22 24 26 28 30
julia> f(x::Matrix) = fill(x[1,1], 1,4); # возвращает матрицу 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
.
#
Base.eachrow
— Function
eachrow(A::AbstractVecOrMat) <: AbstractVector
Создает объект RowSlices
, который является вектором строк матрицы или вектором A
. Срезы строк возвращаются в виде представлений AbstractVector
A
.
Обратное действие см. в описании stack
(rows; dims=1)
.
Совместимость: Julia 1.1
Для этой функции требуется версия Julia не ниже 1.1. |
Совместимость: Julia 1.9
До версии Julia 1.9 при этом возвращался итератор. |
Пример
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
#
Base.eachcol
— Function
eachcol(A::AbstractVecOrMat) <: AbstractVector
Создает объект ColumnSlices
, который является вектором столбцов матрицы или вектором A
. Срезы столбцов возвращаются в виде представлений AbstractVector
A
.
Совместимость: Julia 1.1
Для этой функции требуется версия Julia не ниже 1.1. |
Совместимость: Julia 1.9
До версии Julia 1.9 при этом возвращался итератор. |
Пример
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
#
Base.eachslice
— Function
eachslice(A::AbstractArray; dims, drop=true)
Создает объект Slices
, который является массивом срезов в измерениях dims
для A
, возвращая представления, которые выбирают все данные из других измерений в A
. dims
может быть целым числом или кортежем целых чисел.
Если drop = true
(по умолчанию), внешние срезы (Slices
) будут отбрасывать внутренние размеры, а порядок измерений будет соответствовать порядку в dims
. Если drop = false
, срезы (Slices
) будет иметь ту же размерность, что и базовый массив, а размер внутренних измерений будет равен 1.
Обратное действие eachslice(A; dims::Integer)
см. в описании stack
(slices; dims)
.
Совместимость: Julia 1.1
Для этой функции требуется версия Julia не ниже 1.1. |
Совместимость: Julia 1.9
До версии Julia 1.9 при этом возвращался итератор и в |
Пример
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]
Комбинаторика
#
Base.invperm
— Function
invperm(v)
Возвращает обратную перестановку v
. Если B = A[v]
, то A == B[invperm(v)]
.
См. также sortperm
, invpermute!
, isperm
, permutedims
.
Примеры
julia> p = (2, 3, 1);
julia> invperm(p)
(3, 1, 2)
julia> v = [2; 4; 3; 1];
julia> invperm(v)
4-element Vector{Int64}:
4
1
3
2
julia> A = ['a','b','c','d'];
julia> B = A[v]
4-element Vector{Char}:
'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)
'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
julia> B[invperm(v)]
4-element Vector{Char}:
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)
#
Base.isperm
— Function
isperm(v) -> Bool
Возвращает true
, если v
является допустимой перестановкой.
Примеры
julia> isperm([1; 2])
true
julia> isperm([1; 3])
false
#
Base.permute!
— Method
permute!(v, p)
Перестанавливает вектор v
на месте в соответствии с перестановкой p
. Проверка того, что p
является перестановкой, не выполняется.
Для возвращения новой перестановки используйте v[p]
. Обратите внимание, что это гораздо быстрее, чем permute!(v, p)
.
См. также описание invpermute!
.
Примеры
julia> A = [1, 1, 3, 4];
julia> perm = [2, 4, 3, 1];
julia> permute!(A, perm);
julia> A
4-element Vector{Int64}:
1
4
3
1
#
Base.reverse
— Method
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
Совместимость: Julia 1.6
До Julia 1.6 в |
#
Base.reverseind
— Function
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🚀
#
Base.reverse!
— Function
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
.
Совместимость: Julia 1.6
Для многомерной функции |