Массивы

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

Core.AbstractArrayТип

AbstractArray{T, N}

Абстрактный тип массива, от которого наследуются массивы.

Core.ArrayТип

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

Создаёт неинициализированный N-мерный плотный массив с типом элементов T, где N определяется из длины или числа dims. dims может быть кортежем или набором целочисленных аргументов, соответствующих длинам в каждой размерности. Если ранг N задан явно, как в Array{T,N}(dims), то он должен совпадать с длиной или числом dims.

Пример

julia> A = Array{Float64, 2}(2, 2);

julia> ndims(A)
2

julia> eltype(A)
Float64

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([A::AbstractArray,] [T=eltype(A)::Type,] [dims=size(A)::Tuple])

Создаёт массив всех нулей с той же структурой, что и A, типом элементов T и размером dims. Аргумент A можно опустить, что эквивалентно передаче Array{Float64,0}(). Для удобства dims также можно передать в вариативном формате.

Примеры

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

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

julia> zeros(A)
2×2 Array{Int64,2}:
 0  0
 0  0

julia> zeros(A, Float64)
2×2 Array{Float64,2}:
 0.0  0.0
 0.0  0.0

julia> zeros(A, Bool, (3,))
3-element Array{Bool,1}:
 false
 false
 false

См. также ones, similar.

Base.onesФункция

ones([A::AbstractArray,] [T=eltype(A)::Type,] [dims=size(A)::Tuple])

Создаёт массив всех единиц с той же структурой, что и A, типом элементов T и размером dims. Аргумент A можно опустить, что эквивалентно передаче Array{Float64,0}(). Для удобства dims также можно передать в вариативном формате.

Примеры

