Массивы

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 Array{Union{Nothing, String},1}:
 nothing
 nothing

julia> Array{Union{Nothing, Int}}(nothing, 2, 3)
2×3 Array{Union{Nothing, Int64},2}:
 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 Array{Union{Missing, String},1}:
 missing
 missing

julia> Array{Union{Missing, Int}}(missing, 2, 3)
2×3 Array{Union{Missing, Int64},2}:
 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 Array{Union{Nothing, String},1}:
 nothing
 nothing

Vector{T}(missing, m)

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

Примеры

julia> Vector{Union{Missing, String}}(missing, 2)
2-element Array{Union{Missing, String},1}:
 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 Array{Union{Nothing, String},2}:
 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 Array{Union{Missing, String},2}:
 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}

N-мерный шагающий массив с элементами типа T. Эти массивы следуют интерфейсу шагающих массивов. Если 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 Array{Int8,1}:
 1
 2
 3

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

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

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

Примеры

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

julia> zeros(Int8, 2, 3)
2×3 Array{Int8,2}:
 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 Array{Float64,2}:
 1.0  1.0

julia> ones(ComplexF64, 2, 3)
2×3 Array{Complex{Float64},2}:
 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 BitArray{2}:
 0  0
 0  0

julia> BitArray(undef, (3, 1))
3×1 BitArray{2}:
 0
 0
 0

BitArray(itr)

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

Примеры

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

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

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

trues(dims)

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

Примеры

julia> trues(2,3)
2×3 BitArray{2}:
 1  1  1
 1  1  1

falses(dims)

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

Примеры

julia> falses(2,3)
2×3 BitArray{2}:
 0  0  0
 0  0  0

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

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

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

Примеры

julia> fill(1.0, (5,5))
5×5 Array{Float64,2}:
 1.0  1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0  1.0

julia> fill(0.5, 1, 2)
1×2 Array{Float64,2}:
 0.5  0.5

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

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

fill!(A, x)

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

Примеры

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

julia> fill!(A, 2.)
2×3 Array{Float64,2}:
 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 Array{Array{Int64,1},1}:
 [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 Array{Int64,1}:
 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 BitArray{1}:
 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 , указанным в последнем аргументе. storagetype может быть типом или функцией.

Примеры:

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)

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-мерный пользовательский массив, который сообщает о своём 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 Array{Complex{Int64},2}:
 1+1im  2-1im
 2+2im  3+1im

julia> conj!(A);

julia> A
2×2 Array{Complex{Int64},2}:
 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. Все остальные аргументы итерационно обрабатываются или индексируются.

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

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

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

Примеры

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

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

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

julia> parse.(Int, ["1", "2"])
2-element Array{Int64,1}:
 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 Array{Array{Int64,1},1}:
 [1, 1]
 [2, 2]

julia> string.(("one","two","three","four"), ": ", 1:4)
4-element Array{String,1}:
 "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 Array{Float64,1}:
  1.0
 -2.0

julia> A
2-element Array{Float64,1}:
 1.0
 0.0

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

julia> A
2-element Array{Float64,1}:
  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 Array{Float64,1}:
 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, указывающий, что объект ведёт себя как многомерный массив для трансляции. В частности, 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 Array{Int64,1}:
 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 Array{Int64,2}:
 1  2
 3  4

julia> getindex(A, 1)
1

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

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

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

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

Примеры

julia> A = zeros(2,2);

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

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

julia> A
2×2 Array{Float64,2}:
 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 Array{Foo,1}:
 #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:istop, jstart:jstop, ...)) -> R

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

for j = jstart:jstop
    for i = istart: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)

Трансляция

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

Примеры

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

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

view(A, inds...)

Подобно getindex, но возвращает представление родительского массива A с заданными индексами вместо создания копии. Вызов getindex или setindex! над возвращаемым SubArray вычисляет индексы родительского массива на лету без проверки границ.

Примеры

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

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

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

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

@view A[inds...]

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

Примеры

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

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

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

julia> A
2×2 Array{Int64,2}:
 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 Array{Float64,2}:
 1.0  1.0  1.0
 2.0  2.0  2.0
 3.0  3.0  3.0

parent(A)

Возвращает «родительский массив» типа представления массива (например, SubArray), или сам массив, если это не представление.

Примеры

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

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

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

parentindices(A)

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

Примеры

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

