Документация Engee

Массивы

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

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

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

Совместимость: Julia 1.11

Для этого типа требуется версия Julia не ниже 1.11.

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

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

Совместимость: Julia 1.11

Для этого типа требуется версия Julia не ниже 1.11.

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

Из-за упакованного формата хранения одновременные операции доступа к элементам BitArray, как минимум одна из которых представляет собой операцию записи, не являются потокобезопасными.

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

Создает неопределенный массив BitArray с заданными измерениями. Действует аналогично конструктору Array. См. описание undef.

Примеры

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

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

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

Примеры

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

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

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

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

Примеры

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

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

Примеры

julia> falses(2,3)
2×3 BitMatrix:
 0  0  0
 0  0  0
fill(value, dims::Tuple)
fill(value, dims...)

Создает массив размером dims, в котором каждой позиции присвоено значение value.

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

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

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

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

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

julia> value = v[1]
Any[]

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

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

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

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

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

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

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

См. также описание fill!, zeros, ones, similar.

Примеры

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

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

julia> A = fill(zeros(2), 2) # задает для обоих элементов один и тот же вектор [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.

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

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

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

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

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

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

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

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

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

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

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

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

См. также описание undef, isassigned.

similar(storagetype, axes)

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

Примеры:

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

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

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

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

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

ndims(A::AbstractArray) -> Integer

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

См. также описание size, axes.

Примеры

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

julia> ndims(A)
3
size(A::AbstractArray, [dim])

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

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

См. также описание length, ndims, eachindex, sizeof.

Примеры

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

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

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

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

См. также описание size, keys, eachindex.

Примеры

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

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

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

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

Примеры

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

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

julia> axes(A, 4) == 1:1  # все измерения d > ndims(A) имеют размер, равный 1
true

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

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

ix = axes(v, 1)
ix[2:end]          # будет работать для, например, вектора, но может завершиться сбоем в общем случае
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), если они используют индексирование от единицы. Для типов массивов без быстрого линейного индексирования обычно возвращается специализированный декартов диапазон для эффективного индексирования массива с индексами, указанными для каждого измерения.

В общем случае 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 индексов Int. Все другие выражения индексирования, включая линейное индексирование, будут пересчитаны в эквивалентное декартово расположение. Например, если бы массив A был пользовательской матрицей 2×3 с декартовым индексированием и мы обратились бы по индексу A[5], он был бы пересчитан в эквивалентный декартов индекс с вызовом A[1, 3], поскольку 5 = 1 + 2*(3 - 1).

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

См. также описание IndexLinear.

conj!(A)

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

См. также описание conj.

Примеры

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

julia> conj!(A);

julia> A
2×2 Matrix{Complex{Int64}}:
 1-1im  2+1im
 2-2im  3-1im
stride(A, k::Integer)

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

См. также описание strides.

Примеры

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

julia> stride(A,2)
3

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

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

См. также описание stride.

Примеры

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

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

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

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

broadcast(f, As...)

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

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

Результирующий тип контейнера определяется приведенными ниже правилами.

  • Если все аргументы являются скалярами или нульмерными массивами, возвращается скаляр без оболочки.

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

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

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

Примеры

julia> A = [1, 2, 3, 4, 5]
5-element 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

# 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

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

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]) # аналогично идентификатору, поскольку массивы уже поддерживают оси и индексирование
3-element Vector{Int64}:
 1
 2
 3

julia> Broadcast.broadcastable(Int) # Типы не поддерживают оси, индексирование или итерацию, но обычно используются как скаляры
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, AbstractRange или массив поддерживаемых индексов. Для выбора всех элементов в определенном измерении можно использовать :, а для фильтрации элементов, где соответствующий индекс равен true, можно использовать логический массив (например, Array{Bool} или BitArray).

Если 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. Эта функция может быть полезна для универсального кода.

Возвращаемый индекс может выходить за пределы допустимого диапазона. Рекомендуется использовать checkbounds.

