Массивы

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

Core.AbstractArrayТип

AbstractArray{T,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}

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

Core.ArrayМетод

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

Создать неинициализированный многомерный 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}

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

Создаёт неинициализированный 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}:
 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

Base.truesФункция

trues(dims)

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

Примеры

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

Base.falsesФункция

falses(dims)

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

Примеры

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

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

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

Подтипы 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.

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

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 создаст итерируемый объект, который быстр для всех аргументов (a UnitRange, если все входные данные имеют быструю линейную индексацию, a 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. Одиночные и отсутствующие измерения расширяются до соответствия размерам других аргументов путём виртуального повторения значения. По умолчанию только ограниченное число типов рассматриваются как скаляры, включая Numbers, Strings, Symbols, Types, Functions и некоторые общие одиночные значения, такие как 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, но поддерживает 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")

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

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

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

combine_styles(cs...) -> BroadcastStyle

Определяет, какой BroadcastStyle использовать для любого количества аргументов-значений. Использует BroadcastStyle для получения стиля для каждого аргумента и result_style для объединения стилей.

Примеры

julia> Broadcast.combine_styles([1], [1 2; 3 4])
Base.Broadcast.DefaultArrayStyle{2}()

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

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

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

Base.getindexМетод

getindex(A, inds...)

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

Примеры

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

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

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

Создаёт представление SubArray из выражения индексирования. Это можно применить только напрямую к выражению ссылки (например, @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

Преобразуйте каждую операцию слайсинга массива в данном выражении (которое может быть блоком 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

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

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}:
 1
 0
 0
 1

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

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

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

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

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

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

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

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

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

Base.permutedims!Функция

permutedims!(dest, src, perm)

Переставляет размерности массива src и сохраняет результат в массиве dest. perm - вектор, задающий перестановку длиной ndims(src). Предварительно выделенный массив dest должен иметь size(dest) == size(src)[perm] и полностью перезаписывается. Поддержка операций in-place перестановки отсутствует, и могут возникнуть непредсказуемые результаты, если 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)

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

Примеры

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.eachrowФункция

eachrow(A::AbstractVecOrMat)

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

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

Base.eachcolФункция

eachcol(A::AbstractVecOrMat)

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

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

Base.eachsliceФункция

eachslice(A::AbstractArray; dims)

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

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

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

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

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