Массивы

Конструкторы и типы

Core.AbstractArrayТип

AbstractArray{T,N}

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

Base.AbstractVectorТип

AbstractVector{T}

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

Base.AbstractMatrixТип

AbstractMatrix{T}

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

Base.AbstractVecOrMatКонстанта

AbstractVecOrMat{T}

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

Core.ArrayТип

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

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

Core.ArrayМетод

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

Core.ArrayМетод

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

Core.ArrayМетод

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

Core.UndefInitializerТип

UndefInitializer

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

Примеры

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

Core.undefКонстанта

undef

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

Примеры

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

Base.VectorТип

Vector{T} <: AbstractVector{T}

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

Base.VectorМетод

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

Base.VectorМетод

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

Base.VectorМетод

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

Base.MatrixТип

Matrix{T} <: AbstractMatrix{T}

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

Base.MatrixМетод

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

Base.MatrixМетод

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

Base.MatrixМетод

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

Base.VecOrMatКонстанта

VecOrMat{T}

Объединение типов Vector{T} и Matrix{T}.

Core.DenseArrayТип

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

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

Base.DenseVectorТип

DenseVector{T}

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

Base.DenseMatrixТип

DenseMatrix{T}

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

Base.DenseVecOrMatКонстанта

DenseVecOrMat{T}

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

Base.StridedArrayКонстанта

StridedArray{T, N}

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

Base.StridedVectorКонстанта

StridedVector{T}

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

Base.StridedMatrixКонстанта

StridedMatrix{T}

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

Base.StridedVecOrMatКонстанта

StridedVecOrMat{T}

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

Base.getindexМетод

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

Base.zerosФункция

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

Создаёт Array, с типом элементов 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

Base.onesФункция

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

Создаёт Array, с типом элементов 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

Base.BitArrayТип

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

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

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

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

Base.BitArrayМетод

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

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

Примеры

julia> BitArray(undef, 2, 2)
2×2 BitArray{2}:
 false  false
 false  true

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

Base.BitArrayМетод

BitArray(itr)

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

Примеры

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

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

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

Base.truesФункция

trues(dims)

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

Примеры

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

Base.falsesФункция

falses(dims)

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

Примеры

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

Base.fillФункция

fill(x, dims)

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

Примеры

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

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

Base.fill!Функция

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

Base.similarФункция

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

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

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

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

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

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

julia> similar(trues(10,10), 2)
2-element BitArray{1}:
 false
 false

Поскольку диапазоны могут хранить только элементы типа 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.

Основные функции

Base.ndimsФункция

ndims(A::AbstractArray) -> Integer

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

Примеры

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

julia> ndims(A)
3

Base.sizeФункция

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

Base.axesМетод

axes(A)

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

Примеры

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

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

Base.axesМетод

axes(A, d)

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

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

Примеры

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

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

Base.lengthМетод

length(A::AbstractArray)

Возвращает количество элементов в массиве, по умолчанию prod(size(A)).

Примеры

julia> length([1, 2, 3, 4])
4

julia> length([1 2; 3 4])
4

Base.eachindexФункция

eachindex(A...)

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

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

Примеры

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)

Base.IndexStyleТип

IndexStyle(A)
IndexStyle(typeof(A))

IndexStyle задаёт "родной стиль индексации" для массива A. При определении нового типа AbstractArray, вы можете выбрать реализацию линейной индексации (с IndexLinear) или декартовой индексации. Если вы решите реализовать линейную индексацию, то вы должны установить этот признак для вашего типа массива:

Base.IndexStyle(::Type{<:MyArray}) = IndexLinear()

По умолчанию IndexCartesian().

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

Если вы определите оба стиля индексации для вашего AbstractArray, этот признак можно использовать для выбора наиболее производительного стиля индексации. Некоторые методы проверяют этот признак у своих входных данных и передают управление различным алгоритмам в зависимости от наиболее эффективной схемы доступа. В частности, eachindex создаёт итератор, тип которого зависит от значения этого признака.

Base.IndexLinearТип

IndexLinear()

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

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

Base.IndexCartesianТип

IndexCartesian()

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

