Массивы

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 в памяти на [stride(A, d)] позиций. Строенные массивы особенно важны и полезны, потому что иногда их можно напрямую передавать как указатели в библиотеки на других языках, таких как BLAS.

StridedVector{T}

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

StridedMatrix{T}

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

StridedVecOrMat{T}

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

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

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

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

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

RowSlices{M,AX,S}

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

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

ColumnSlices{M,AX,S}

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

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

getindex(type[, elements...])

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

Примеры

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

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

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

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

Примеры

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

Примеры

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

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

BitArray(itr)

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

Примеры

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

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

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

trues(dims)

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

Примеры

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

falses(dims)

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

Примеры

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

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

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

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

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

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

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

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

julia> value = v[1]
Any[]

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

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

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

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

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

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

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

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

Примеры

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

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

julia> A = fill(zeros(2), 2) # 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(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}, так как диапазоны не изменяемы и не поддерживают 2 измерения:

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

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

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

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

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

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

similar(storagetype, axes)

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

Примеры:

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

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

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

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

ndims(A::AbstractArray) -> Integer

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

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

Примеры

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

julia> ndims(A)
3

size(A::AbstractArray, [dim])

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

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

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

Примеры

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

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

julia> size(A, 2)
3

axes(A)

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

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

Примеры

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

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

axes(A, d)

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

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

Примеры

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

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

julia> axes(A, 4) == 1:1  # all dimensions d > ndims(A) have size 1
true

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

Каждый из индексов должен быть 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 вместо этого.

Примеры

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

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

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

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

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

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

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

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

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

Примеры

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

julia> for i in eachindex(A) # linear indexing
           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)) # 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], так как 1 + 2*(3 - 1) = 5.

См. также IndexCartesian.

IndexCartesian()

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

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

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

Пересчёт декартовых индексов из линейного индекса значительно сложнее, чем в обратном направлении. Первая операция требует деления — очень дорогостоящей операции — в то время как вторая использует только умножение и сложение и является практически бесплатной. Эта асимметрия означает, что использование линейного индексирования с IndexCartesian массивом намного дороже, чем использование декартова индексирования с IndexLinear массивом.

См. также IndexLinear.

conj!(A)

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

См. также conj.

Примеры

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

julia> conj!(A);

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

stride(A, k::Integer)

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

См. также: strides.

Примеры

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

julia> stride(A,2)
3

julia> stride(A,3)
12

strides(A)

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

См. также: stride.

Примеры

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

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

broadcast(f, As...)

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

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

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

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

Существует специальный синтаксис для распространения: 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 не является массивом, но поддерживает итерацию, индексирование и тип, поддерживающий 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, удаляя любые предварительно существующие элементы в dst. Если dst и src одного типа, dst == src должно сохраниться после вызова. Если dst и src многомерные массивы, они должны иметь одинаковые axes.

См. также copyto!.

isassigned(array, i) -> Bool

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

Примеры

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

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

julia> mutable struct Foo end

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

julia> isassigned(v, 1)
false

Colon()

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

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

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

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

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

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

I::CartesianIndex обрабатывается как «скаляр» (не контейнер) для broadcast. Для итерации по компонентам CartesianIndex, преобразуйте его в кортеж с помощью Tuple(I).

Примеры

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

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

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

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

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

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

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

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

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

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

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

CartesianIndices(A::AbstractArray) -> R

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

Примеры

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

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

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

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

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

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

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

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

Вещание

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

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

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

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

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

Dims{N}

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

LinearIndices(A::AbstractArray)

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

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

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

Примеры

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

julia> b = LinearIndices(A);

julia> extrema(b)
(1, 210)

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

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

Пример

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

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

julia> linear[1,2]
4

to_indices(A, I::Tuple)

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

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

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

julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # exotic index
(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)) # no shape checking
(1, 2)

checkbounds(Bool, A, I...)

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

См. также checkindex.

Примеры

julia> A = rand(3, 3);

julia> checkbounds(Bool, A, 2)
true

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

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

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

checkbounds(A, I...)

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

checkindex(Bool, inds::AbstractUnitRange, index)

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

См. также checkbounds.

Примеры

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

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

elsize(type)

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

Примеры

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

view(A, inds...)

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

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