См. также описание 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. Эта функция может быть полезна для универсального кода.

Возвращаемый индекс может выходить за пределы допустимого диапазона. Рекомендуется использовать checkbounds.

См. также описание 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

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

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

См. также описание copyto!.

Совместимость: Julia 1.1

Для этого метода требуется версия Julia не ниже 1.1. В Julia 1.0 этот метод доступен в стандартной библиотеке Future как Future.copy!.

 
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
Совместимость: Julia 1.10

Для использования CartesianIndex в качестве «скаляра» для broadcast требуется Julia 1.10; в предыдущих версиях используйте Ref(I).

 
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

Для метода диапазона шагов CartesianIndices((istart:istep:istop, jstart:[jstep:]jstop, ...)) требуется версия 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.

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

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

«Представление» — это структура данных, которая работает как массив (является подтипом 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). При этом все операции взятия среза в этом блоке изменяются так, что создаются представления. Иногда может быть быстрее создать копию, а иногда — использовать представление, как описано в разделе Советы по производительности.

view(A, inds...)

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

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

Совместимость: Julia 1.6

В Julia 1.6 или более поздних версиях view можно вызвать для AbstractString, в результате чего возвращается SubString.

Примеры

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 1.5

Для использования begin в выражении индексирования для ссылки на первый индекс требуется версия 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
@views expression

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

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

Макрос @views затрагивает только выражения array[...], которые явным образом используются в заданном expression, а не операцию среза массива, которая происходит в функциях, вызываемых этим кодом.
Совместимость: 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(::DataType, ::AbstractArray).

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

 
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)]); # при отображении будет выдана ошибка

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 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
reshape(A, dims...) -> AbstractArray
reshape(A, dims) -> AbstractArray

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

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

Примеры

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

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

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

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

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

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

См. также описание reshape, vec.

Примеры

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

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

julia> b[1,1,1] = 5; a
2×2×1×1 Array{Int64, 4}:
[:, :, 1, 1] =
 5  3
 2  4
vec(a::AbstractArray) -> AbstractVector

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

Примеры

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

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

julia> vec(1:3)
1:3

См. также описание reshape и dropdims.

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

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

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

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

cat(A...; dims)

Выполняет конкатенацию входных массивов в измерениях, указанных в dims.

В измерении d in dims размером выходного массива является sum(size(a,d) for a in A). В других измерениях все входные массивы должны иметь одинаковый размер, который также будет размером выходного массива в этих измерениях.

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

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

Именованный аргумент также принимает Val(dims).

Совместимость: Julia 1.8

Для нескольких измерений в Julia 1.8 было добавлено dims = Val(::Tuple).

Примеры

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

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

Расширенная справка

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

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

cat не объединяет две строки; для этого можно использовать *.

 
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]']  # синтаксис для указания типа элемента
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 = elements in each row (2, 1, 1)
 _______     _
 3           1 = elements in each column (3, 1)
 _____________
 4             = elements in each 3d slice (4,)
 _____________
 4             = elements in each 4d slice (4,)
⇒ shape = ((2, 1, 1), (3, 1), (4,), (4,)) with `row_first` = true
stack(iter; [dims])

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

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

При использовании именованного аргумента dims::Integer i-й элемент итерации (iter) становится срезом selectdim(result, dims, i), так что size(result, dims) == length(iter). В этом случае stack меняет действие функции eachslice на обратное с тем же dims.

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

Совместимость: Julia 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 (если задано) или по умолчанию по последнему измерению.

См. также описание mapslices и eachcol.

Примеры

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

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

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

Примеры

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

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

См. также описание circshift!, circcopy!, bitrotate, <<.

Примеры

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

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

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

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

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

julia> circshift(a, -1)
5-element BitVector:
 1
 0
 0
 1
 1
circshift!(dest, src, shifts)

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

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

См. также описание circshift.

circcopy!(dest, src)

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

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

