Массивы

AbstractArray{T,N}

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

См. также: AbstractVector, AbstractMatrix, eltype, ndims.

AbstractVector{T}

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

AbstractMatrix{T}

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

AbstractVecOrMat{T}

Объединение типов AbstractVector{T} и AbstractMatrix{T}.

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

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

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

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

Примеры

julia> A = Array{Float64, 2}(undef, 2, 3) # N given explicitly
2×3 Matrix{Float64}:
 6.90198e-310  6.90198e-310  6.90198e-310
 6.90198e-310  6.90198e-310  0.0

julia> B = Array{Float64}(undef, 4) # N determined by the input
4-element Vector{Float64}:
   2.360075077e-314
 NaN
   2.2671131793e-314
   2.299821756e-314

julia> similar(B, 2, 4, 1) # use typeof(B), and the given size
2×4×1 Array{Float64, 3}:
[:, :, 1] =
 2.26703e-314  2.26708e-314  0.0           2.80997e-314
 0.0           2.26703e-314  2.26708e-314  0.0

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

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

Примеры

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

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

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

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

Примеры

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

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

UndefInitializer

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

Примеры

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

undef

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

См. также: missing, similar.

Примеры

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

Vector{T} <: AbstractVector{T}

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

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

Vector{T}(undef, n)

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

Примеры

julia> Vector{Float64}(undef, 3)
3-element Array{Float64, 1}:
 6.90966e-310
 6.90966e-310
 6.90966e-310

Vector{T}(nothing, m)

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

Примеры

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

Vector{T}(missing, m)

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

Примеры

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

Matrix{T} <: AbstractMatrix{T}

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

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

Matrix{T}(undef, m, n)

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

Примеры

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

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

Matrix{T}(nothing, m, n)

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

Примеры

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

Matrix{T}(missing, m, n)

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

Примеры

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

VecOrMat{T}

Объединение типов Vector{T} и Matrix{T}, позволяющее функциям принимать либо матрицу, либо вектор.

Примеры

julia> Vector{Float64} <: VecOrMat{Float64}
true

julia> Matrix{Float64} <: VecOrMat{Float64}
true

julia> Array{Float64, 3} <: VecOrMat{Float64}
false

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

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

DenseVector{T}

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

DenseMatrix{T}

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

DenseVecOrMat{T}

Объединение типов DenseVector{T} и DenseMatrix{T}.

StridedArray{T, N}

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

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

StridedVector{T}

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

StridedMatrix{T}

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

StridedVecOrMat{T}

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

getindex(type[, elements...])

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

Примеры

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

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

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

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

Примеры

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

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

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

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

Примеры

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

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

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

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

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

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

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

Создаёт undef BitArray с заданными измерениями. Ведёт себя идентично конструктору Array. Смотрите undef.

Примеры

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

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

BitArray(itr)

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

Примеры

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

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

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

trues(dims)

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

Примеры

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

falses(dims)

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

Примеры

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

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

Создайте массив размера dims с каждым элементом, установленным в значение value.

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

Размеры размерностей dims могут быть указаны как кортеж или последовательность аргументов. Кортеж длины N или N аргументов, следующих за value , определяют массив размерности N. Таким образом, распространённый способ создания нульмерного массива, в котором единственный элемент установлен в значение x — это fill(x).

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

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

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

julia> value = v[1]
Any[]

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

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

Для создания массива многих независимых внутренних массивов используйте понимание вместо этого. Это создаёт новый и отдельный массив на каждой итерации цикла:

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

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

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

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

См. также: fill!, zeros, ones, similar.

Примеры

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

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

julia> A = fill(zeros(2), 2) # sets both elements to the same [0.0, 0.0] vector
2-element Vector{Vector{Float64}}:
 [0.0, 0.0]
 [0.0, 0.0]

julia> A[1][1] = 42; # modifies the filled value to be [42.0, 0.0]

julia> A # both A[1] and A[2] are the very same vector
2-element Vector{Vector{Float64}}:
 [42.0, 0.0]
 [42.0, 0.0]