Примеры

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

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

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

julia> A # 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[...]) не затрагиваются.

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

Примеры

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, SubString, ReshapedArray или LinearAlgebra.Transpose был передан в качестве аргумента в view, reshape, transpose, и т. д. во время создания объекта. Если вход не является обернутым объектом, возвращает сам вход. Если вход обернут несколько раз, будет удалена только внешняя обертка.

Примеры

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

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

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

parentindices(A)

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

Примеры

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

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

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

selectdim(A, d::Integer, i)

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

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

См. также: eachslice.

Примеры

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

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

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

reinterpret(::Type{Out}, x::In)

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

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

julia> reinterpret(NTuple{2, UInt8}, 0x1234)
(0x34, 0x12)

julia> reinterpret(UInt16, (0x34, 0x12))
0x1234

julia> reinterpret(Tuple{UInt16, UInt8}, (0x01, 0x0203))
(0x0301, 0x02)

reinterpret(T::DataType, A::AbstractArray)

Создаёт представление массива с теми же двоичными данными, что и заданный массив, но с T в качестве типа элементов.

Эта функция также работает с «ленивыми» массивами, элементы которых вычисляются только при явном обращении к ним. Например, reinterpret на диапазоне 1:6 работает аналогично плотному вектору collect(1:6):

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

julia> reinterpret(Complex{Int}, 1:6)
3-element reinterpret(Complex{Int64}, ::UnitRange{Int64}):
 1 + 2im
 3 + 4im
 5 + 6im

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 имеет значение true для типов, которые поддерживают быструю линейную индексацию, и false в противном случае.

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

cat(A...; dims)

Конкатенирует входные массивы вдоль измерений, указанных в dims.

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

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

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

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

Примеры

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

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])  # accepts numbers
true

julia> v == [1; 2; [3,4]]  # syntax for the same operation
true

julia> summary(ComplexF64[1; 2; [3,4]])  # syntax for supplying the element type
"4-element Vector{ComplexF64}"

julia> vcat(range(1, 2, length=3))  # collects lazy ranges
3-element Vector{Float64}:
 1.0
 1.5
 2.0

julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # row vector and a matrix
([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)  # more efficient than vcat(vs...)
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

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

hcat(A...)

Горизонтальное объединение массивов или чисел. Эквивалентно cat(A...; dims=2), и синтаксису [a b c] или [a;; b;; c].

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

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

Примеры

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

julia> hcat(1, 2, [30 40], [5, 6, 7]')  # accepts numbers
1×7 Matrix{Int64}:
 1  2  30  40  5  6  7

julia> ans == [1 2 [30 40] [5, 6, 7]']  # syntax for the same operation
true

julia> Float32[1 2 [30 40] [5, 6, 7]']  # syntax for supplying the eltype
1×7 Matrix{Float32}:
 1.0  2.0  30.0  40.0  5.0  6.0  7.0

julia> ms = [zeros(2,2), [1 2; 3 4], [50 60; 70 80]];

julia> reduce(hcat, ms)  # more efficient than 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  # disagrees on a vector of matrices
"2×2×3 Array{Float64, 3}"

julia> hcat(Int[], Int[], Int[])  # empty vectors, each of size (0,)
0×3 Matrix{Int64}

julia> hcat([1.1, 9.9], Matrix(undef, 2, 0))  # hcat with empty 2×0 Matrix
2×1 Matrix{Any}:
 1.1
 9.9

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

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

Примеры

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

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

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

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

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

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

Горизонтальное, вертикальное и n-мерное объединение множества values в одном вызове.

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

Примеры

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

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

[:, :, 2] =
 4  5  6

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

[:, :, 2] =
 3
 4

[:, :, 3] =
 5
 6

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

[:, :, 2] =
 3  4

[:, :, 3] =
 5  6

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

[:, :, 2] =
 4  5  6

Примеры построения аргументов

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

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

stack(iter; [dims])

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

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

С ключевым словом dims::Integer, вместо этого i-й элемент iter становится слайсом selectdim(result, dims, i), так что size(result, dims) == length(iter). В этом случае stack обращает действие eachslice с теми же dims.

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

Примеры

julia> 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))  # accepts any iterators of iterators
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)  # unlike any cat function, 1st axis of vecs[1] is 2nd axis of result
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)  # inverse of eachslice
true

