Массивы

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

# Core.AbstractArray — Type

AbstractArray{T,N}

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

См. также описание AbstractVector, AbstractMatrix, eltype, ndims.

# Base.AbstractVector — Type

AbstractVector{T}

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

# Base.AbstractMatrix — Type

AbstractMatrix{T}

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

# Base.AbstractVecOrMat — Type

AbstractVecOrMat{T}

Тип объединения AbstractVector{T} и AbstractMatrix{T}.

# Core.Array — Type

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

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

# Core.Array — Method

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

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

Примеры

julia> A = Array{Float64, 2}(undef, 2, 3) # N задан явным образом
2×3 Matrix{Float64}:
 6.90198e-310  6.90198e-310  6.90198e-310
 6.90198e-310  6.90198e-310  0.0

julia> B = Array{Float64}(undef, 4) # N определен входными данными
4-element Vector{Float64}:
   2.360075077e-314
 NaN
   2.2671131793e-314
   2.299821756e-314

julia> similar(B, 2, 4, 1) # использовать typeof(B) и заданный размер
2×4×1 Array{Float64, 3}:
[:, :, 1] =
 2.26703e-314  2.26708e-314  0.0           2.80997e-314
 0.0           2.26703e-314  2.26708e-314  0.0

# Core.Array — Method

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

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

Примеры

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

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

# Core.Array — Method

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

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

Примеры

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

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

# Core.UndefInitializer — Type

UndefInitializer

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

Примеры

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

# Core.undef — Constant

undef

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

См. также описание missing, similar.

Примеры

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

# Base.Vector — Type

Vector{T} <: AbstractVector{T}

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

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

# Base.Vector — Method

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

# Base.Vector — Method

Vector{T}(nothing, m)

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

Примеры

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

# Base.Vector — Method

Vector{T}(missing, m)

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

Примеры

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

# Base.Matrix — Type

Matrix{T} <: AbstractMatrix{T}

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

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

# Base.Matrix — Method

Matrix{T}(undef, m, n)

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

Примеры

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

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

# Base.Matrix — Method

Matrix{T}(nothing, m, n)

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

Примеры

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

# Base.Matrix — Method

Matrix{T}(missing, m, n)

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

Примеры

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

# Base.VecOrMat — Type

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

# Core.DenseArray — Type

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

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

# Base.DenseVector — Type

DenseVector{T}

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

# Base.DenseMatrix — Type

DenseMatrix{T}

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

# Base.DenseVecOrMat — Type

DenseVecOrMat{T}

Тип объединения DenseVector{T} и DenseMatrix{T}.

# Base.StridedArray — Type

StridedArray{T, N}

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

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

# Base.StridedVector — Type

StridedVector{T}

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

# Base.StridedMatrix — Type

StridedMatrix{T}

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

# Base.StridedVecOrMat — Type

StridedVecOrMat{T}

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

# Base.Slices — Type

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

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

Обычно они строятся с помощью eachslice, eachcol или eachrow.

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

# Base.RowSlices — Type

RowSlices{M,AX,S}

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

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

# Base.ColumnSlices — Type

ColumnSlices{M,AX,S}

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

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

# Base.getindex — Method

getindex(type[, elements...])

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

Примеры

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

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

# Base.zeros — Function

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

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

Примеры

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

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

# Base.ones — Function

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

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

Примеры

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

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

# Base.BitArray — Type

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

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

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

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

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

# Base.BitArray — Method

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

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

Примеры

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

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

# Base.BitArray — Method

BitArray(itr)

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

Примеры

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

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

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

# Base.trues — Function

trues(dims)

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

Примеры

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

# Base.falses — Function

falses(dims)

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

Примеры

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

# Base.fill — Function

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

Создает массив размером dims, где каждому расположению задано значение value.

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

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

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

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

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

julia> value = v[1]
Any[]

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

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

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

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

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

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

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

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

# Base.fill! — Function

fill!(A, x)

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

Примеры

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