julia> ones(Complex128, 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

julia> ones(1,2)
1×2 Array{Float64,2}:
 1.0  1.0

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

julia> ones(A)
2×2 Array{Int64,2}:
 1  1
 1  1

julia> ones(A, Float64)
2×2 Array{Float64,2}:
 1.0  1.0
 1.0  1.0

julia> ones(A, Bool, (3,))
3-element Array{Bool,1}:
 true
 true
 true

См. также zeros, similar.

Base.BitArrayТип

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

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

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

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

BitArray(itr)

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

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

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

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

Base.truesФункция

trues(dims)

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

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

trues(A)

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

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

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

Base.falsesФункция

falses(dims)

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

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

falses(A)

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

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

julia> falses(A)
2×2 BitArray{2}:
 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}}(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}(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}(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

Base.similarМетод

similar(storagetype, indices)

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

Примеры:

similar(Array{Int}, indices(A))

создаёт массив, который «подражает» Array{Int} (и может быть реализован через него), но индексируется так же, как A. Если A имеет обычный способ индексирования, это будет идентично Array{Int}(size(A)), но если A имеет необычный способ индексирования, то индексы результата будут соответствовать A.

similar(BitArray, (indices(A, 2),))

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

similar(dims->zeros(Int, dims), indices(A))

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

Base.eyeФункция

eye([T::Type=Float64,] m::Integer, n::Integer)

Матрица тождества m×n. Тип элементов по умолчанию — Float64.

Примеры

julia> eye(3, 4)
3×4 Array{Float64,2}:
 1.0  0.0  0.0  0.0
 0.0  1.0  0.0  0.0
 0.0  0.0  1.0  0.0

julia> eye(2, 2)
2×2 Array{Float64,2}:
 1.0  0.0
 0.0  1.0

julia> eye(Int, 2, 2)
2×2 Array{Int64,2}:
 1  0
 0  1

eye(m, n)

Матрица тождества m×n.

eye([T::Type=Float64,] n::Integer)

Матрица тождества n×n . Тип элементов по умолчанию — Float64.

Примеры

julia> eye(Int, 2)
2×2 Array{Int64,2}:
 1  0
 0  1

julia> eye(2)
2×2 Array{Float64,2}:
 1.0  0.0
 0.0  1.0

eye(A)

Строит матрицу тождества тех же размеров и типа, что и A.

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

julia> eye(A)
3×3 Array{Int64,2}:
 1  0  0
 0  1  0
 0  0  1

Обратите внимание на различие с ones.

Base.linspaceФункция

linspace(start, stop, n=50)

Создаёт диапазон элементов, равномерно распределённых по линейному закону от start до stop.

julia> linspace(1.3,2.9,9)
1.3:0.2:2.9

Base.logspaceФункция

logspace(start::Real, stop::Real, n::Integer=50)

Создаёт вектор n логарифмически распределённых чисел от 10^start до 10^stop.

julia> logspace(1.,10.,5)
5-element Array{Float64,1}:
   10.0
 1778.28
    3.16228e5
    5.62341e7
    1.0e10

Base.Random.randsubseqФункция

randsubseq(A, p) -> Vector

Возвращает вектор, содержащий случайную подпоследовательность заданного массива A, где каждый элемент A включается (в порядке) с независимой вероятностью p. (Сложность линейная по p*length(A), поэтому эта функция эффективна даже если p мал, а A велик). Технически, этот процесс известен как "выборка Бернулли" из A.

Base.Random.randsubseq!Функция

randsubseq!(S, A, p)

Аналогично randsubseq, но результаты сохраняются в S (размер которого изменяется по мере необходимости).

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

Base.ndimsФункция

ndims(A::AbstractArray) -> Integer

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

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

julia> ndims(A)
3

Base.sizeФункция

size(A::AbstractArray, [dim...])

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

julia> A = ones(2,3,4);

julia> size(A, 2)
3

julia> size(A,3,2)
(4, 3)

Base.indicesМетод

indices(A)

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

julia> A = ones(5,6,7);

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

Base.indicesМетод

indices(A, d)

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

julia> A = ones(5,6,7);

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

Base.lengthМетод

length(A::AbstractArray) -> Integer

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

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

julia> length(A)
60

Base.eachindexФункция

eachindex(A...)

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

Пример для разреженного 2-мерного массива:

julia> A = sparse([1, 1, 2], [1, 3, 1], [1, 2, -5])
2×3 SparseMatrixCSC{Int64,Int64} with 3 stored entries:
  [1, 1]  =  1
  [2, 1]  =  -5
  [1, 3]  =  2

julia> for iter in eachindex(A)
           @show iter.I[1], iter.I[2]
           @show A[iter]
       end
(iter.I[1], iter.I[2]) = (1, 1)
A[iter] = 1
(iter.I[1], iter.I[2]) = (2, 1)
A[iter] = -5
(iter.I[1], iter.I[2]) = (1, 2)
A[iter] = 0
(iter.I[1], iter.I[2]) = (2, 2)
A[iter] = 0
(iter.I[1], iter.I[2]) = (1, 3)
A[iter] = 2
(iter.I[1], iter.I[2]) = (2, 3)
A[iter] = 0

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

Base.linearindicesФункция

linearindices(A)

Возвращает UnitRange, определяющий допустимый диапазон индексов для A[i], где i является Int. Для массивов с обычной индексацией (индексы начинаются с 1) или для любого многомерного массива, это 1:length(A); однако, для одномерных массивов с нестандартными индексами, это indices(A, 1).

Вызов этой функции является "безопасным" способом написания алгоритмов, которые используют линейную индексацию.

julia> A = ones(5,6,7);

julia> b = linearindices(A);

julia> extrema(b)
(1, 210)

Base.IndexStyleТип

IndexStyle(A)
IndexStyle(typeof(A))

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

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

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

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

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

Base.countnzФункция

countnz(A) -> Integer

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

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

julia> countnz(A)
6

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 = ones(3,4,5);

julia> stride(A,2)
3

julia> stride(A,3)
12

Base.stridesФункция

strides(A)

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

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

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

Base.ind2subФункция

ind2sub(a, index) -> subscripts

Возвращает кортеж индексов в массиве a соответствующий линейному индексу index.

julia> A = ones(5,6,7);

julia> ind2sub(A,35)
(5, 1, 2)

julia> ind2sub(A,70)
(5, 2, 3)

ind2sub(dims, index) -> subscripts

Возвращает кортеж индексов в массиве с размерами dims, соответствующий линейному индексу index.

Пример:

i, j, ... = ind2sub(size(A), indmax(A))

предоставляет индексы максимального элемента.

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

julia> ind2sub((3,4),3)
(3, 1)

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

Base.sub2indФункция

sub2ind(dims, i, j, k...) -> index

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

julia> sub2ind((5,6,7),1,2,3)
66

julia> sub2ind((5,6,7),1,6,3)
86

Base.LinAlg.checksquareФункция

LinAlg.checksquare(A)

Проверяет, является ли матрица квадратной, и возвращает общую размерность. Для нескольких аргументов возвращает вектор.

Пример

julia> A = ones(4,4); B = zeros(5,5);

julia> LinAlg.checksquare(A, B)
2-element Array{Int64,1}:
 4
 5

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

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

Base.broadcastФункция

broadcast(f, As...)

Распространяет массивы, кортежи, Refы, значения null и/или скаляры As в контейнер соответствующего типа и размерности. В этом контексте всё, что не является подтипом AbstractArray, Ref (кроме Ptrов), Tuple, или Nullable считается скаляром. Результирующий контейнер определяется по следующим правилам:

• Если все аргументы являются скалярами, возвращается скаляр.

• Если аргументы являются кортежами и нулём или более скалярами, возвращается кортеж.

• Если аргументы содержат по крайней мере один массив или Ref, возвращается массив (расширяющий размерности одиночных элементов), Refы обрабатываются как 0-мерные массивы, а кортежи как 1-мерные массивы.

Следующее дополнительное правило применяется к Nullable аргументам: если есть по крайней мере один Nullable, и все аргументы являются скалярами или Nullable, возвращается Nullable, рассматривая Nullableы как «контейнеры».

Существует специальный синтаксис для трансляции: 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> broadcast(+, 1.0, (0, -2.0), Ref(1))
2-element Array{Float64,1}:
 2.0
 0.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"

julia> Nullable("X") .* "Y"
Nullable{String}("XY")

julia> broadcast(/, 1.0, Nullable(2.0))
Nullable{Float64}(0.5)

julia> (1 + im) ./ Nullable{Int}()
Nullable{Complex{Float64}}()

Base.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.52441
 4.72789
 3.42336

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

broadcast_getindex(A, inds...)

Распространяет массивы inds на общий размер, как в broadcast, и возвращает массив результатов A[ks...], где ks проходит по позициям в результате трансляции A.

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> C = broadcast(+,A,B)
5×2 Array{Int64,2}:
  2   3
  5   6
  8   9
 11  12
 14  15

julia> broadcast_getindex(C,[1,2,10])
3-element Array{Int64,1}:
  2
  5
 15

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

broadcast_setindex!(A, X, inds...)

Распространяет массивы X и inds на общий размер и сохраняет значение из каждой позиции в X по индексам в A, заданным теми же позициями в inds.

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

Base.getindexМетод

getindex(A, inds...)

Возвращает подмножество массива A по указанию inds, где каждый ind может быть Int, Range, или 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...)

Сохраняет значения из массива X в подмножестве A по указанию inds.

Base.copy!Метод

copy!(dest, Rdest::CartesianRange, src, Rsrc::CartesianRange) -> 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 ), чтобы представить набор индексов, которые они охватывают, прежде чем использоваться.

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, и всегда при итерировании с явным CartesianRange.