Примеры для многомерных случаев:

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

julia> E = eachslice(A, dims=2);  # a vector of matrices

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  # keeps all dimensions
(2, 3, 5, 7)

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

julia> hvcat(5, M...) |> size  # hvcat puts matrices next to each other
(14, 15)

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

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

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

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

Примеры

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

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

vect(X...)

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

Примеры

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

circshift(A, shifts)

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

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

Примеры

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

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

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

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

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

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

circshift!(dest, src, shifts)

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

См. также circshift.

circcopy!(dest, src)

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

См. также: circshift.

Примеры

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

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

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

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

findall(A)

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

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

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

Примеры

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

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

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

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

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

findall(f::Function, A)

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

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

Примеры

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

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

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

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

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

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

findfirst(A)

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

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

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

Примеры

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

julia> findfirst(A)
3

julia> findfirst(falses(3)) # 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> perm = (3, 1, 2); # put the last dimension first

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)) # the inverse permutation
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, перевернув элементы относительно главной диагонали матрицы. Отличается от 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 (для векторов начальное значение init необязательно). Также можно использовать accumulate! для предварительно выделенного выходного массива, что улучшит производительность и позволит управлять точностью результата (например, для избежания переполнения).

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

Примеры

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

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

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

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

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

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

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

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

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

Примеры

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

julia> y = rand(5);

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

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

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

julia> B = similar(A);

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

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

cumprod(A; dims::Integer)

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

Примеры

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

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

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

cumprod(itr)

Кумулятивное произведение итератора.

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

Примеры

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

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

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

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

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

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

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

cumsum(A; dims::Integer)

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

Примеры

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

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

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

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

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

cumsum(itr)

Кумулятивная сумма итератора.

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

Примеры

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

Примеры

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

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

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

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

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

См. также ^.

Примеры

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

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

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

Примеры

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

rot180(A)

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

Примеры

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

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

rot180(A, k)

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

Примеры

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

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

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

rotl90(A)

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

Примеры

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

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

rotl90(A, k)

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

Примеры

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

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

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

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

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

rotr90(A)

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

Примеры

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

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

rotr90(A, k)

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

Примеры

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

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

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

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

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

mapslices(f, A; dims)

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

Например, если dims = [1,2] и A четырёхмерны, тогда 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);  # returns a 1×4 matrix

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];  # returns a number

julia> mapslices(g, A, dims=[1,3])
1×5×1 Array{Rational{Int64}, 3}:
[:, :, 1] =
 1//21  3//23  1//5  7//27  9//29

julia> map(g, eachslice(A, dims=2))
5-element Vector{Rational{Int64}}:
 1//21
 3//23
 1//5
 7//27
 9//29

julia> mapslices(sum, A; dims=(1,3)) == sum(A; dims=(1,3))
true

Обратите внимание, что в eachslice(A; dims=2), указанное измерение — это то, без двоеточия в срезе. Это view(A,:,i,:), в то время как mapslices(f, A; dims=(1,3)) использует A[:,i,:]. Функция f может изменять значения в срезе, не затрагивая A.

eachrow(A::AbstractVecOrMat) <: AbstractVector

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

Для обратного, см. stack(rows; dims=1).

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

Пример

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

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

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

eachcol(A::AbstractVecOrMat) <: AbstractVector

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

Для обратного, см. stack(cols) или reduce(hcat, cols).

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

Пример

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

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

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

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

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

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

См. stack(slices; dims) для обратного к eachslice(A; dims::Integer).

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

Пример

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

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

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

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

invperm(v)

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

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

Примеры

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

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

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

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

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

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

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

isperm(v) -> Bool

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

Примеры

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

permute!(v, p)

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

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

См. также invpermute!.

Примеры

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

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

julia> permute!(A, perm);

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

invpermute!(v, p)

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

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

Примеры

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

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

julia> invpermute!(A, perm);

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

reverse(A; dims=:)

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

Примеры

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

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

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

reverseind(v, i)

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

Примеры

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

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

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

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

Функция на месте для reverse.

Примеры

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

julia> reverse!(A);

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

reverse!(A; dims=:)

Подобно reverse, но работает на месте в A.