Массивы

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

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

Создаёт массив, заполненный нулями, с заданным типом элементов 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...)

Создаёт массив, заполненный единицами, с заданным типом элементов 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} <: DenseArray{Bool, N}

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

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

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

Примеры

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

Base.falsesФункция

falses(dims)

Создаёт массив, все значения которого установлены в 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),))

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

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

По умолчанию используется IndexCartesian().

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

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

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

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

Base.broadcast_axes(A)

Вычислить оси для A.

Это следует специализировать только для объектов, которые не определяют axes, но хотят участвовать в широковещательной передаче.

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 для определённых типов контейнеров AbstractArray. Стиль широковещательной передачи, созданный таким образом, не отслеживает размерность; если отслеживание важно для вашего типа, вам следует создать собственный пользовательский 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.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)

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

Из представления массива A, возвращает соответствующие индексы в родительском элементе.

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 (начальное значение 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 по размерности dims массива A, сохраняя результат в B. Начальное значение dims необязательно для векторов. Если задан ключевой аргумент init, его значение используется для инициализации накопления. См. также accumulate.

Примеры

julia> x = [1, 0, 2, 0, 3];

julia> y = [0, 0, 0, 0, 0];

julia> accumulate!(+, y, x);

julia> y
5-element Array{Int64,1}:
 1
 1
 3
 3
 6

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

julia> B = [0 0; 0 0];

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

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

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

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

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::AbstractMatrix; dims::Integer)

Оператор конечных разностей матрицы или вектора A. Если 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 четырёхмерный, 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