Массивы

AbstractArray{T,N}

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

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

AbstractVector{T}

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

AbstractMatrix{T}

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

AbstractVecOrMat{T}

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

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

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

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

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

Примеры

julia> A = Array{Float64, 2}(undef, 2, 3) # N 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)

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

Примеры

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

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

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

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

Примеры

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

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

UndefInitializer

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

Примеры

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

undef

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

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

Примеры

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

Vector{T} <: AbstractVector{T}

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

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

Vector{T}(undef, n)

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

Примеры

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

Vector{T}(nothing, m)

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

Примеры

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

Vector{T}(missing, m)

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

Примеры

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

Matrix{T} <: AbstractMatrix{T}

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

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

Matrix{T}(undef, m, n)

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

Примеры

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

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

Matrix{T}(nothing, m, n)

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

Примеры

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

Matrix{T}(missing, m, n)

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

Примеры

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

VecOrMat{T}

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

Примеры

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

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

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

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

Многомерный плотный массив с элементами типа 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...)

Создаёт массив, заполненный нулями, с типом элемента 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...)

Создаёт массив, заполненный единицами, с типом элемента 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(x, dims::Tuple)
fill(x, dims...)

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

dims может быть указан как кортеж или последовательность аргументов. Например, общее выражение fill(x) создает нульмерный массив, содержащий единственное значение x.

См. также: 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

Если x является ссылкой на объект, все элементы будут ссылаться на один и тот же объект:

julia> A = fill(zeros(2), 2);

julia> A[1][1] = 42; # modifies both A[1][1] and A[2][1]

julia> A
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 Array{Int64,2}:
 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 Array{Float64,2}:
 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 для описания своих местоположений. Часто для эффективного представления этих массивов целых чисел и CartesianIndex используются специальные типы массивов LinearIndices и CartesianIndices соответственно.

Обратите внимание, что 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 для определённых типов контейнеров массивов. Стиль широковещательной рассылки, созданный таким образом, теряет отслеживание размерности; если отслеживание важно для вашего типа, вы должны создать свой собственный пользовательский 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. Размеры двух областей должны совпадать.

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.

Примеры

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)))
2×3 CartesianIndices{2, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)  CartesianIndex(1, 3)
 CartesianIndex(2, 1)  CartesianIndex(2, 2)  CartesianIndex(2, 3)

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

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

julia> cartesian = CartesianIndices((1:3, 1:2))
3×2 CartesianIndices{2, Tuple{UnitRange{Int64}, UnitRange{Int64}}}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)
 CartesianIndex(2, 1)  CartesianIndex(2, 2)
 CartesianIndex(3, 1)  CartesianIndex(3, 2)

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

julia> cartesian = CartesianIndices((1:2:5, 1:2))
3×2 CartesianIndices{2, Tuple{StepRange{Int64, Int64}, UnitRange{Int64}}}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)
 CartesianIndex(3, 1)  CartesianIndex(3, 2)
 CartesianIndex(5, 1)  CartesianIndex(5, 2)

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

Вещание

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

julia> CIs = CartesianIndices((2:3, 5:6))
2×2 CartesianIndices{2, Tuple{UnitRange{Int64}, UnitRange{Int64}}}:
 CartesianIndex(2, 5)  CartesianIndex(2, 6)
 CartesianIndex(3, 5)  CartesianIndex(3, 6)

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

julia> CIs .+ CI
2×2 CartesianIndices{2, Tuple{UnitRange{Int64}, UnitRange{Int64}}}:
 CartesianIndex(5, 9)  CartesianIndex(5, 10)
 CartesianIndex(6, 9)  CartesianIndex(6, 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, если элементы массива хранятся плотно с равномерным линейным смещением.

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

Примеры

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

hcat(A...)

Конкатенация по измерению 2.

Примеры

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

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 = элементы в каждой строке (2, 1, 1) _______ _ 3 1 = элементы в каждом столбце (3, 1) _____________ 4 = элементы в каждом 3d срезе (4,) _____________ 4 = элементы в каждом 4d срезе (4,) => shape = ((2, 1, 1), (3, 1), (4,), (4,)) с 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

Примеры

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

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

julia> accumulate(+, [1,2,3]; init=100)
3-element Vector{Int64}:
 101
 103
 106

julia> accumulate(min, [1,2,-1]; init=0)
3-element Vector{Int64}:
  0
  0
 -1

julia> accumulate(+, fill(1, 3, 3), dims=1)
3×3 Matrix{Int64}:
 1  1  1
 2  2  2
 3  3  3

julia> accumulate(+, fill(1, 3, 3), dims=2)
3×3 Matrix{Int64}:
 1  2  3
 1  2  3
 1  2  3

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

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

Примеры

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

julia> y = [0, 0, 0, 0, 0];

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

julia> y
5-element Vector{Int64}:
 1
 1
 3
 3
 6

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

julia> B = [0 0; 0 0];

julia> accumulate!(-, B, A, dims=1);

julia> B
2×2 Matrix{Int64}:
  1   2
 -2  -2

julia> accumulate!(-, B, A, dims=2);

julia> B
2×2 Matrix{Int64}:
 1  -1
 3  -1

cumprod(A; dims::Integer)

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

Примеры

julia> a = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
 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! для использования предварительно выделенного выходного массива, как для производительности, так и для управления точностью результата (например, для предотвращения переполнения).

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

Примеры

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

julia> cumprod([fill(1//3, 2, 2) for i in 1:3])
3-element Vector{Matrix{Rational{Int64}}}:
 [1//3 1//3; 1//3 1//3]
 [2//9 2//9; 2//9 2//9]
 [4//27 4//27; 4//27 4//27]

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

julia> cumprod(x^2 for x in 1:3)
3-element Vector{Int64}:
  1
  4
 36

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)

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

Примеры

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

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

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

julia> cumsum(x^2 for x in 1:3)
3-element Vector{Int64}:
  1
  5
 14

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)

Поворот матрицы влево на 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 имеет 4 измерения, то 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.