Пример

julia> A = reshape(collect(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.CartesianRangeТип

CartesianRange(Istart::CartesianIndex, Istop::CartesianIndex) -> R
CartesianRange(sz::Dims) -> R
CartesianRange(istart:istop, jstart:jstop, ...) -> R

Определяет область R, охватывающую многомерную прямоугольную область целочисленных индексов. Они чаще всего встречаются в контексте итерации, где for I in R ... end вернёт CartesianIndex индексы I, эквивалентные вложенным циклам

for j = jstart:jstop
    for i = istart:istop
        ...
    end
end

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

julia> foreach(println, CartesianRange((2, 2, 2)))
CartesianIndex{3}((1, 1, 1))
CartesianIndex{3}((2, 1, 1))
CartesianIndex{3}((1, 2, 1))
CartesianIndex{3}((2, 2, 1))
CartesianIndex{3}((1, 1, 2))
CartesianIndex{3}((2, 1, 2))
CartesianIndex{3}((1, 2, 2))
CartesianIndex{3}((2, 2, 2))

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, indices(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 SubArray{Int64,1,Array{Int64,2},Tuple{Base.Slice{Base.OneTo{Int64}},Int64},true}:
 1
 3

julia> fill!(b, 0)
2-element SubArray{Int64,1,Array{Int64,2},Tuple{Base.Slice{Base.OneTo{Int64}},Int64},true}:
 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 SubArray{Int64,1,Array{Int64,2},Tuple{Base.Slice{Base.OneTo{Int64}},Int64},true}:
 1
 3

julia> fill!(b, 0)
2-element SubArray{Int64,1,Array{Int64,2},Tuple{Base.Slice{Base.OneTo{Int64}},Int64},true}:
 0
 0

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

Base.@viewsМакрос

@views expression

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

Обратите внимание, что макрос @views влияет только на array[...] выражения, которые явно появляются в данном expression, а не на операции среза массивов, выполняемые в вызываемых функциях этим кодом.

Base.parentФункция

parent(A)

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

Base.parentindexesФункция

parentindexes(A)

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

Base.slicedimФункция

slicedim(A, d::Integer, i)

Возвращает все данные A, где индекс для размерности d равен i. Эквивалентно 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> slicedim(A,2,3)
2-element Array{Int64,1}:
 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 Array{Float32,2}:
 1.4013f-45  2.8026f-45  4.2039f-45  5.60519f-45  7.00649f-45

Base.reshapeФункция

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

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

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

julia> A = collect(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

Base.squeezeФункция

squeeze(A, dims)

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

Пример

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

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

Base.vecФункция

vec(a::AbstractArray) -> Vector

Преобразует массив 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

См. также reshape.

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

Base.catФункция

cat(dims, A...)

Конкатенирует входные массивы вдоль указанных размерностей в итерируемом dims. Для размерностей, не входящих в dims, все входные массивы должны иметь одинаковый размер, который также будет размером выходного массива вдоль этой размерности. Для размерностей, входящих в dims, размер выходного массива является суммой размеров входных массивов вдоль этой размерности. Если dims является единственным числом, различные массивы плотно размещаются вдоль этой размерности. Если dims является итерируемым, содержащим несколько размерностей, это позволяет строить блочно-диагональные матрицы и их многомерные аналоги, одновременно увеличивая несколько размерностей для каждого нового входного массива и размещая нулевые блоки в других местах. Например, cat([1,2], matrices...) создаёт блочно-диагональную матрицу, то есть блочную матрицу с 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.flipdimФункция

flipdim(A, d::Integer)

Инвертирование A по размерности d.

Пример

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

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

Base.circshiftФункция

circshift(A, shifts)

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

Пример

julia> b = reshape(collect(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

См. также 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(collect(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}((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.containsМетод

contains(fun, itr, x) -> Bool

Возвращает true, если существует хотя бы один элемент y в itr, такой что fun(y,x) равен true.

julia> vec = [10, 100, 200]
3-element Array{Int64,1}:
  10
 100
 200

julia> contains(==, vec, 200)
true

julia> contains(==, vec, 300)
false

julia> contains(>, vec, 100)
true

julia> contains(>, vec, 200)
false

Base.findМетод

find(A)

Возвращает вектор линейных индексов ненулевых элементов в A (определённых A[i]!=0). Часто используется для преобразования булевого массива в массив индексов true элементов. Если в A нет ненулевых элементов, find возвращает пустой массив.

Примеры

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

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

julia> find(zeros(3))
0-element Array{Int64,1}

Base.findМетод

find(f::Function, A)

Возвращает вектор I линейных индексов A где f(A[I]) возвращает true. Если в A нет таких элементов, find возвращает пустой массив.

Примеры

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

julia> find(isodd,A)
2-element Array{Int64,1}:
 1
 2

julia> find(isodd, [2, 4])
0-element Array{Int64,1}

Base.findnФункция

findn(A)

Возвращает вектор индексов по каждой размерности, указывающий на расположение ненулевых элементов в A (определённых A[i]!=0). Если в A нет ненулевых элементов, findn возвращает 2-кортеж пустых массивов.

Примеры

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

julia> findn(A)
([1, 1, 3, 2], [1, 2, 2, 3])

julia> A = zeros(2,2)
2×2 Array{Float64,2}:
 0.0  0.0
 0.0  0.0

julia> findn(A)
(Int64[], Int64[])

Base.findnzФункция

findnz(A)

Возвращает кортеж (I, J, V), где I и J — индексы строк и столбцов ненулевых значений в матрице A, а V — вектор ненулевых значений.

Пример

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

julia> findnz(A)
([1, 1, 3, 2], [1, 2, 2, 3], [1, 2, 4, 3])

Base.findfirstМетод

findfirst(A)

Возвращает линейный индекс первого ненулевого значения в A (определённого A[i]!=0). Возвращает 0, если такое значение не найдено.

Примеры

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

julia> findfirst(A)
2

julia> findfirst(zeros(3))
0

Base.findfirstМетод

findfirst(A, v)

Возвращает линейный индекс первого элемента, равного v в A. Возвращает 0, если v не найден.

Примеры

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

julia> findfirst(A,2)
2

julia> findfirst(A,3)
0

Base.findfirstМетод

findfirst(predicate::Function, A)

Возвращает линейный индекс первого элемента A, для которого predicate возвращает true. Возвращает 0, если такого элемента нет.

Примеры

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

julia> findfirst(iseven, A)
2

julia> findfirst(x -> x>10, A)
0

Base.findlastМетод

findlast(A)

Возвращает линейный индекс последнего ненулевого значения в A (определённого A[i]!=0). Возвращает 0, если в A нет ненулевых значений.

Примеры

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

julia> findlast(A)
2

julia> A = zeros(2,2)
2×2 Array{Float64,2}:
 0.0  0.0
 0.0  0.0

julia> findlast(A)
0

Base.findlastМетод

findlast(A, v)

Возвращает линейный индекс последнего элемента, равного v в A. Возвращает 0, если нет элемента A равного v.

Примеры

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

julia> findlast(A,1)
4

julia> findlast(A,2)
3

julia> findlast(A,3)
0

Base.findlastМетод

findlast(predicate::Function, A)

Возвращает линейный индекс последнего элемента A, для которого predicate возвращает true. Возвращает 0, если такого элемента нет.

Примеры

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

julia> findlast(isodd, A)
2

julia> findlast(x -> x > 5, A)
0

Base.findnextМетод

findnext(A, i::Integer)

Находит следующий линейный индекс >= i ненулевого элемента A, или 0, если не найден.

Примеры

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

julia> findnext(A,1)
2

julia> findnext(A,3)
0

Base.findnextМетод

findnext(predicate::Function, A, i::Integer)

Находит следующий линейный индекс >= i элемента A, для которого predicate возвращает true, или 0, если не найден.

Примеры

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

julia> findnext(isodd, A, 1)
1

julia> findnext(isodd, A, 2)
0

Base.findnextМетод

findnext(A, v, i::Integer)

Находит следующий линейный индекс >= i элемента A равного v (используя ==), или 0, если не найден.

Примеры

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

julia> findnext(A,4,4)
0

julia> findnext(A,4,3)
3

Base.findprevМетод

findprev(A, i::Integer)

Найти предыдущий линейный индекс <= i ненулевого элемента A, или 0, если не найден.

Примеры

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

julia> findprev(A,2)
2

julia> findprev(A,1)
0

Base.findprevМетод

findprev(predicate::Function, A, i::Integer)

Найти предыдущий линейный индекс <= i элемента A, для которого predicate возвращает true, или 0, если не найден.

Примеры

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

julia> findprev(isodd, A, 1)
0

julia> findprev(isodd, A, 3)
2

Base.findprevМетод

findprev(A, v, i::Integer)

Найти предыдущий линейный индекс <= i элемента A равного v (используя ==) или 0, если не найден.

Примеры

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

julia> findprev(A, 1, 4)
2

julia> findprev(A, 1, 1)
0

Base.permutedimsФункция

permutedims(A, perm)

Переставить размерности массива A. perm - вектор, определяющий перестановку длиной ndims(A). Это обобщение транспонирования для многомерных массивов. Транспонирование эквивалентно permutedims(A, [2,1]).

См. также: PermutedDimsArray.

Пример

julia> A = reshape(collect(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

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 = ones(3,4,1,1,1);

julia> b = ones(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, dim=1)

Кумулятивная операция op по размерности dim (по умолчанию 1). См. также 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

accumulate(op, v0, A)

Как accumulate, но с начальным элементом v0. Первый элемент результата будет op(v0, first(A)). Например:

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

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

Base.accumulate!Функция

accumulate!(op, B, A, dim=1)

Кумулятивная операция op по A вдоль размерности, сохраняя результат в B. Размерность по умолчанию равна 1. См. также accumulate.

Base.cumprodФункция

cumprod(A, dim=1)

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

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

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

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

Base.cumprod!Функция

cumprod!(B, A, dim::Integer=1)

Накопленное произведение A вдоль размерности, сохраняя результат в B. Размерность по умолчанию равна 1. См. также cumprod.

Base.cumsumФункция

cumsum(A, dim=1)

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

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

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

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

Base.cumsum!Функция

cumsum!(B, A, dim::Integer=1)

Накопленная сумма A вдоль размерности, сохраняя результат в B. Размерность по умолчанию равна 1. См. также cumsum.

Base.cumsum_kbnФункция

cumsum_kbn(A, [dim::Integer=1])

Накопленная сумма вдоль размерности, использующая алгоритм компенсированной суммирования Кахана-Бабушки-Неймана для дополнительной точности. Размерность по умолчанию равна 1.

Base.LinAlg.diffФункция

diff(A, [dim::Integer=1])

Оператор конечных разностей матрицы или вектора A. Если A является матрицей, вычислить конечную разность по размерности dim (по умолчанию 1).

Пример

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

julia> diff(a,2)
2×1 Array{Int64,2}:
  2
 10

Base.LinAlg.gradientФункция

gradient(F::AbstractVector, [h::Real])

Вычислить разности вдоль вектора F, используя h как расстояние между точками. По умолчанию расстояние равно единице.

Пример

julia> a = [2,4,6,8];

julia> gradient(a)
4-element Array{Float64,1}:
 2.0
 2.0
 2.0
 2.0

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

reducedim(f, A, region[, v0])

Применяет двухаргументную функцию f по измерениям A. region — вектор, определяющий измерения для сокращения, а v0 — начальное значение для использования в сокращениях. Для +, *, max и min аргумент v0 является необязательным.

Ассоциативность сокращения зависит от реализации; если вам нужна определённая ассоциативность, например, слева направо, следует написать свой цикл. См. документацию для reduce.

Примеры

julia> a = reshape(collect(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> reducedim(max, a, 2)
4×1 Array{Int64,2}:
 13
 14
 15
 16

julia> reducedim(max, a, 1)
1×4 Array{Int64,2}:
 4  8  12  16

Base.mapreducedimФункция

mapreducedim(f, op, A, region[, v0])

Возвращает то же, что и reducedim(op, map(f, A), region, f(v0)), но, как правило, быстрее, так как промежуточный массив не используется.

Примеры

julia> a = reshape(collect(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> mapreducedim(isodd, *, a, 1)
1×4 Array{Bool,2}:
 false  false  false  false

julia> mapreducedim(isodd, |, a, 1, true)
1×4 Array{Bool,2}:
 true  true  true  true

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(collect(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, [1,2])
1×1×2×2 Array{Int64,4}:
[:, :, 1, 1] =
 10

[:, :, 2, 1] =
 26

[:, :, 1, 2] =
 42

[:, :, 2, 2] =
 58

Base.sum_kbnФункция

sum_kbn(A)

Возвращает сумму всех элементов A, используя алгоритм компенсированного суммирования Кагана-Бабушки-Неймаиера для повышения точности.

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

Base.Random.randpermФункция

randperm([rng=GLOBAL_RNG,] n::Integer)

Создаёт случайную перестановку длины n. Необязательный аргумент rng задаёт генератор случайных чисел (см. Случайные числа). Для случайной перестановки произвольного вектора см. shuffle или shuffle!.

Пример

julia> rng = MersenneTwister(1234);

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

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) для больших векторов.

См. также ipermute!.

Пример

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

ipermute!(v, p)

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

Пример

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

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

julia> ipermute!(A, perm);

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

Base.Random.randcycleФункция

randcycle([rng=GLOBAL_RNG,] n::Integer)

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

Пример

julia> rng = MersenneTwister(1234);

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

Base.Random.shuffleФункция

shuffle([rng=GLOBAL_RNG,] v)

Возвращает случайную перестановку копии v. Необязательный аргумент rng задаёт генератор случайных чисел (см. Случайные числа). Для перестановки v на месте см. shuffle!. Для получения случайно переставленных индексов см. randperm.

Пример

julia> rng = MersenneTwister(1234);

julia> shuffle(rng, collect(1:10))
10-element Array{Int64,1}:
  6
  1
 10
  2
  3
  9
  5
  7
  4
  8

Base.Random.shuffle!Функция

shuffle!([rng=GLOBAL_RNG,] v)

Функция на месте, соответствующая shuffle: случайная перестановка массива v на месте, необязательно с генератором случайных чисел rng.

Пример

julia> rng = MersenneTwister(1234);

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

Base.reverseФункция

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

Возвращает копию v перевернутую от начала до конца.

Примеры

julia> A = collect(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

Base.reverseindФункция

reverseind(v, i)

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

Base.reverse!Функция

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

Функция на месте, соответствующая reverse.

Битовые массивы

BitArray — это эффективные с точки зрения памяти "упакованные" булевы массивы, которые хранят по одному биту на булево значение. Их можно использовать аналогично Array{Bool} массивам (которые хранят по одному байту на булево значение), и их можно преобразовывать в них и из них с помощью Array(bitarray) и BitArray(array), соответственно.

Base.flipbits!Функция

flipbits!(B::BitArray{N}) -> BitArray{N}

Выполняет побитовую операцию не на B. См. ~.

Пример

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

julia> flipbits!(A)
2×2 BitArray{2}:
 false  false
 false  false

Base.rol!Функция

rol!(dest::BitVector, src::BitVector, i::Integer) -> BitVector

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

rol!(B::BitVector, i::Integer) -> BitVector

Выполняет операцию левого циклического сдвига на месте над B. i управляет тем, на сколько позиций сдвинуть биты.

Base.rolФункция

rol(B::BitVector, i::Integer) -> BitVector

Выполняет операцию левого циклического сдвига, возвращая новый BitVector. i управляет тем, на сколько позиций сдвинуть биты. См. также rol!.

Примеры

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

julia> rol(A,1)
5-element BitArray{1}:
  true
 false
 false
  true
  true

julia> rol(A,2)
5-element BitArray{1}:
 false
 false
  true
  true
  true

julia> rol(A,5)
5-element BitArray{1}:
  true
  true
 false
 false
  true

Base.ror!Функция

ror!(dest::BitVector, src::BitVector, i::Integer) -> BitVector

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

ror!(B::BitVector, i::Integer) -> BitVector

Выполняет операцию правого циклического сдвига на месте над B. i управляет тем, на сколько позиций сдвинуть биты.

Base.rorФункция

ror(B::BitVector, i::Integer) -> BitVector

Выполняет операцию правого циклического сдвига над B, возвращая новый BitVector. i управляет тем, на сколько позиций сдвинуть биты. См. также ror!.

Примеры

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

julia> ror(A,1)
5-element BitArray{1}:
  true
  true
  true
 false
 false

julia> ror(A,2)
5-element BitArray{1}:
 false
  true
  true
  true
 false

julia> ror(A,5)
5-element BitArray{1}:
  true
  true
 false
 false
  true

Разреженные векторы и матрицы

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

Base.SparseArrays.SparseVectorТип

SparseVector{Tv,Ti<:Integer} <: AbstractSparseVector{Tv,Ti}

Тип вектора для хранения разреженных векторов.

Base.SparseArrays.SparseMatrixCSCТип

SparseMatrixCSC{Tv,Ti<:Integer} <: AbstractSparseMatrix{Tv,Ti}

Тип матрицы для хранения разреженных матриц в формате Compressed Sparse Column.

Base.SparseArrays.sparseФункция

sparse(A)

Преобразование AbstractMatrix A в разреженную матрицу.

Пример

julia> A = eye(3)
3×3 Array{Float64,2}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> sparse(A)
3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
  [1, 1]  =  1.0
  [2, 2]  =  1.0
  [3, 3]  =  1.0

sparse(I, J, V,[ m, n, combine])

Создаёт разреженную матрицу S с размерами m x n, такую что S[I[k], J[k]] = V[k]. Функция combine используется для объединения дубликатов. Если m и n не указаны, они устанавливаются в maximum(I) и maximum(J) соответственно. Если функция combine не указана, combine по умолчанию равна +, если элементы V не являются булевыми, в противном случае combine по умолчанию равна |. Все элементы I должны удовлетворять 1 <= I[k] <= m, а все элементы J должны удовлетворять 1 <= J[k] <= n. Числовые нули в (I, J, V) сохраняются как структурные ненулевые элементы; чтобы удалить числовые нули, используйте dropzeros!.

Для дополнительной документации и экспертного драйвера см. Base.SparseArrays.sparse!.

Пример

julia> Is = [1; 2; 3];

julia> Js = [1; 2; 3];

julia> Vs = [1; 2; 3];

julia> sparse(Is, Js, Vs)
3×3 SparseMatrixCSC{Int64,Int64} with 3 stored entries:
  [1, 1]  =  1
  [2, 2]  =  2
  [3, 3]  =  3

Base.SparseArrays.sparsevecФункция

sparsevec(I, V, [m, combine])

Создаёт разреженный вектор S длины m, такой что S[I[k]] = V[k]. Дубликаты объединяются с помощью функции combine, которая по умолчанию равна +, если аргумент combine не указан, если элементы V не являются булевыми, в противном случае combine по умолчанию равна |.

julia> II = [1, 3, 3, 5]; V = [0.1, 0.2, 0.3, 0.2];

julia> sparsevec(II, V)
5-element SparseVector{Float64,Int64} with 3 stored entries:
  [1]  =  0.1
  [3]  =  0.5
  [5]  =  0.2

julia> sparsevec(II, V, 8, -)
8-element SparseVector{Float64,Int64} with 3 stored entries:
  [1]  =  0.1
  [3]  =  -0.1
  [5]  =  0.2

julia> sparsevec([1, 3, 1, 2, 2], [true, true, false, false, false])
3-element SparseVector{Bool,Int64} with 3 stored entries:
  [1]  =  true
  [2]  =  false
  [3]  =  true

sparsevec(d::Dict, [m])

Создаёт разреженный вектор длины m , где ненулевые индексы — ключи из словаря, а ненулевые значения — значения из словаря.

julia> sparsevec(Dict(1 => 3, 2 => 2))
2-element SparseVector{Int64,Int64} with 2 stored entries:
  [1]  =  3
  [2]  =  2

sparsevec(A)

Преобразует вектор A в разреженный вектор длины m.

Пример

julia> sparsevec([1.0, 2.0, 0.0, 0.0, 3.0, 0.0])
6-element SparseVector{Float64,Int64} with 3 stored entries:
  [1]  =  1.0
  [2]  =  2.0
  [5]  =  3.0

Base.SparseArrays.issparseФункция

Возвращает true, если S разреженный, и false в противном случае.

Base.fullФункция

full(S)

Преобразует разреженную матрицу или вектор S в плотную матрицу или вектор.

Пример

julia> A = speye(3)
3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
  [1, 1]  =  1.0
  [2, 2]  =  1.0
  [3, 3]  =  1.0

julia> full(A)
3×3 Array{Float64,2}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

Base.SparseArrays.nnzФункция

nnz(A)

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

Пример

julia> A = speye(3)
3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
  [1, 1]  =  1.0
  [2, 2]  =  1.0
  [3, 3]  =  1.0

julia> nnz(A)
3

Base.SparseArrays.spzerosФункция

spzeros([type,]m[,n])

Создаёт разреженный вектор длины m или разреженную матрицу размера m x n. Этот разреженный массив не будет содержать ненулевых значений. Во время создания не будет выделено памяти для ненулевых значений. Тип по умолчанию — Float64, если не указан.

Примеры

julia> spzeros(3, 3)
3×3 SparseMatrixCSC{Float64,Int64} with 0 stored entries

julia> spzeros(Float32, 4)
4-element SparseVector{Float32,Int64} with 0 stored entries

Base.SparseArrays.sponesФункция

spones(S)

Создаёт разреженный массив с той же структурой, что и у S, но с каждым ненулевым элементом, имеющим значение 1.0.

Пример

julia> A = sparse([1,2,3,4],[2,4,3,1],[5.,4.,3.,2.])
4×4 SparseMatrixCSC{Float64,Int64} with 4 stored entries:
  [4, 1]  =  2.0
  [1, 2]  =  5.0
  [3, 3]  =  3.0
  [2, 4]  =  4.0

julia> spones(A)
4×4 SparseMatrixCSC{Float64,Int64} with 4 stored entries:
  [4, 1]  =  1.0
  [1, 2]  =  1.0
  [3, 3]  =  1.0
  [2, 4]  =  1.0

Обратите внимание на разницу с speye.

Base.SparseArrays.speyeМетод

speye([type,]m[,n])

Создаёт разрешённую единичную матрицу размера m x m. При указании n, создаёт разрешённую единичную матрицу размера m x n. Тип по умолчанию — Float64, если не указан.

sparse(I, m, n) эквивалентно speye(Int, m, n), и sparse(α*I, m, n) может быть использовано для эффективного создания разрежённой кратной α единичной матрицы.

Base.SparseArrays.speyeМетод

speye(S)

Создаёт разрешённую единичную матрицу с тем же размером, что и у S.

Пример

julia> A = sparse([1,2,3,4],[2,4,3,1],[5.,4.,3.,2.])
4×4 SparseMatrixCSC{Float64,Int64} with 4 stored entries:
  [4, 1]  =  2.0
  [1, 2]  =  5.0
  [3, 3]  =  3.0
  [2, 4]  =  4.0

julia> speye(A)
4×4 SparseMatrixCSC{Float64,Int64} with 4 stored entries:
  [1, 1]  =  1.0
  [2, 2]  =  1.0
  [3, 3]  =  1.0
  [4, 4]  =  1.0

Обратите внимание на разницу с spones.

speye([type,]m[,n])

Создаёт разрешённую единичную матрицу размера m x m. При указании n, создаёт разрешённую единичную матрицу размера m x n. Тип по умолчанию — Float64, если не указан.

sparse(I, m, n) эквивалентно speye(Int, m, n), и sparse(α*I, m, n) можно использовать для эффективного создания разреженной множественной α единичной матрицы.

Base.SparseArrays.spdiagmФункция

spdiagm(B, d[, m, n])

Построение разреженной диагональной матрицы. B — это кортеж векторов, содержащих диагонали, а d — это кортеж, содержащий позиции диагоналей. В случае, если входные данные содержат только одну диагональ, B может быть вектором (вместо кортежа), а d может быть позицией диагонали (вместо кортежа), по умолчанию равной 0 (диагональ). Необязательно, m и n задают размер получаемой разреженной матрицы.

Пример

julia> spdiagm(([1,2,3,4],[4,3,2,1]),(-1,1))
5×5 SparseMatrixCSC{Int64,Int64} with 8 stored entries:
  [2, 1]  =  1
  [1, 2]  =  4
  [3, 2]  =  2
  [2, 3]  =  3
  [4, 3]  =  3
  [3, 4]  =  2
  [5, 4]  =  4
  [4, 5]  =  1

Base.SparseArrays.sprandФункция

sprand([rng],[type],m,[n],p::AbstractFloat,[rfn])

Создание случайного по длине m разреженного вектора или m по n разреженной матрицы, в которой вероятность любого элемента, отличного от нуля, независимо задаётся p (и, следовательно, средняя плотность ненулевых элементов также точно равна p). Значения, отличные от нуля, выбираются из распределения, заданного rfn, и имеют тип type. Используется равномерное распределение, если rfn не указано. Необязательный аргумент rng задаёт генератор псевдослучайных чисел, см. Случайные числа.

Пример

julia> rng = MersenneTwister(1234);

julia> sprand(rng, Bool, 2, 2, 0.5)
2×2 SparseMatrixCSC{Bool,Int64} with 2 stored entries:
  [1, 1]  =  true
  [2, 1]  =  true

julia> sprand(rng, Float64, 3, 0.75)
3-element SparseVector{Float64,Int64} with 1 stored entry:
  [3]  =  0.298614

Base.SparseArrays.sprandnФункция

sprandn([rng], m[,n],p::AbstractFloat)

Создание случайного разреженного вектора длины m или разреженной матрицы размера m на n с заданной (независимой) вероятностью p любого элемента, отличного от нуля, где значения, отличные от нуля, выбираются из нормального распределения. Необязательный аргумент rng задаёт генератор псевдослучайных чисел, см. Случайные числа.

Пример

julia> rng = MersenneTwister(1234);

julia> sprandn(rng, 2, 2, 0.75)
2×2 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
  [1, 1]  =  0.532813
  [2, 1]  =  -0.271735
  [2, 2]  =  0.502334

Base.SparseArrays.nonzerosФункция

nonzeros(A)

Возвращает вектор структурных ненулевых значений в разреженной матрице A. Это включает нули, которые явно хранятся в разреженной матрице. Возвращаемый вектор напрямую указывает на внутреннее хранилище ненулевых значений A, и любые изменения в возвращаемом векторе также изменят A . См. rowvals и nzrange.

Пример

julia> A = speye(3)
3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
  [1, 1]  =  1.0
  [2, 2]  =  1.0
  [3, 3]  =  1.0

julia> nonzeros(A)
3-element Array{Float64,1}:
 1.0
 1.0
 1.0

Base.SparseArrays.rowvalsФункция

rowvals(A::SparseMatrixCSC)

Возвращает вектор индексов строк A. Любые изменения в возвращаемом векторе также изменят A. Предоставление доступа к тому, как хранятся индексы строк, может быть полезно при итерации по структурно ненулевым значениям. См. также nonzeros и nzrange.

Пример

julia> A = speye(3)
3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
  [1, 1]  =  1.0
  [2, 2]  =  1.0
  [3, 3]  =  1.0

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

Base.SparseArrays.nzrangeФункция

nzrange(A::SparseMatrixCSC, col::Integer)

Возвращает диапазон индексов структурных ненулевых значений столбца разреженной матрицы. В сочетании с nonzeros и rowvals это позволяет удобно итерироваться по разреженной матрице:

A = sparse(I,J,V)
rows = rowvals(A)
vals = nonzeros(A)
m, n = size(A)
for i = 1:n
   for j in nzrange(A, i)
      row = rows[j]
      val = vals[j]
      # perform sparse wizardry...
   end
end

Base.SparseArrays.dropzeros!Метод

dropzeros!(A::SparseMatrixCSC, trim::Bool = true)

Удаляет сохранённые числовые нули из A, необязательно обрезая избыточное пространство из A.rowval и A.nzval при trim равном true.

Для варианта вне места, см. dropzeros. Для алгоритмической информации см. fkeep!.

Base.SparseArrays.dropzerosМетод

dropzeros(A::SparseMatrixCSC, trim::Bool = true)

Генерирует копию A и удаляет сохранённые числовые нули из этой копии, необязательно обрезая избыточное пространство из массивов rowval и nzval при trim равном true.

Для варианта на месте и алгоритмической информации см. dropzeros!.

Пример

julia> A = sparse([1, 2, 3], [1, 2, 3], [1.0, 0.0, 1.0])
3×3 SparseMatrixCSC{Float64,Int64} with 3 stored entries:
  [1, 1]  =  1.0
  [2, 2]  =  0.0
  [3, 3]  =  1.0

julia> dropzeros(A)
3×3 SparseMatrixCSC{Float64,Int64} with 2 stored entries:
  [1, 1]  =  1.0
  [3, 3]  =  1.0

Base.SparseArrays.dropzeros!Метод

dropzeros!(x::SparseVector, trim::Bool = true)

Удаляет сохранённые числовые нули из x, необязательно обрезая избыточное пространство из x.nzind и x.nzval при trim равном true.

Для варианта вне места, см. dropzeros. Для алгоритмической информации см. fkeep!.

Base.SparseArrays.dropzerosМетод

dropzeros(x::SparseVector, trim::Bool = true)

Генерирует копию x и удаляет числовые нули из этой копии, необязательно обрезая избыточное пространство из массивов nzind и nzval при trim равном true.

Для варианта на месте и алгоритмической информации см. dropzeros!.

Пример

julia> A = sparsevec([1, 2, 3], [1.0, 0.0, 1.0])
3-element SparseVector{Float64,Int64} with 3 stored entries:
  [1]  =  1.0
  [2]  =  0.0
  [3]  =  1.0

julia> dropzeros(A)
3-element SparseVector{Float64,Int64} with 2 stored entries:
  [1]  =  1.0
  [3]  =  1.0

Base.SparseArrays.permuteФункция

permute{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
    q::AbstractVector{<:Integer})

Двусторонне переставляет A, возвращая PAQ (A[p,q]). Длина перестановки столбцов q должна совпадать с количеством столбцов A (length(q) == A.n). Длина перестановки строк p должна совпадать с количеством строк A (length(p) == A.m).

Для экспертных пользователей и дополнительной информации см. permute!.

Пример

julia> A = spdiagm([1, 2, 3, 4], 0, 4, 4) + spdiagm([5, 6, 7], 1, 4, 4)
4×4 SparseMatrixCSC{Int64,Int64} with 7 stored entries:
  [1, 1]  =  1
  [1, 2]  =  5
  [2, 2]  =  2
  [2, 3]  =  6
  [3, 3]  =  3
  [3, 4]  =  7
  [4, 4]  =  4

julia> permute(A, [4, 3, 2, 1], [1, 2, 3, 4])
4×4 SparseMatrixCSC{Int64,Int64} with 7 stored entries:
  [4, 1]  =  1
  [3, 2]  =  2
  [4, 2]  =  5
  [2, 3]  =  3
  [3, 3]  =  6
  [1, 4]  =  4
  [2, 4]  =  7

julia> permute(A, [1, 2, 3, 4], [4, 3, 2, 1])
4×4 SparseMatrixCSC{Int64,Int64} with 7 stored entries:
  [3, 1]  =  7
  [4, 1]  =  4
  [2, 2]  =  6
  [3, 2]  =  3
  [1, 3]  =  5
  [2, 3]  =  2
  [1, 4]  =  1

Base.permute!Метод

permute!{Tv,Ti}(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},
    p::AbstractVector{<:Integer}, q::AbstractVector{<:Integer}[, C::SparseMatrixCSC{Tv,Ti}])

Двусторонне переставляет A, сохраняя результат PAQ (A[p,q]) в X. Сохраняет промежуточный результат (AQ)^T (transpose(A[:,q])) в необязательном аргументе C, если он присутствует. Требует, чтобы ни один из X, A, и, если он присутствует, C не являлись ссылками друг на друга; для сохранения результата PAQ обратно в A, используйте следующий метод без X:

permute!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{<:Integer},
    q::AbstractVector{<:Integer}[, C::SparseMatrixCSC{Tv,Ti}[, workcolptr::Vector{Ti}]])

Размеры X должны совпадать с размерами A (X.m == A.m и X.n == A.n), и X должно иметь достаточно памяти для размещения всех выделенных элементов в A (length(X.rowval) >= nnz(A) и length(X.nzval) >= nnz(A)). Длина перестановки столбцов q должна совпадать с количеством столбцов A (length(q) == A.n). Длина перестановки строк p должна совпадать с количеством строк A (length(p) == A.m).

Размеры C должны совпадать с размерами transpose(A) (C.m == A.n и C.n == A.m), и C должно иметь достаточно памяти для размещения всех выделенных элементов в A (length(C.rowval) >= nnz(A) и length(C.nzval) >= nnz(A)).

Для дополнительной (алгоритмической) информации и для версий этих методов, которые отказываются от проверки аргументов, см. (неэкспортированные) родительские методы unchecked_noalias_permute! и unchecked_aliasing_permute!.

См. также: permute.