Массивы

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}

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

Если A является StridedArray, то его элементы хранятся в памяти со смещениями, которые могут различаться между измерениями, но являются постоянными внутри измерения. Например, A может иметь шаг 2 в измерении 1 и шаг 3 в измерении 2. Увеличение A по измерению d переходит в памяти на [strides(A, d)] позиции. Strided массивы особенно важны и полезны, поскольку иногда их можно передавать непосредственно как указатели во внешние библиотеки, такие как 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.

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

Примеры

julia> fill(1.0, (2,3))
2×3 Array{Float64,2}:
 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 Array{Array{Float64,1},1}:
 [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 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 соответственно. Размеры можно указать либо как единственный кортеж, либо как серию целочисленных аргументов.

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

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

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

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

julia> similar(trues(10,10), 2)
2-element 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, вернёт простой одномерный диапазон, даже если он многомерный.

Пользовательский массив, который указывает свой стиль индексации как IndexLinear, должен реализовать индексацию (и присваивание по индексу) только с помощью одного Int индекса; все остальные выражения индексации, включая многомерный доступ, будут пересчитаны на линейный индекс. Например, если A был бы пользовательской матрицей с линейной индексацией, и мы ссылались на 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. При обнаружении нового типа индекса, который он не может обработать, будет выдано сообщение об ошибке.

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

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

Примеры

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

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

julia> hcat(x, [1; 2; 3])
3×1 Array{Any,2}:
 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 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))
Int64[]

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 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 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 по размерности dims массива A, сохраняя результат в 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(itr)

Кумулятивное произведение итератора. Также см. 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]

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

julia> cumprod(x^2 for x in 1:3)
3-element Array{Int64,1}:
  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 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

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

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

cumsum(itr)

Кумулятивная сумма итератора. Также см. 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]

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

julia> cumsum(x^2 for x in 1:3)
3-element Array{Int64,1}:
  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 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, возвращая строки в виде AbstractVector представлений.

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

Пример

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

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

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

eachcol(A::AbstractVecOrMat)

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

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

Пример

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

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

julia> collect(eachcol(a))
2-element Array{SubArray{Int64,1,Array{Int64,2},Tuple{Base.Slice{Base.OneTo{Int64}},Int64},true},1}:
 [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.

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': 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 Array{Char,1}:
 '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 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