Массивы

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

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}

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

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

Подтипы 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}:
 false
 false

Поскольку 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),))

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

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

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

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

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

Base.IndexLinearТип

IndexLinear()

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

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

Base.IndexCartesianТип

IndexCartesian()

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

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

Base.conj!Функция

conj!(A)

Преобразует массив в его комплексно сопряжённый в месте.

См. также conj.

Примеры

julia> A = [1+im 2-im; 2+2im 3+im]
2×2 Array{Complex{Int64},2}:
 1+1im  2-1im
 2+2im  3+1im

julia> conj!(A);

julia> A
2×2 Array{Complex{Int64},2}:
 1-1im  2+1im
 2-2im  3-1im

Base.strideФункция

stride(A, k::Integer)

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

Примеры

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

julia> stride(A,2)
3

julia> stride(A,3)
12

Base.stridesФункция

strides(A)

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

Примеры

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

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

Трансляция и векторизация

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

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

broadcast(f, As...)

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

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

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

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

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

Примеры

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

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

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

julia> parse.(Int, ["1", "2"])
2-element Array{Int64,1}:
 1
 2

julia> abs.((1, -2))
(1, 2)

julia> broadcast(+, 1.0, (0, -2.0))
(1.0, -1.0)

julia> (+).([[0,2], [1,3]], Ref{Vector{Int}}([1,-1]))
2-element Array{Array{Int64,1},1}:
 [1, 1]
 [2, 2]

julia> string.(("one","two","three","four"), ": ", 1:4)
4-element Array{String,1}:
 "one: 1"
 "two: 2"
 "three: 3"
 "four: 4"

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

broadcast!(f, dest, As...)

Как broadcast, но сохраняет результат broadcast(f, As...) в массиве dest. Обратите внимание, что dest используется только для хранения результата и не предоставляет аргументы для f, если они не указаны также в As, как в broadcast!(f, A, A, B) для выполнения A[:] = broadcast(f, A, B).

Примеры

julia> A = [1.0; 0.0]; B = [0.0; 0.0];

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

julia> B
2-element Array{Float64,1}:
  1.0
 -2.0

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

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

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

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

@. expr

Преобразует каждый вызов функции или оператор в expr в "вызов с точкой" (например, преобразует f(x) в f.(x)), и преобразует каждое присваивание в expr в "присваивание с точкой" (например, преобразует += в .+=).

Если вы хотите избежать добавления точек для определённых вызовов функций в expr, вставьте эти вызовы функций с помощью $. Например, @. sqrt(abs($sort(x))) эквивалентно sqrt.(abs.(sort(x))) (без точки для sort).

(@. эквивалентно вызову @__dot__.)

Примеры

julia> x = 1.0:3.0; y = similar(x);

julia> @. y = x + 3 * sin(x)
3-element Array{Float64,1}:
 3.5244129544236893
 4.727892280477045
 3.4233600241796016

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

Base.Broadcast.BroadcastStyleТип

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

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

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

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

Base.Broadcast.DefaultArrayStyleТип

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

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

Broadcast.broadcastable(x)

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

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

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

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

Более сложные типы индексов могут потребовать больше контекста о размерности, в которую они индексируют. Для поддержки этих случаев to_indices(A, I) вызывает to_indices(A, axes(A), I), который затем рекурсивно проходит по заданному кортежу индексов и размерностным индексам A параллельно. Таким образом, не все типы индексов гарантированно распространяются на Base.to_index.

Base.checkboundsФункция

checkbounds(Bool, A, I...)

Возвращает true если указанные индексы I находятся в пределах границ для данного массива A Подтипы AbstractArray должны специализировать этот метод, если им нужно предоставить пользовательские поведения проверки границ; однако во многих случаях можно положиться на индексы A и checkindex.

См. также checkindex.

Примеры

julia> A = rand(3, 3);

julia> checkbounds(Bool, A, 2)
true

julia> checkbounds(Bool, A, 3, 4)
false

julia> checkbounds(Bool, A, 1:3)
true

julia> checkbounds(Bool, A, 1:3, 2:4)
false

checkbounds(A, I...)

Выбрасывает ошибку, если указанные индексы I не находятся в пределах границ для данного массива A.

Base.checkindexФункция

checkindex(Bool, inds::AbstractUnitRange, index)

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

Примеры

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

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

Представления (SubArrays и другие типы представлений)

Base.viewФункция

view(A, inds...)

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

Примеры

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

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

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

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

Base.@viewМакрос

@view A[inds...]

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

Примеры

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

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

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