Стиль декартовой индексации использует несколько целых чисел/индексов для описания позиции в массиве. Например, если A была бы типом (2, 3, 4) пользовательской матрицы с декартовой индексацией, мы могли бы сослаться на A[2, 1, 3], и Julia автоматически преобразовала бы это в правильное место в базовой памяти. См. также IndexLinear.

Base.conj!Функция

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

Base.strideФункция

stride(A, k::Integer)

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

Примеры

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

julia> stride(A,2)
3

julia> stride(A,3)
12

Base.stridesФункция

strides(A)

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

Примеры

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

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

Распространение и векторизация

См. также символ точки для векторизации функций; например, f.(args...) неявно вызывает broadcast(f, args...). Вместо того, чтобы полагаться на «векторизованные» методы функций, таких как sin, для работы с массивами, вы должны использовать sin.(a) для векторизации с помощью broadcast.

Base.Broadcast.broadcastФункция

broadcast(f, As...)

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

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

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

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

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

Примеры

julia> A = [1, 2, 3, 4, 5]
5-element 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"

Base.Broadcast.broadcast!Функция

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

Base.Broadcast.@__dot__Макрос

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

Для специализации трансляции на пользовательских типах см.

Base.Broadcast.BroadcastStyleТип

BroadcastStyle — абстрактный тип и функция-аттрибут, используемая для определения поведения объектов при трансляции. BroadcastStyle(typeof(x)) возвращает стиль, связанный с x. Чтобы настроить поведение трансляции типа, можно объявить стиль, определив пару тип/метод.

struct MyContainerStyle <: BroadcastStyle end
Base.BroadcastStyle(::Type{<:MyContainer}) = MyContainerStyle()

Затем необходимо написать метод(ы) (по крайней мере similar), работающие с Broadcasted{MyContainerStyle}. Также существуют несколько предопределенных подтипов BroadcastStyle, которые можно использовать; см. главу «Интерфейсы» в руководстве для получения дополнительной информации.

Base.Broadcast.AbstractArrayStyleТип

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.

Base.Broadcast.ArrayStyleТип

Broadcast.ArrayStyle{MyArrayType}() — это BroadcastStyle, указывающий, что объект ведет себя как массив при трансляции. Он предоставляет простой способ создания Broadcast.AbstractArrayStyle для определённых типов контейнеров. Стиль трансляции, созданный таким образом, теряет информацию о размерности; если сохранение размерности важно для вашего типа, вы должны создать свой собственный пользовательский Broadcast.AbstractArrayStyle.

Base.Broadcast.DefaultArrayStyleТип

Broadcast.DefaultArrayStyle{N}() — это BroadcastStyle, указывающий, что объект ведёт себя как N-мерный массив при трансляции. В частности, DefaultArrayStyle используется для любого типа AbstractArray, который не определил специализированный стиль, и в отсутствие переопределений от других аргументов broadcast, тип результата будет Array. Когда существует множество входных данных для broadcast, DefaultArrayStyle «уступает» любому другому Broadcast.ArrayStyle.

Base.Broadcast.broadcastableФункция

Broadcast.broadcastable(x)

Возвращает либо x, либо объект, подобный x, такой, что он поддерживает axes, индексирование, и его тип поддерживает ndims.

Если x поддерживает итерацию, возвращаемое значение должно иметь такое же поведение при итерации и индексировании, как и collect(x).

Если x не является AbstractArray, но поддерживает итерацию, индексирование, и его тип поддерживает 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")

Индексирование и присваивание

Base.getindexМетод

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

Base.setindex!Метод

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

Base.copyto!Метод

copyto!(dest, Rdest::CartesianIndices, src, Rsrc::CartesianIndices) -> dest

Копирует блок src в диапазоне Rsrc в блок dest в диапазоне Rdest. Размеры двух областей должны совпадать.

Base.isassignedФункция

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

Base.ColonТип

Colon()

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

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

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

Base.IteratorsMD.CartesianIndexТип

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

Base.IteratorsMD.CartesianIndicesТип

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.

Base.DimsТип

Dims{N}