julia> fill!(A, 2.)
2×3 Matrix{Float64}:
 2.0  2.0  2.0
 2.0  2.0  2.0

julia> a = [1, 1, 1]; A = fill!(Vector{Vector{Int}}(undef, 3), a); a[1] = 2; A
3-element Vector{Vector{Int64}}:
 [2, 1, 1]
 [2, 1, 1]
 [2, 1, 1]

julia> x = 0; f() = (global x += 1; x); fill!(Vector{Int}(undef, 3), f())
3-element Vector{Int64}:
 1
 1
 1

# Base.empty — Function

empty(x::Tuple)

Возвращает пустой кортеж ().

empty(v::AbstractVector, [eltype])

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

См. также описание empty!, isempty, isassigned.

Примеры

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

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

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

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

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

# Base.similar — Function

similar(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.

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

# Base.ndims — Function

ndims(A::AbstractArray) -> Integer

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

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

Примеры

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

julia> ndims(A)
3

# Base.size — Function

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

# Base.axes — Method

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

# Base.axes — Method

axes(A, d)

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

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

Примеры

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

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

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

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

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

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

# Base.length — Method

length(A::AbstractArray)

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

Примеры

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

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

# Base.keys — Method

keys(a::AbstractArray)

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

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

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

Примеры

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

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

# Base.eachindex — Function

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

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

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

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

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

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

Примеры

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

julia> for i in eachindex(A) # линейное индексирование
           println("A[", i, "] == ", A[i])
       end
A[1] == 10
A[2] == 30
A[3] == 20
A[4] == 40

julia> for i in eachindex(view(A, 1:2, 1:1)) # Декартово индексирование
           println(i)
       end
CartesianIndex(1, 1)
CartesianIndex(2, 1)

# Base.IndexStyle — Type

IndexStyle(A)
IndexStyle(typeof(A))

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

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

По умолчанию используется IndexCartesian().

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

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

# Base.IndexLinear — Type

IndexLinear()

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

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

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

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

# Base.IndexCartesian — Type

IndexCartesian()

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

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

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

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

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

# Base.conj! — Function

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

# Base.stride — Function

stride(A, k::Integer)

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

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

Примеры

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

julia> stride(A,2)
3

julia> stride(A,3)
12

# Base.strides — Function

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.

# Base.Broadcast.broadcast — Function

broadcast(f, As...)

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

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

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

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

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

Примеры

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

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

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

julia> parse.(Int, ["1", "2"])
2-element Vector{Int64}:
 1
 2

julia> abs.((1, -2))
(1, 2)

julia> broadcast(+, 1.0, (0, -2.0))
(1.0, -1.0)

julia> (+).([[0,2], [1,3]], Ref{Vector{Int}}([1,-1]))
2-element Vector{Vector{Int64}}:
 [1, 1]
 [2, 2]

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

# Base.Broadcast.broadcast! — Function

broadcast!(f, dest, As...)

Аналогична broadcast, но хранит результат broadcast(f, As...) в массиве dest. Обратите внимание, что dest используется только для хранения результата, и не предоставляет аргументы для f, пока она тоже не будет указана в As, как в broadcast!(f, A, A, B) для выполнения A[:] = broadcast(f, A, B).

Примеры

julia> A = [1.0; 0.0]; B = [0.0; 0.0];

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

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

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

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

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

# Base.Broadcast.@__dot__ — Macro

@. expr

Преобразует каждый вызов функции или оператор в expr в «вызов с точкой» (например, преобразует f(x) и f.(x)) и преобразует каждое присваивание в expr в «присваивание с точкой» (например, преобразует += в .+=).

Чтобы не добавлять эти точки для выбранных вызовов функции в expr, используйте в вызовах $. Например, @. sqrt(abs($sort(x))) эквивалентно sqrt.(abs.(sort(x))) (нет точки для sort)

(@. эквивалентен символу @__dot__)

Примеры

julia> x = 1.0:3.0; y = similar(x);

julia> @. y = x + 3 * sin(x)
3-element Vector{Float64}:
 3.5244129544236893
 4.727892280477045
 3.4233600241796016

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

# Base.Broadcast.BroadcastStyle — Type

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

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

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

# Base.Broadcast.AbstractArrayStyle — Type

Broadcast.AbstractArrayStyle{N} <: BroadcastStyle является абстрактным супертипом для любого стиля, связанного с типом AbstractArray. Параметр N представляет собой размерность, что может быть удобно для работы с типами AbstractArray, которые поддерживают только конкретные размерности:

struct SparseMatrixStyle <: Broadcast.AbstractArrayStyle{2} end
Base.BroadcastStyle(::Type{<:SparseMatrixCSC}) = SparseMatrixStyle()

Для типов AbstractArray, поддерживающих произвольную размерность, параметру N можно задать значение Any:

struct MyArrayStyle <: Broadcast.AbstractArrayStyle{Any} end
Base.BroadcastStyle(::Type{<:MyArray}) = MyArrayStyle()

В случаях, когда вы хотите иметь возможность смешивать несколько AbstractArrayStyle и контролировать размерность, ваш стиль должен поддерживать конструктор Val:

struct MyArrayStyleDim{N} <: Broadcast.AbstractArrayStyle{N} end
(::Type{<:MyArrayStyleDim})(::Val{N}) where N = MyArrayStyleDim{N}()

Обратите внимание, что если два или более подтипов AbstractArrayStyle конфликтуют, механизм трансляции вернется к созданию Array. Если это нежелательно, может понадобиться определить правила двоичного BroadcastStyle для управления типом вывода.

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

# Base.Broadcast.ArrayStyle — Type

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

# Base.Broadcast.DefaultArrayStyle — Type

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

# Base.Broadcast.broadcastable — Function

Broadcast.broadcastable(x)

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

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

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

Примеры

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

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

julia> Broadcast.broadcastable("hello") # Строки нарушают конвенцию итерации соответствия и действуют как скаляры
Base.RefValue{String}("hello")

# Base.Broadcast.combine_axes — Function

combine_axes(As...) -> Tuple

Определяет оси результатов для трансляции среди всех значений в As.

julia> Broadcast.combine_axes([1], [1 2; 3 4; 5 6])
(Base.OneTo(3), Base.OneTo(2))

julia> Broadcast.combine_axes(1, 1, 1)
()

# Base.Broadcast.combine_styles — Function

combine_styles(cs...) -> BroadcastStyle

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

Примеры

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

# Base.Broadcast.result_style — Function

result_style(s1::BroadcastStyle[, s2::BroadcastStyle]) -> BroadcastStyle

Принимает один или два BroadcastStyle и комбинирует их с помощью типа BroadcastStyle для определения общего BroadcastStyle.

Примеры

julia> Broadcast.result_style(Broadcast.DefaultArrayStyle{0}(), Broadcast.DefaultArrayStyle{3}())
Base.Broadcast.DefaultArrayStyle{3}()

julia> Broadcast.result_style(Broadcast.Unknown(), Broadcast.DefaultArrayStyle{1}())
Base.Broadcast.DefaultArrayStyle{1}()

Индексирование и присваивание

# Base.getindex — Method

getindex(A, inds...)

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

Примеры

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

julia> getindex(A, 1)
1

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

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

# Base.setindex! — Method

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

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

Примеры

julia> A = zeros(2,2);

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

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

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

# Base.copyto! — Method

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

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

Примеры

julia> A = zeros(5, 5);

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

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

julia> Binds = CartesianIndices(B);

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

# Base.copy! — Function

copy!(dst, src) -> dst

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

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

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

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

# Base.isassigned — Function

isassigned(array, i) -> Bool

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

Примеры

julia> isassigned(rand(3, 3), 5)
true

julia> isassigned(rand(3, 3), 3 * 3 + 1)
false

julia> mutable struct Foo end

julia> v = similar(rand(3), Foo)
3-element Vector{Foo}:
 #undef
 #undef
 #undef

julia> isassigned(v, 1)
false

# Base.Colon — Type

Colon()

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

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

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

# Base.IteratorsMD.CartesianIndex — Type

CartesianIndex(i, j, k...)   -> I
CartesianIndex((i, j, k...)) -> I

Создает многомерный индекс I, который можно использовать для индексирования многомерного массива A. В частности, A[I] эквивалентен A[i,j,k...]. Можно легко смешивать целочисленные индексы и индексы CartesianIndex. Например, A[Ipre, i, Ipost] (где Ipre и Ipost являются индексами CartesianIndex, а i — Int) может быть полезным выражением при написании алгоритмов, которые работают в одном измерении массива произвольной размерности.

CartesianIndex иногда создается с помощью функции eachindex и всегда при итерации с явным CartesianIndices.

Примеры

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

[:, :, 2, 1] =
 5  7
 6  8

[:, :, 1, 2] =
  9  11
 10  12

[:, :, 2, 2] =
 13  15
 14  16

julia> A[CartesianIndex((1, 1, 1, 1))]
1

julia> A[CartesianIndex((1, 1, 1, 2))]
9

julia> A[CartesianIndex((1, 1, 2, 1))]
5

# Base.IteratorsMD.CartesianIndices — Type

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

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

for j = jstart:jstep:jstop
    for i = istart:istep:istop
        ...
    end
end

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

CartesianIndices(A::AbstractArray) -> R

Для удобства при создании CartesianIndices из массива формируется диапазон его индексов.

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

Для метода диапазона шагов 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.

# Base.Dims — Type

Dims{N}

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

# Base.LinearIndices — Type

LinearIndices(A::AbstractArray)

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

Для массивов с обычным индексированием (индексы начинаются с 1) или любых многомерных массивов линейные индексы находятся в диапазоне от 1 до length(A). Однако для AbstractVector линейные индексы являются axes(A, 1) и поэтому не начинаются с 1 для векторов с нетрадиционным индексированием.

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

Примеры

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

julia> b = LinearIndices(A);

julia> extrema(b)
(1, 210)

LinearIndices(inds::CartesianIndices) -> R
LinearIndices(sz::Dims) -> R
LinearIndices((istart:istop, jstart:jstop, ...)) -> R

Возвращает массив LinearIndices с указанной формой или axes.

Пример

Основное назначение этого конструктора — интуитивное преобразование декартова индексирования в линейное:

julia> linear = LinearIndices((1:3, 1:2))
3×2 LinearIndices{2, Tuple{UnitRange{Int64}, UnitRange{Int64}}}:
 1  4
 2  5
 3  6

julia> linear[1,2]
4

# Base.to_indices — Function

to_indices(A, I::Tuple)

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

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

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

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

Примеры

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

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

julia> to_indices(A, (1,1,2,20)) # без проверки границ
(1, 1, 2, 20)

julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # необычный индекс
(1, 2, 3, 4)

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

julia> to_indices(A, (1,2)) # без проверки формы
(1, 2)

# Base.checkbounds — Function

checkbounds(Bool, A, I...)

Возвращает true, если указанные индексы I находятся в границах заданного массива A. Подтипы AbstractArray должны специализировать этот метод, если им необходимо реализовать пользовательское поведение проверки границ. Однако во многих случаях можно использовать индексы A и функцию checkindex.

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

Примеры

julia> A = rand(3, 3);

julia> checkbounds(Bool, A, 2)
true

julia> checkbounds(Bool, A, 3, 4)
false

julia> checkbounds(Bool, A, 1:3)
true

julia> checkbounds(Bool, A, 1:3, 2:4)
false

checkbounds(A, I...)

Выдает ошибку, если указанные индексы I находятся за пределами границ заданного массива A.

# Base.checkindex — Function

checkindex(Bool, inds::AbstractUnitRange, index)

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

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

Примеры

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

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

# Base.elsize — Function

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

# Base.view — Function

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

# Base.@view — Macro

@view A[inds...]

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

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

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

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

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

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

# Base.@views — Macro

@views expression

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

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

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

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

Примеры

julia> A = zeros(3, 3);

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

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

# Base.parent — Function

parent(A)

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

Примеры

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

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

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

# Base.parentindices — Function

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

# Base.selectdim — Function

selectdim(A, d::Integer, i)

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

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

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

Примеры

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

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

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

# Base.reinterpret — Function

reinterpret(type, A)

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

Примеры

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

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

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

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

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

Для этого метода требуется версия не ниже Julia 1.6.

Примеры

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

julia> reinterpret(reshape, Complex{Int}, A)    # результатом является вектор
2-element reinterpret(reshape, Complex{Int64}, ::Matrix{Int64}) with eltype Complex{Int64}:
 1 + 3im
 2 + 4im

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

julia> reinterpret(reshape, Int, a)             # результатом является матрица
3×2 reinterpret(reshape, Int64, ::Vector{Tuple{Int64, Int64, Int64}}) with eltype Int64:
 1  4
 2  5
 3  6

# Base.reshape — Function

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

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

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

Примеры

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

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

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

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

# Base.dropdims — Function

dropdims(A; dims)

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

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

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

# Base.vec — Function

vec(a::AbstractArray) -> AbstractVector

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

Примеры

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

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

julia> vec(1:3)
1:3

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

# Base.SubArray — Type

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

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

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

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

# Base.cat — Function

cat(A...; dims)

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

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

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

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

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

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

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

Примеры

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

julia> cat(true, trues(2,2), trues(4)', dims=(1,2))  # блочно-диагональный
4×7 Matrix{Bool}:
 1  0  0  0  0  0  0
 0  1  1  0  0  0  0
 0  1  1  0  0  0  0
 0  0  0  1  1  1  1

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

# Base.vcat — Function

vcat(A...)

Выполняет конкантенацию массивов или чисел по вертикали. Эквивалентна cat(A...; dims=1) и синтаксису [a; b; c].

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

См. также описание функций hcat, Iterators.flatten и stack.

Примеры

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

julia> v == vcat(1, 2, [3,4])  # принимает числа
true

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

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

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

julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # вектор строки и матрица
([10 20 30], [4.0 5.0 6.0; 7.0 8.0 9.0])

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

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

julia> reduce(vcat, vs)  # эффективнее, чем vcat(vs...)
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

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

# Base.hcat — Function

hcat(A...)

Выполняет конкантенацию массивов или чисел по горизонтали. Эквивалентна cat(A...; dims=2) и синтаксису [a b c] или `[a: b;; c]`.

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

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

# Base.hvcat — Function

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

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

Примеры

julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
(1, 2, 3, 4, 5, 6)

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

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

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

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

# Base.hvncat — Function

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

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

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

Примеры

julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
(1, 2, 3, 4, 5, 6)

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

[:, :, 2] =
 4  5  6

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

[:, :, 2] =
 3
 4

[:, :, 3] =
 5
 6

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

[:, :, 2] =
 3  4

[:, :, 3] =
 5  6

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

[:, :, 2] =
 4  5  6

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

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

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

# Base.stack — Function

stack(iter; [dims])

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

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

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

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

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

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

Примеры

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

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

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

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

julia> stack(zip(1:4, 10:99))  # принимает любые итераторы итераторов
2×4 Matrix{Int64}:
  1   2   3   4
 10  11  12  13

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

julia> stack(vecs; dims=1)  # В отличие от любой функции cat, 1-я ось vecs[1] является 2-й осью результата
3×2 Matrix{Float32}:
   1.0    2.0
  30.0   40.0
 500.0  600.0

julia> x = rand(3,4);

julia> x == stack(eachcol(x)) == stack(eachrow(x), dims=1)  # обратная величина каждого среза
true

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

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

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

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

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

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

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

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

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

julia> stack(M) |> size  # более высокие измерения
(2, 3, 5, 7)

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

julia> hvcat(5, M...) |> size  # hvcat размещает матрицы рядом друг с другом
(14, 15)

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

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

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

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

# Base.vect — Function

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

# Base.circshift — Function

circshift(A, shifts)

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

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

Примеры

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

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

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

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

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

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

# Base.circshift! — Function

circshift!(dest, src, shifts)

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

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

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

# Base.circcopy! — Function

circcopy!(dest, src)

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

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

Примеры

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

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

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

julia> dest[1:3,2:4] == src[1:3,2:4]
true

# Base.findall — Method

findall(A)

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

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

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

Примеры

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

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

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

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

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

# Base.findall — Method

findall(f::Function, A)

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

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

Примеры

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

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

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

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

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

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

# Base.findfirst — Method

findfirst(A)

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

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

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

Примеры

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

julia> findfirst(A)
3

julia> findfirst(falses(3)) # возвращает nothing, но не выводится в REPL

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

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

# Base.findfirst — Method

findfirst(predicate::Function, A)

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

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

Примеры

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

julia> findfirst(iseven, A)
2

julia> findfirst(x -> x>10, A) # возвращает nothing, но не выводится в REPL

julia> findfirst(isequal(4), A)
2

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

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

# Base.findlast — Method

findlast(A)

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

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

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

# Base.findlast — Method

findlast(predicate::Function, A)

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

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

Примеры

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

julia> findlast(isodd, A)
3

julia> findlast(x -> x > 5, A) # возвращает nothing, но не выводится в REPL

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

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

# Base.findnext — Method

findnext(A, i)

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

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

# Base.findnext — Method

findnext(predicate::Function, A, i)

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

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

Примеры

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

julia> findnext(isodd, A, 1)
1

julia> findnext(isodd, A, 2) # возвращает nothing, но не выводится в REPL

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

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

# Base.findprev — Method

findprev(A, i)

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

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

# Base.findprev — Method

findprev(predicate::Function, A, i)

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

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

# Base.permutedims — Function

permutedims(A::AbstractArray, perm)

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

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

Примеры

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

[:, :, 2] =
 5  7
 6  8

julia> perm = (3, 1, 2); # последнее измерение размещается первым

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

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

julia> A == permutedims(B, invperm(perm)) # обратная перестановка
true

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

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

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

julia> B = permutedims(A, perm);

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

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

permutedims(m::AbstractMatrix)

Перестанавливает измерения матрицы m путем переворота элементов по диагонали матрицы. Отличается от функции transpose для LinearAlgebra тем, что операция не является рекурсивной.

Примеры

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

julia> b = [5 6; 7 8];

julia> c = [9 10; 11 12];

julia> d = [13 14; 15 16];

julia> X = [[a] [b]; [c] [d]]
2×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]     [5 6; 7 8]
 [9 10; 11 12]  [13 14; 15 16]

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

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

permutedims(v::AbstractVector)

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

Примеры

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

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

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

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

# Base.permutedims! — Function

permutedims!(dest, src, perm)

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

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

# Base.PermutedDimsArrays.PermutedDimsArray — Type

PermutedDimsArray(A, perm) -> B

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

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

Примеры

julia> A = rand(3,5,4);

julia> B = PermutedDimsArray(A, (3,1,2));

julia> size(B)
(4, 3, 5)

julia> B[3,1,2] == A[1,2,3]
true

# Base.promote_shape — Function

promote_shape(s1, s2)

Проверяет две формы массива на совместимость, разрешая конечные одинарные измерения, и возвращает ту форму, которая имеет больше измерений.

Примеры

julia> a = fill(1, (3,4,1,1,1));

julia> b = fill(1, (3,4));

julia> promote_shape(a,b)
(Base.OneTo(3), Base.OneTo(4), Base.OneTo(1), Base.OneTo(1), Base.OneTo(1))

julia> promote_shape((2,3,1,4), (2, 3, 1, 4, 1))
(2, 3, 1, 4, 1)

Функции для работы с массивами

# Base.accumulate — Function

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

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

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

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

Для accumulate в итераторе, не связанном с массивами, требуется версия Julia не ниже 1.5.

Примеры

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

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

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

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

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

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

# Base.accumulate! — Function

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

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

См. также описание функций accumulate, cumsum! и cumprod!.

Примеры

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

julia> y = rand(5);

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

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

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

julia> B = similar(A);

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

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

# Base.cumprod — Function

cumprod(A; dims::Integer)

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

Примеры

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

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

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

cumprod(itr)

Совокупное произведение итератора.

См. также описание функций cumprod!, accumulate и cumsum.

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

Для 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"

# Base.cumprod! — Function

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

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

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

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

# Base.cumsum — Function

cumsum(A; dims::Integer)

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

Примеры

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

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

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

Возвращаемым типом массива 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

В первом случае целочисленные значения расширяются до размера системного слова и, таким образом, результатом является Int64[100, 128]. В последнем случае такого расширения не происходит, и переполнение целочисленных значений дает результат Int8[100, -128].

cumsum(itr)

Совокупная сумма итератора.

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

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

Для cumsum в итераторе, не связанном с массивами, требуется версия Julia не ниже 1.5.

Примеры

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

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

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

# Base.cumsum! — Function

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

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

# Base.diff — Function

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

# Base.repeat — Function

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

Создает массив путем повтора массива A заданное число раз (указанное с помощью counts) в каждом измерении.

См. также описание fill, Iterators.repeated, Iterators.cycle.

Примеры

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

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

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

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

Примеры

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

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

julia> repeat([1 2; 3 4], inner=(2, 1), outer=(1, 3))
4×6 Matrix{Int64}:
 1  2  1  2  1  2
 1  2  1  2  1  2
 3  4  3  4  3  4
 3  4  3  4  3  4

repeat(s::AbstractString, r::Integer)

Повторяет строку r раз. Это можно записать в виде s^r.

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

Примеры

julia> repeat("ha", 3)
"hahaha"

repeat(c::AbstractChar, r::Integer) -> String

Повторяет символ r раз. Это можно также сделать путем вызова c^r.

Примеры

julia> repeat('A', 3)
"AAA"

# Base.rot180 — Function

rot180(A)

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

Примеры

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

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

rot180(A, k)

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

Примеры

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

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

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

# Base.rotl90 — Function

rotl90(A)

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

Примеры

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

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

rotl90(A, k)

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

Примеры

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

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

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

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

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

# Base.rotr90 — Function

rotr90(A)

Поворачивает матрицу A вправо на 90.

Примеры

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

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

rotr90(A, k)

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

Примеры

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

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

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

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

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

# Base.mapslices — Function

mapslices(f, A; dims)

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

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

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

# Base.eachrow — Function

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

# Base.eachcol — Function

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

# Base.eachslice — Function

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

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

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

Обратное действие eachslice(A; dims::Integer) см. в описании stack(slices; dims).

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

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

# Base.invperm — Function

invperm(v)

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

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

Примеры

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

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

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

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

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

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

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

# Base.isperm — Function

isperm(v) -> Bool

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

Примеры

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

# Base.permute! — Method

permute!(v, p)

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

Для возвращения новой перестановки используйте v[p]. Обратите внимание, что это гораздо быстрее, чем permute!(v, p).

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

Примеры

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

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

julia> permute!(A, perm);

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

# Base.invpermute! — Function

invpermute!(v, p)

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

Примеры

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

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

julia> invpermute!(A, perm);

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

# Base.reverse — Method

reverse(A; dims=:)

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

Примеры

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

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

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

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

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

# Base.reverseind — Function

reverseind(v, i)

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

Примеры

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

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

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

# Base.reverse! — Function

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

Встроенная версия reverse.

Примеры

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

julia> reverse!(A);

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

reverse!(A; dims=:)

Аналогична reverse, но работает на месте в A.

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

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