julia> A
2×2 Array{Int64,2}:
 0  2
 0  4

Base.@viewsМакрос

@views expression

Преобразует каждую операцию среза массива в данном выражении (которое может быть блоком/циклом/функцией и т. д.) для возврата представления. Скалярные индексы, не массивные типы и явные вызовы getindex (в отличие от array[...]) не затрагиваются.

Примеры

julia> A = zeros(3, 3);

julia> @views for row in 1:3
           b = A[row, :]
           b[:] .= row
       end

julia> A
3×3 Array{Float64,2}:
 1.0  1.0  1.0
 2.0  2.0  2.0
 3.0  3.0  3.0

Base.parentФункция

parent(A)

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

Примеры

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

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

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

Base.parentindicesФункция

parentindices(A)

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

Примеры

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

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

julia> parentindices(V)
(1, Base.Slice(Base.OneTo(2)))

Base.selectdimФункция

selectdim(A, d::Integer, i)

Возвращает представление всех данных A, где индекс для измерения d равен i.

Эквивалентно view(A,:,:,...,i,:,:,...), где i находится в позиции d.

Примеры

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

julia> selectdim(A, 2, 3)
2-element view(::Array{Int64,2}, :, 3) with eltype Int64:
 3
 7

Base.reinterpretФункция

reinterpret(type, A)

Изменяет интерпретацию типа блока памяти. Для массивов это создает представление массива с теми же бинарными данными, что и заданный массив, но со специфицированным типом элементов. Например, reinterpret(Float32, UInt32(7)) интерпретирует 4 байта, соответствующие UInt32(7) как Float32.

Примеры

julia> reinterpret(Float32, UInt32(7))
1.0f-44

julia> reinterpret(Float32, UInt32[1 2 3 4 5])
1×5 reinterpret(Float32, ::Array{UInt32,2}):
 1.4013e-45  2.8026e-45  4.2039e-45  5.60519e-45  7.00649e-45

Base.reshapeФункция

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

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

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

Примеры

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

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

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

julia> reshape(1:6, 2, 3)
2×3 reshape(::UnitRange{Int64}, 2, 3) with eltype Int64:
 1  3  5
 2  4  6

Base.dropdimsФункция

dropdims(A; dims)

Удаляет измерения, указанные dims, из массива A. Элементы dims должны быть уникальными и находиться в диапазоне 1:ndims(A). size(A,i) должно быть равно 1 для всех i в dims.

Примеры

julia> a = reshape(Vector(1:4),(2,2,1,1))
2×2×1×1 Array{Int64,4}:
[:, :, 1, 1] =
 1  3
 2  4

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

Base.vecФункция

vec(a::AbstractArray) -> AbstractVector

Преобразует массив a в одномерный вектор-столбец. Возвращает a если это уже AbstractVector. Полученный массив использует те же базовые данные, что и a, поэтому он будет изменяемым только если a изменяемый, в этом случае изменение одного также изменит другой.

Примеры

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

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

julia> vec(1:3)
1:3

См. также reshape.

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

Base.catФункция

cat(A...; dims=dims)

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

Base.vcatФункция

vcat(A...)

Объединяет вдоль измерения 1.

Примеры

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

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

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

julia> c = ([1 2 3], [4 5 6])
([1 2 3], [4 5 6])

julia> vcat(c...)
2×3 Array{Int64,2}:
 1  2  3
 4  5  6

Base.hcatФункция

hcat(A...)

Объединяет вдоль измерения 2.

Примеры

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

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

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

julia> c = ([1; 2; 3], [4; 5; 6])
([1, 2, 3], [4, 5, 6])

julia> hcat(c...)
3×2 Array{Int64,2}:
 1  4
 2  5
 3  6

Base.hvcatФункция

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

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

Примеры

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

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

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

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

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

Если первый аргумент — целое число n, то предполагается, что все блочные строки имеют n блочных столбцов.

Base.vectФункция

vect(X...)

Создает Vector с типом элемента, вычисляемым из promote_typeof аргумента, содержащего список аргументов.

Примеры