fill!(A, x)

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

Примеры

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

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

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

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

empty(x::Tuple)

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

empty(v::AbstractVector, [eltype])

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

См. также: empty!, isempty, isassigned.

Примеры

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

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

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

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

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

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

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

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

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

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

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

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

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

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

См. также: undef, isassigned.

similar(storagetype, axes)

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

Примеры:

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

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

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

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

ndims(A::AbstractArray) -> Integer

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

См. также: size, axes.

Примеры

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

julia> ndims(A)
3

size(A::AbstractArray, [dim])

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

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

См. также: length, ndims, eachindex, sizeof.

Примеры

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

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

julia> size(A, 2)
3

axes(A)

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

См. также: size, keys, eachindex.

Примеры

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

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

axes(A, d)

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

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

Примеры

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

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

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

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

ix = axes(v, 1)
ix[2:end]          # will work for eg Vector, but may fail in general
ix[(begin+1):end]  # works for generalized indexes

length(A::AbstractArray)

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

Примеры

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

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

keys(a::AbstractArray)

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

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

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

eachindex(A...)

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

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

Примеры

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

julia> for i in eachindex(A) # linear indexing
           println(i)
       end
1
2
3
4

julia> for i in eachindex(view(A, 1:2, 1:1)) # Cartesian indexing
           println(i)
       end
CartesianIndex(1, 1)
CartesianIndex(2, 1)

IndexStyle(A)
IndexStyle(typeof(A))

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

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

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

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

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

IndexLinear()

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

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

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

См. также IndexCartesian.

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.

conj!(A)

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

См. также conj.

Примеры

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

julia> conj!(A);

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

stride(A, k::Integer)

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

См. также: strides.

Примеры

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

julia> stride(A,2)
3

julia> stride(A,3)
12

strides(A)

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

См. также: stride.

Примеры

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

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

broadcast(f, As...)

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

@. expr

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

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

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

См. также Broadcast.DefaultArrayStyle.

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

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

Broadcast.broadcastable(x)

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

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

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

Примеры

julia> Broadcast.broadcastable([1,2,3]) # like `identity` since arrays already support axes and indexing
3-element Vector{Int64}:
 1
 2
 3

julia> Broadcast.broadcastable(Int) # Types don't support axes, indexing, or iteration but are commonly used as scalars
Base.RefValue{Type{Int64}}(Int64)

julia> Broadcast.broadcastable("hello") # Strings break convention of matching iteration and act like a scalar instead
Base.RefValue{String}("hello")

combine_axes(As...) -> Tuple

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

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

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

combine_styles(cs...) -> BroadcastStyle

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

Примеры

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

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

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

Примеры

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

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

getindex(A, inds...)

Возвращает подмножество массива A согласно указанному inds, где каждый 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

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

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

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

Примеры

julia> A = zeros(5, 5);

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

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

julia> Binds = CartesianIndices(B);

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

copy!(dst, src) -> dst

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

См. также copyto!.

isassigned(array, i) -> Bool

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

Примеры

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

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

julia> mutable struct Foo end

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

julia> isassigned(v, 1)
false

Colon()

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

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

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

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

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

CartesianIndex иногда генерируется функцией eachindex, и всегда при итерации с явным CartesianIndices.

Примеры

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

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

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

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

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

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

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

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

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

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

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

CartesianIndices(A::AbstractArray) -> R

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

Примеры

julia> foreach(println, CartesianIndices((2, 2, 2)))
CartesianIndex(1, 1, 1)
CartesianIndex(2, 1, 1)
CartesianIndex(1, 2, 1)
CartesianIndex(2, 2, 1)
CartesianIndex(1, 1, 2)
CartesianIndex(2, 1, 2)
CartesianIndex(1, 2, 2)
CartesianIndex(2, 2, 2)

julia> CartesianIndices(fill(1, (2,3)))
CartesianIndices((2, 3))

Преобразование между линейными и декартовыми индексами

