Массивы

AbstractArray{T,N}

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

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.

Примеры

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

julia> B = Array{Float64}(undef, 2) # N determined by the input
2-element Array{Float64, 1}:
 1.87103e-320
 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, используемый при инициализации массивов для указания желания вызывающим конструктором неинициализированного массива.

Примеры

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

Vector{T} <: AbstractVector{T}

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

Vector{T}(undef, n)

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

Примеры

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}.

Matrix{T}(undef, m, n)

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

Примеры

julia> Matrix{Float64}(undef, 2, 3)
2×3 Array{Float64, 2}:
 6.93517e-310  6.93517e-310  6.93517e-310
 6.93517e-310  6.93517e-310  1.29396e-320

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}.

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

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

DenseVector{T}

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

DenseMatrix{T}

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

DenseVecOrMat{T}

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

StridedArray{T, N}

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

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

StridedVector{T}

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

StridedMatrix{T}

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

StridedVecOrMat{T}

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

getindex(type[, elements...])

Создаёт 1-мерный массив указанного типа. Обычно вызывается со синтаксисом 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.

Примеры

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(x, dims::Tuple)
fill(x, dims...)

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

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

Примеры

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

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

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

Подтипы пользовательского Абстрактного массива могут выбрать, какой тип массива лучше всего подходит для возврата для данного типа элементов и размерности. Если они не специализируют этот метод, по умолчанию возвращается 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

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.

Примеры

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

julia> ndims(A)
3

size(A::AbstractArray, [dim])

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

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

Примеры

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

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

julia> size(A, 2)
3

axes(A)

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

Примеры

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

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-мерный пользовательский массив, который сообщает об индексе как 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.

Примеры

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

julia> stride(A,2)
3

julia> stride(A,3)
12

strides(A)

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

Примеры

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.

Примеры

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

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. При обнаружении нового типа индекса, который он не знает как обработать, будет выдано сообщение об ошибке.

Для простых типов индексов он делегирует обработку каждого индекса i скрытой функции Base.to_index(A, 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. Пользовательские типы, которые хотели бы вести себя как индексы для всех массивов, могут расширить этот метод, чтобы предоставить специализированную реализацию проверки границ.

Примеры

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...]

Создает представление из выражения индексирования. Это может быть применено только непосредственно к выражению ссылки (например, @view A[1,2:end]), и не должно использоваться в качестве цели присваивания (например, @view(A[1,2:end]) = ...). См. также @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.

Примеры

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

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)

Удаляет измерения, указанные dims из массива A. Элементы dims должны быть уникальными и находиться в диапазоне 1:ndims(A). size(A,i) должно быть равно 1 для всех i в dims.

Примеры

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

julia> dropdims(a; dims=3)
2×2×1 Array{Int64, 3}:
[:, :, 1] =
 1  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.

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 — это единственное число, различные массивы плотно укладываются вдоль этого измерения. Если dims — это итерируемый объект, содержащий несколько измерений, это позволяет строить блочно-диагональные матрицы и их аналоги высших измерений, одновременно увеличивая несколько измерений для каждого нового входного массива и помещая нулевые блоки в остальных местах. Например, cat(matrices...; dims=(1,2)) создаёт блочно-диагональную матрицу, то есть блочную матрицу с matrices[1], matrices[2], ... в качестве диагональных блоков и соответствующими нулевыми блоками вне диагонали.

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 блочных столбцов.

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)

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

Примеры

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!.

circshift!(dest, src, shifts)

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

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

См. также circshift.

circcopy!(dest, src)

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

Примеры

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 индексов или ключей A. Если таких элементов в A нет, возвращается пустой массив. Для поиска других типов значений передайте предикат в качестве первого аргумента.

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

Примеры

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

Примеры

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

Примеры

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

Примеры

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

См. также: PermutedDimsArray.

Примеры

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

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

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

См. также: permutedims.

Примеры

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! для использования предварительно выделенного массива результата, что улучшает производительность и позволяет управлять точностью результата (например, чтобы избежать переполнения).

Примеры

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.

Примеры

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(x->1, ndims(A)), outer=ntuple(x->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 — четырёхмерный массив, то f вызывается для A[:,:,i,j] для всех i и j.

Примеры

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.

Пример

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 и 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)].

Примеры

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> r = reverse("Julia")
"ailuJ"

julia> for i in 1:length(r)
           print(r[reverseind("Julia", 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.