julia> V = view(A, 1, :)
2-element view(::Array{Int64,2}, 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 Array{Int64,2}:
 1  2  3  4
 5  6  7  8

julia> selectdim(A, 2, 3)
2-element view(::Array{Int64,2}, :, 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, ::Array{UInt32,2}):
 1.0f-45  3.0f-45  4.0f-45  6.0f-45  7.0f-45

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

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

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

Примеры

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

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

julia> reshape(A, 2, :)
2×8 Array{Int64,2}:
 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 Array{Int64,2}:
 1  2  3
 4  5  6

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

julia> vec(1:3)
1:3

См. также reshape.

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 Array{Int64,2}:
 1  2  3  4  5

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

julia> vcat(a,b)
3×5 Array{Int64,2}:
  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 Array{Int64,2}:
 1  2  3
 4  5  6

hcat(A...)

Конкатенация вдоль измерения 2.

Примеры

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

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

julia> hcat(a,b)
5×3 Array{Int64,2}:
 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 Array{Int64,2}:
 1  4
 2  5
 3  6

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

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

Примеры

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

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

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

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

julia> hvcat((2,2,2), a,b,c,d,e,f)
3×2 Array{Int64,2}:
 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 Array{Float64,1}:
 1.0
 2.5
 0.5

circshift(A, shifts)

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

Примеры

julia> b = 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> circshift(b, (0,2))
4×4 Array{Int64,2}:
  9  13  1  5
 10  14  2  6
 11  15  3  7
 12  16  4  8

julia> circshift(b, (-1,0))
4×4 Array{Int64,2}:
 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 BitArray{1}:
 1
 1
 0
 0
 1

julia> circshift(a, 1)
5-element BitArray{1}:
 1
 1
 1
 0
 0

julia> circshift(a, -1)
5-element BitArray{1}:
 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 с индексами или ключами true из A. Если таких элементов в A нет, возвращает пустой массив. Для поиска других типов значений передайте предикат в качестве первого аргумента.

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

Примеры

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

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

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

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

julia> findall(falses(3))
0-element Array{Int64,1}

findall(f::Function, A)

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

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

Примеры

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

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

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

julia> findall(!iszero, A)
4-element Array{CartesianIndex{2},1}:
 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 Array{Symbol,1}:
 :A
 :C

findfirst(A)

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

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

Примеры

julia> A = [false, false, true, false]
4-element Array{Bool,1}:
 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 Array{Bool,2}:
 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 Array{Int64,1}:
 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 Array{Int64,2}:
 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 Array{Bool,1}:
 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 Array{Bool,2}:
 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 Array{Int64,1}:
 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 Array{Int64,2}:
 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 Array{Bool,1}:
 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 Array{Bool,2}:
 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 Array{Bool,1}:
 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 Array{Bool,2}:
 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 Array{Int64,1}:
 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 Array{Int64,2}:
 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 Array{Array{Int64,2},2}:
 [1 2; 3 4]     [5 6; 7 8]
 [9 10; 11 12]  [13 14; 15 16]

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

julia> transpose(X)
2×2 Transpose{Transpose{Int64,Array{Int64,2}},Array{Array{Int64,2},2}}:
 [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 Array{Int64,2}:
 1  2  3  4

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

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

julia> transpose(V)
1×2 Transpose{Transpose{Int64,Array{Int64,2}},Array{Array{Int64,2},1}}:
 [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.

Примеры

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

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

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

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

promote_shape(s1, s2)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

julia> accumulate(+, fill(1, 3, 3), dims=2)
3×3 Array{Int64,2}:
 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 Array{Int64,1}:
 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 Array{Int64,2}:
  1   2
 -2  -2

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

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

cumprod(A; dims::Integer)

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

Примеры

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

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

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

cumprod(x::AbstractVector)

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

Примеры

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

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

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 Array{Int64,2}:
 1  2  3
 4  5  6

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

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

cumsum(x::AbstractVector)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

julia> repeat([1, 2, 3], 2, 3)
6×3 Array{Int64,2}:
 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 Array{Int64,1}:
 1
 1
 2
 2

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

julia> repeat([1 2; 3 4], inner=(2, 1), outer=(1, 3))
4×6 Array{Int64,2}:
 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 Array{Int64,2}:
 1  2
 3  4

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

rot180(A, k)

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

Примеры

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

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

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

rotl90(A)

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

Примеры

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

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

rotl90(A, k)

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

Примеры

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

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

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

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

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

rotr90(A)

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

Примеры

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

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

rotr90(A, k)

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

Примеры

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

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

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

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

julia> rotr90(a,4)
2×2 Array{Int64,2}:
 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.

Примеры

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

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

eachcol(A::AbstractVecOrMat)

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

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

eachslice(A::AbstractArray; dims)

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

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

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

invperm(v)

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

Примеры

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

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

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

julia> B = A[v]
4-element Array{Char,1}:
 'b'
 'd'
 'c'
 'a'

julia> B[invperm(v)]
4-element Array{Char,1}:
 'a'
 'b'
 'c'
 'd'

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 Array{Int64,1}:
 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 Array{Int64,1}:
 4
 1
 3
 1

reverse(v [, start=1 [, stop=length(v) ]] )

Возвратить копию v, перевернутую с начала до конца. См. также Iterators.reverse для итерации в обратном порядке без создания копии.

Примеры

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

julia> reverse(A)
5-element Array{Int64,1}:
 5
 4
 3
 2
 1

julia> reverse(A, 1, 4)
5-element Array{Int64,1}:
 4
 3
 2
 1
 5

julia> reverse(A, 3, 5)
5-element Array{Int64,1}:
 1
 2
 5
 4
 3

reverse(A; dims::Integer)

Перевернуть A по размерности dims.

Примеры

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

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

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 Array{Int64,1}:
 1
 2
 3
 4
 5

julia> reverse!(A);

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