Преобразование линейного индекса в декартов индекс использует тот факт, что CartesianIndices является AbstractArray и может быть индексирован линейно:

julia> cartesian = CartesianIndices((1:3, 1:2))
CartesianIndices((1:3, 1:2))

julia> cartesian[4]
CartesianIndex(1, 2)

julia> cartesian = CartesianIndices((1:2:5, 1:2))
CartesianIndices((1:2:5, 1:2))

julia> cartesian[2, 2]
CartesianIndex(3, 2)

Расширение

CartesianIndices поддерживает трансляцию арифметических операций (+ и -) с CartesianIndex.

julia> CIs = CartesianIndices((2:3, 5:6))
CartesianIndices((2:3, 5:6))

julia> CI = CartesianIndex(3, 4)
CartesianIndex(3, 4)

julia> CIs .+ CI
CartesianIndices((5:6, 9:10))

Для преобразования декартовых индексов в линейные, см. LinearIndices.

Dims{N}

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

LinearIndices(A::AbstractArray)

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

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

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

Примеры

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

julia> b = LinearIndices(A);

julia> extrema(b)
(1, 210)

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

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

Пример

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

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

julia> linear[1,2]
4

to_indices(A, I::Tuple)

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

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

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

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

checkbounds(Bool, A, I...)

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

См. также checkindex.

Примеры

julia> A = rand(3, 3);

julia> checkbounds(Bool, A, 2)
true

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

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

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

checkbounds(A, I...)

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

checkindex(Bool, inds::AbstractUnitRange, index)

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

См. также checkbounds.

Примеры

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

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

elsize(type)

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

Примеры

julia> Base.elsize(rand(Float32, 10))
4

view(A, inds...)

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

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

Примеры

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

julia> b = view(A, :, 1)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

julia> fill!(b, 0)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 0
 0

julia> A # Note A has changed even though we modified b
2×2 Matrix{Int64}:
 0  2
 0  4

julia> view(2:5, 2:3) # returns a range as type is immutable
3:4

@view A[inds...]

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

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

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

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

Примеры

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

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

julia> fill!(b, 0)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 0
 0

julia> A
2×2 Matrix{Int64}:
 0  2
 0  4

@views expression

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

Примеры

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

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

parentindices(A)

Возвращает индексы в parent, которые соответствуют представлению массива A.

Примеры

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

julia> V = view(A, 1, :)
2-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2

julia> parentindices(V)
(1, Base.Slice(Base.OneTo(2)))

selectdim(A, d::Integer, i)

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

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

См. также: eachslice.

Примеры

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

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

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

reinterpret(type, A)

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

Примеры

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

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

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

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

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

Примеры

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

julia> reinterpret(reshape, Complex{Int}, A)    # the result is a vector
2-element reinterpret(reshape, Complex{Int64}, ::Matrix{Int64}) with eltype Complex{Int64}:
 1 + 3im
 2 + 4im

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

julia> reinterpret(reshape, Int, a)             # the result is a matrix
3×2 reinterpret(reshape, Int64, ::Vector{Tuple{Int64, Int64, Int64}}) with eltype Int64:
 1  4
 2  5
 3  6

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

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

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

Примеры

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

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

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

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

dropdims(A; dims)

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

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

См. также: reshape, vec.

Примеры

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

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

julia> b[1,1,1] = 5; a
2×2×1×1 Array{Int64, 4}:
[:, :, 1, 1] =
 5  3
 2  4

vec(a::AbstractArray) -> AbstractVector

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

Примеры

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

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

julia> vec(1:3)
1:3

См. также reshape, dropdims.

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

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

Строить SubArray с помощью функции view.

cat(A...; dims)

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

См. также hcat, vcat, hvcat, repeat.

Примеры

julia> cat([1 2; 3 4], [pi, pi], fill(10, 2,3,1); dims=2)
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

vcat(A...)

Конкатенировать вдоль размерности 1. Для эффективной конкатенации большого вектора массивов используйте reduce(vcat, x).

Примеры

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