julia> a = Base.vect(UInt8(1), 2.5, 1//2)
3-element Array{Float64,1}:
 1.0
 2.5
 0.5

Base.circshiftФункция

circshift(A, shifts)

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

Примеры

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

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

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

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

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

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

См. также circshift!.

Base.circshift!Функция

circshift!(dest, src, shifts)

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

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

См. также circshift.

Base.circcopy!Функция

circcopy!(dest, src)

Копирует src в dest, индексируя каждое измерение по модулю его длины. src и dest должны иметь одинаковый размер, но могут быть смещены в своих индексах; любое смещение приводит к (циклическому) обходу. Если массивы имеют перекрывающиеся индексы, то в области перекрытия dest совпадает с src.

Примеры

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

julia> dest = OffsetArray{Int}(undef, (0:3,2:5))

julia> circcopy!(dest, src)
OffsetArrays.OffsetArray{Int64,2,Array{Int64,2}} with indices 0:3×2:5:
 8  12  16  4
 5   9  13  1
 6  10  14  2
 7  11  15  3

julia> dest[1:3,2:4] == src[1:3,2:4]
true

Base.findallМетод

findall(A)

Возвращает вектор I индексов или ключей 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 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] размерности и полностью перезаписывается. Не поддерживается работа «на месте», и неожиданные результаты возможны, если массивы src и dest имеют перекрывающиеся области памяти.

См. также permutedims.

Base.PermutedDimsArrays.PermutedDimsArrayТип

PermutedDimsArray(A, perm) -> B

На основе AbstractArray A создать представление B, в котором размерности переставлены. Похоже на permutedims, но без копирования (B использует хранилище A).

См. также: permutedims.

Примеры

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

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

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

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

Base.promote_shapeФункция

promote_shape(s1, s2)

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

Примеры

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

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

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

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

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

Base.accumulateФункция

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

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

Примеры

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

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

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

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

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

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

Base.accumulate!Функция

accumulate!(op, B, A; [dims], [init])

Накопительная операция op над A по размерности dims, сохраняя результат в B. Начальное значение dims необязательно для векторов. Если задан ключевой аргумент init, его значение используется для инициализации накопления. См. также accumulate.

Примеры

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

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

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

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

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

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

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

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

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

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

Base.cumprodФункция

cumprod(A; dims::Integer)

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

Примеры

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

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

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

cumprod(x::AbstractVector)

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

Примеры

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

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

Base.cumprod!Функция

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

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

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

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

Base.cumsumФункция

cumsum(A; dims::Integer)

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

Примеры

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

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

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

cumsum(x::AbstractVector)

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

Примеры

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

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

Base.cumsum!Функция

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

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

Base.diffФункция

diff(A::AbstractVector)
diff(A::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 4-мерно, f вызывается для A[:,:,i,j] для всех i и j.

Примеры

julia> a = reshape(Vector(1:16),(2,2,2,2))
2×2×2×2 Array{Int64,4}:
[:, :, 1, 1] =
 1  3
 2  4

[:, :, 2, 1] =
 5  7
 6  8

[:, :, 1, 2] =
  9  11
 10  12

[:, :, 2, 2] =
 13  15
 14  16

julia> mapslices(sum, a, dims = [1,2])
1×1×2×2 Array{Int64,4}:
[:, :, 1, 1] =
 10

[:, :, 2, 1] =
 26

[:, :, 1, 2] =
 42

[:, :, 2, 2] =
 58

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

Base.invpermФункция

invperm(v)

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

Примеры

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

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

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

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

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

Base.ispermФункция

isperm(v) -> Bool

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

Примеры

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

Base.permute!Метод

permute!(v, p)

Переставляет вектор v на месте согласно перестановке p. Проверка, что p является перестановкой, не выполняется.

Чтобы вернуть новую перестановку, используйте v[p]. Обратите внимание, что это, как правило, быстрее, чем permute!(v,p) для больших векторов.

См. также invpermute!.

Примеры

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

julia> perm = [2, 4, 3, 1];

julia> permute!(A, perm);

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

Base.invpermute!Функция

invpermute!(v, p)

Подобно permute!, но применяется обратная перестановка.

Примеры

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

julia> perm = [2, 4, 3, 1];

julia> invpermute!(A, perm);

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

Base.reverseМетод

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

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

Примеры

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

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

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

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

reverse(A; dims::Integer)

Переворачивает A в измерении dims.

Примеры

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

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

Base.reverseindФункция

reverseind(v, i)

Принимая индекс i в reverse(v), возвращает соответствующий индекс в v так, что v[reverseind(v,i)] == reverse(v)[i]. (Это может быть нетривиально в случаях, когда v содержит символы, не являющиеся ASCII.)

Примеры

julia> r = reverse("Julia")
"ailuJ"

julia> for i in 1:length(r)
           print(r[reverseind("Julia", i)])
       end
Julia

Base.reverse!Функция

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

Функция-аналог reverse для работы на месте.

Примеры

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

julia> reverse!(A);

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