NTuple N Int используется для представления измерений AbstractArray.

Base.LinearIndicesТип

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

Base.to_indicesФункция

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.

Base.checkboundsФункция

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.

Base.checkindexФункция

checkindex(Bool, inds::AbstractUnitRange, index)

Возвращает true если заданный index находится в пределах границ inds.

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

Примеры

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

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

Просмотры (SubArrays и другие типы просмотров)

Base.viewФункция

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

Base.@viewМакрос

@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

Base.@viewsМакрос

@views expression

Преобразует каждую операцию среза массива в данном выражении (которое может быть блоком/блоком кода, циклом, функцией и т. д.) в возврат просмотра. Скалярные индексы, типы, не являющиеся массивами, и явные вызовы 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

Base.parentФункция

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

Base.parentindicesФункция

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

Base.selectdimФункция

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

Base.reinterpretФункция

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.4013e-45  2.8026e-45  4.2039e-45  5.60519e-45  7.00649e-45

Base.reshapeФункция

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

Base.dropdimsФункция

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

Base.vecФункция

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.

Конкатенация и перестановка

Base.catФункция

cat(A...; dims=dims)

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

Base.vcatФункция

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

Base.hcatФункция

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

Base.hvcatФункция

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

Base.vectФункция

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

Base.circshiftФункция

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}:
  true
  true
 false
 false
  true

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

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

См. также circshift!.

Base.circshift!Функция

circshift!(dest, src, shifts)

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

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

См. также circshift.

Base.circcopy!Функция

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

Base.findallМетод

findall(A)

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

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

Примеры

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

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

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

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

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

Base.findallМетод

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

Base.findfirstМетод

findfirst(A)

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

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

Примеры

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

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}:
 false  false
  true  false

julia> findfirst(A)
CartesianIndex(2, 1)

Base.findfirstМетод

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)

Base.findlastМетод

findlast(A)

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

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

Примеры

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

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}:
 true  false
 true  false

julia> findlast(A)
CartesianIndex(2, 1)

Base.findlastМетод

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)

Base.findnextМетод

findnext(A, i)

Находит следующий индекс после или включая i элемента true из A, или nothing в случае отсутствия.

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

Примеры

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

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}:
 false  false
  true  false

julia> findnext(A, CartesianIndex(1, 1))
CartesianIndex(2, 1)

Base.findnextМетод

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)

Base.findprevМетод

findprev(A, i)

Находит предыдущий индекс до или включая i элемента true из A, или nothing в случае отсутствия.

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

Примеры

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

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}:
 false  false
  true   true

julia> findprev(A, CartesianIndex(2, 1))
CartesianIndex(2, 1)

Base.findprevМетод

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)

Base.permutedimsФункция

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]

Base.permutedims!Функция

permutedims!(dest, src, perm)

Переставляет измерения массива src и сохраняет результат в массиве dest. perm — вектор, задающий перестановку длиной ndims(src). Предварительно выделенный массив dest должен иметь size(dest) == size(src)[perm] и полностью перезаписывается. Встроенная перестановка не поддерживается, и будут получены неожиданные результаты, если src и dest имеют перекрывающиеся области памяти.

См. также permutedims.

Base.PermutedDimsArrays.PermutedDimsArrayТип

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

Base.promote_shapeФункция

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)

Функции массивов

Base.accumulateФункция

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

Накопительная операция op по измерению dims массива A (начальное значение dims необязательно для векторов). Начальное значение 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

Base.accumulate!Функция

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

Base.cumprodФункция

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]

Base.cumprod!Функция

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

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

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

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

Base.cumsumФункция

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]

Base.cumsum!Функция

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

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

Base.diffФункция

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

Base.repeatФункция

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"

Base.rot180Функция

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

Base.rotl90Функция

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

Base.rotr90Функция

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

Base.mapslicesФункция

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

Комбинаторика

Base.invpermФункция

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'

Base.ispermФункция

isperm(v) -> Bool

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

Примеры

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

Base.permute!Метод

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

Base.invpermute!Функция

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

Base.reverseМетод

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

Base.reverseindФункция

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

Base.reverse!Функция

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