julia> b = [6 7 8 9 10; 11 12 13 14 15]
2×5 Matrix{Int64}:
  6   7   8   9  10
 11  12  13  14  15

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

julia> c = ([1 2 3], [4 5 6])
([1 2 3], [4 5 6])

julia> vcat(c...)
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

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

julia> reduce(vcat, vs)
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

hcat(A...)

Конкатенировать вдоль размерности 2. Для эффективной конкатенации большого вектора массивов используйте reduce(hcat, x).

Примеры

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

julia> b = [6 7; 8 9; 10 11; 12 13; 14 15]
5×2 Matrix{Int64}:
  6   7
  8   9
 10  11
 12  13
 14  15

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

julia> c = ([1; 2; 3], [4; 5; 6])
([1, 2, 3], [4, 5, 6])

julia> hcat(c...)
3×2 Matrix{Int64}:
 1  4
 2  5
 3  6

julia> x = Matrix(undef, 3, 0)  # x = [] would have created an Array{Any, 1}, but need an Array{Any, 2}
3×0 Matrix{Any}

julia> hcat(x, [1; 2; 3])
3×1 Matrix{Any}:
 1
 2
 3

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

julia> reduce(hcat, vs)
2×3 Matrix{Int64}:
 1  3  5
 2  4  6

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

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

Примеры

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

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

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 `rowfirst` = true

vect(X...)

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

Примеры

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

circshift(A, shifts)

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

См. также: circshift!, circcopy!, bitrotate, <<.

Примеры

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

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

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

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

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

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

circshift!(dest, src, shifts)

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

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

См. также circshift.

circcopy!(dest, src)

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

См. также: circshift.

Примеры

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

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

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

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

findall(A)

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

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

См. также: findfirst, searchsorted.

Примеры

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

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

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

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

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

findall(f::Function, A)

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

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

Примеры

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

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

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

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

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

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

findfirst(A)

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

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

См. также: findall, findnext, findlast, searchsortedfirst.

Примеры

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

julia> findfirst(A)
3

julia> findfirst(falses(3)) # returns nothing, but not printed in the REPL

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

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

findfirst(predicate::Function, A)

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

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

Примеры

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

julia> findfirst(iseven, A)
2

julia> findfirst(x -> x>10, A) # returns nothing, but not printed in the REPL

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

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

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

findlast(A)

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

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

См. также: findfirst, findprev, findall.

Примеры

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

julia> findlast(A)
3

julia> A = falses(2,2);

julia> findlast(A) # returns nothing, but not printed in the REPL

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

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

findlast(predicate::Function, A)

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

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

Примеры

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

julia> findlast(isodd, A)
3

julia> findlast(x -> x > 5, A) # returns nothing, but not printed in the REPL

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

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

findnext(A, i)

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

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

Примеры

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

julia> findnext(A, 1)
3

julia> findnext(A, 4) # returns nothing, but not printed in the REPL

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

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

findnext(predicate::Function, A, i)

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

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

Примеры

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

julia> findnext(isodd, A, 1)
1

julia> findnext(isodd, A, 2) # returns nothing, but not printed in the REPL

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

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

findprev(A, i)

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

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

См. также: findnext, findfirst, findall.

Примеры

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

julia> findprev(A, 3)
3

julia> findprev(A, 1) # returns nothing, but not printed in the REPL

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

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

findprev(predicate::Function, A, i)

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

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

Примеры

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

julia> findprev(isodd, A, 1) # returns nothing, but not printed in the REPL

julia> findprev(isodd, A, 3)
3

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

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

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> permutedims(A, (3, 2, 1))
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  3
 5  7

[:, :, 2] =
 2  4
 6  8

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

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

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

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

permutedims(m::AbstractMatrix)

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

Примеры

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

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

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

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

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

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

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

permutedims(v::AbstractVector)

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

Примеры

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]

permutedims!(dest, src, perm)

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

См. также permutedims.

PermutedDimsArray(A, perm) -> B

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

См. также permutedims, invperm.

Примеры

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

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

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

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

promote_shape(s1, s2)

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