См. также описание circshift.

Примеры

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

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

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

julia> dest[1:3,2:4] == src[1:3,2:4]
true
findall(A)

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

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

См. также описание findfirst, searchsorted.

Примеры

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

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

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

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

julia> findall(falses(3))
Int64[]
findall(f::Function, A)

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

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

Примеры

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

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

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

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

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

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

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

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

См. также описание findall, findnext, findlast, searchsortedfirst.

Примеры

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

julia> findfirst(A)
3

julia> findfirst(falses(3)) # возвращает 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, если значение true в A отсутствует.

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

См. также описание findfirst, findprev, findall.

Примеры

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

julia> findlast(A)
3

julia> A = falses(2,2);

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

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

См. также описание permutedims!, PermutedDimsArray, transpose и invperm.

Примеры

Двумерные массивы:

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

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 1.5

Для использования 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
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 1.5

Для использования cumprod применительно к итератору, не связанному с массивами, требуется версия 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"
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

Возвращаемым типом eltype массива является Int для целых чисел со знаком меньше размера системного слова или UInt для целых чисел без знака меньше размера системного слова. Для сохранения eltype массивов с небольшими целыми числами со знаком или целыми числами без знака следует использовать accumulate(+, A).

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

In the former case, the integers are widened to system word size and therefore the result is Int64[100, 128]. In the latter case, no such widening happens and integer overflow results in Int8[100, -128].

 
cumsum(itr)

Cumulative sum of an iterator.

See also accumulate to apply functions other than +.

Совместимость: Julia 1.5

cumsum on a non-array iterator requires at least 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]
cumsum!(B, A; dims::Integer)

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

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

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

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

Совместимость: Julia 1.1

Для использования diff для массивов с размерностью выше 2 требуется версия 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
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 являются четырехмерными, f вызывается в x = A[:,:,i,j] для всех i и j и f(x) становится R[:,:,i,j] в результате R.

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

Примеры

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

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

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

julia> f(x::Matrix) = fill(x[1,1], 1,4);  # возвращает матрицу 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 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
eachcol(A::AbstractVecOrMat) <: AbstractVector

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

Обратное действие см. в описании stack(cols) или reduce(``hcat, cols).

См. также описание eachrow, eachslice и mapslices.

Совместимость: 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
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).

См. также описание eachrow, eachcol, mapslices и selectdim.

Совместимость: Julia 1.1

Для этой функции требуется версия Julia не ниже 1.1.
Совместимость: Julia 1.9

До версии Julia 1.9 при этом возвращался итератор и в dims поддерживалось только одно измерение.

Примеры

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

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

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

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

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

invperm(v)

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

См. также описание sortperm, invpermute!, isperm и permutedims.

Примеры

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

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

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

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

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

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

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

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

Примеры

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false
permute!(v, p)

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

Для возвращения новой перестановки используйте v[p]. Как правило, выполняется быстрее, чем permute!(v, p); еще быстрее результат будет получен при записи данных в предварительно выделенный выходной массив с помощью u .= @view v[p]. (Хотя permute! перезаписывает v на месте, для отслеживания того, какие элементы были перемещены, требуется внутреннее выделение памяти.)

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

См. также описание invpermute!.

Примеры

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

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

julia> permute!(A, perm);

julia> A
4-element Vector{Int64}:
 1
 4
 3
 1
invpermute!(v, p)

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

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

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

Примеры

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

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

julia> invpermute!(A, perm);

julia> A
4-element Vector{Int64}:
 4
 1
 3
 1
reverse(A; dims=:)

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

Примеры

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

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

julia> reverse(b)
2×2 Matrix{Int64}:
 4  3
 2  1
Совместимость: Julia 1.6

До Julia 1.6 в reverse поддерживались только одинарные целочисленные dims.

 
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.

Совместимость: Julia 1.6

Для многомерной функции reverse! требуется версия Julia не ниже 1.6.