Примеры

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

См. также accumulate, cumsum!, cumprod!.

Примеры

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

julia> y = rand(5);

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

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

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

julia> B = similar(A);

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

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

cumprod(A; dims::Integer)

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

Примеры

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

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

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

cumprod(itr)

Накопленное произведение итератора.

См. также cumprod!, accumulate, cumsum.

Примеры

julia> cumprod(fill(1//2, 3))
3-element Vector{Rational{Int64}}:
 1//2
 1//4
 1//8

julia> cumprod((1, 2, 1, 3, 1))
(1, 2, 2, 6, 6)

julia> cumprod("julia")
5-element Vector{String}:
 "j"
 "ju"
 "jul"
 "juli"
 "julia"

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

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

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

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

cumsum(A; dims::Integer)

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

Примеры

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

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

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

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

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

cumsum(itr)

Накопленная сумма итератора.

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

Примеры

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

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

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

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

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

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

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

Примеры

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

julia> diff(a, dims=2)
2×1 Matrix{Int64}:
  2
 10

julia> diff(vec(a))
3-element Vector{Int64}:
  4
 -2
 12

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

Создайте массив, повторяя массив A заданное количество раз в каждом измерении, указанное параметром counts.

См. также: fill, Iterators.repeated, Iterators.cycle.

Примеры

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

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

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

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

Примеры

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

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

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

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

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

См. также ^.

Примеры

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

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

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

Примеры

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

rot180(A)

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

Примеры

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

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

rot180(A, k)

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

Примеры

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

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

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

rotl90(A)

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

Примеры

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

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

rotl90(A, k)

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

Примеры

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

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

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

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

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

rotr90(A)

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

Примеры

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

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

rotr90(A, k)

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

Примеры

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

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

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

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

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

mapslices(f, A; dims)

Преобразовать заданные измерения массива A с помощью функции f. f вызывается для каждого среза A вида A[...,:,...,:,...]. dims — целочисленный вектор, определяющий, где в этом выражении стоят двоеточия. Результаты конкатенируются по оставшимся измерениям. Например, если dims равно [1,2] и A — четырёхмерный, f вызывается для A[:,:,i,j] для всех i и j.

См. также eachcol, eachslice.

Примеры

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> mapslices(sum, a, dims = [1,2])
1×1×2×2 Array{Int64, 4}:
[:, :, 1, 1] =
 10

[:, :, 2, 1] =
 26

[:, :, 1, 2] =
 42

[:, :, 2, 2] =
 58

eachrow(A::AbstractVecOrMat)

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

См. также eachcol, eachslice, mapslices.

Пример

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

julia> first(eachrow(a))
2-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2

julia> collect(eachrow(a))
2-element Vector{SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}}:
 [1, 2]
 [3, 4]

eachcol(A::AbstractVecOrMat)

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

См. также eachrow и eachslice.

Пример

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

julia> first(eachcol(a))
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

julia> collect(eachcol(a))
2-element Vector{SubArray{Int64, 1, Matrix{Int64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}}:
 [1, 3]
 [2, 4]

eachslice(A::AbstractArray; dims)

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

В настоящее время поддерживается только одно измерение в dims. Эквивалентно (view(A,:,:,...,i,:,: ...)) for i in axes(A, dims)), где i находится в позиции dims.

См. также eachrow, eachcol, mapslices и selectdim.

Пример

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

julia> first(eachslice(M, dims=1))
3-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2
 3

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

invperm(v)

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

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

Примеры

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

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

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

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

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

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

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

isperm(v) -> Bool

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

Примеры

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

permute!(v, p)

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

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

См. также invpermute!.

Примеры

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

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

julia> permute!(A, perm);

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

invpermute!(v, p)

Как и permute!, но применяется обратное заданное перестановке.

Примеры

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

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

julia> invpermute!(A, perm);

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

reverse(A; dims=:)

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

Примеры

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

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

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

reverseind(v, i)

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

Примеры

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

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

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

reverse!(v [, start=1 [, stop=length(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.