Массивы

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

ndims(A::AbstractArray) → Integer

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

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

julia> ndims(A)
3

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

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

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

julia> size(A, 2)
3

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

indices(A)

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

indices(A, d)

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

length(A::AbstractArray) → Integer

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

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

julia> length(A)
60

eachindex(A...)

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

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

julia> A = sparse([1, 1, 2], [1, 3, 1], [1, 2, -5])
2×3 sparse matrix with 3 Int64 nonzero 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 если все входные данные поддерживают быструю линейную индексацию, в противном случае — декартов диапазон). Если массивы имеют разные размеры и/или размерности, eachindex возвращает итерируемый объект, охватывающий наибольший диапазон по каждой размерности.

linearindices(A)

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

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

Base.linearindexing(A)

linearindexing определяет, как абстрактный массив наиболее эффективно обращается к своим элементам. Если Base.linearindexing(A) возвращает Base.LinearFast(), это означает, что линейная индексация с одним индексом — эффективная операция. Если вместо этого возвращается Base.LinearSlow() (по умолчанию), это означает, что массив изначально обращается к своим элементам с индексами, указанными для каждой размерности. Поскольку преобразование линейного индекса в несколько индексов подстроки обычно очень дорого, это предоставляет механизм на основе свойств для включения эффективного обобщённого кода для всех типов массивов.

Подтип абстрактного массива MyArray , который хочет воспользоваться преимуществами быстрой линейной индексации, должен определить linearindexing в области типов:

Base.linearindexing{T<:MyArray}(::Type{T}) = Base.LinearFast()

countnz(A)

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

conj!(A)

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

stride(A, k::Integer)

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

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

julia> stride(A,2)
3

julia> stride(A,3)
12

strides(A)

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

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

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

ind2sub(dims, index) → subscripts

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

Пример:

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

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

ind2sub(a, index) → subscripts

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

sub2ind(dims, i, j, k...) → index

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

LinAlg.checksquare(A)

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

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

Array(dims)

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

getindex(type[, elements...])

Создаёт одномерный массив указанного типа. Обычно вызывается с синтаксисом Type[]. Значения элементов можно указать с помощью Type[a,b,c,...].

zeros(type, dims)

Создаёт массив из нулей указанного типа. Тип по умолчанию — Float64, если не указан.

zeros(A)

Создаёт массив из нулей с тем же типом элементов и формой, что и A.

ones(type, dims)

Создаёт массив из единиц указанного типа. Тип по умолчанию — Float64 , если не указан.

ones(A)

Создаёт массив из единиц с тем же типом элементов и формой, что и A.

trues(dims)

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

trues(A)

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

falses(dims)

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

falses(A)

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

fill(x, dims)

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

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

fill!(A, x)

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

reshape(A, dims)

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

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 с двумя элементами, так как 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, 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.

reinterpret(type, A)

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

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

n-строчная/n единичная матрица. По умолчанию используется тип элементов Float64.

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

m-строчная/n единичная матрица. По умолчанию используется тип элементов Float64.

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

linspace(start, stop, n=50)

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

logspace(start, stop, n=50)

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

Математические операторы и функции

Все математические операции и функции поддерживаются для массивов

broadcast(f, As...)

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

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

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

bitbroadcast(f, As...)

Как broadcast, но выделяет BitArray для хранения результата, а не Array.

Индексирование, присваивание и конкатенация

getindex(A, inds...)

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

view(A, inds...)

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

@view A[inds...]

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

parent(A)

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

parentindexes(A)

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

slicedim(A, d, i)

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

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

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

broadcast_getindex(A, inds...)

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

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

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

isassigned(array, i) → Bool

Проверяет, имеет ли данный массив значение, связанное с индексом i. Возвращает false если индекс выходит за пределы, или ссылка не определена.

cat(dims, A...)

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

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

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

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 столбцов блока.

flipdim(A, d)

Переворачивает 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

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

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

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

findn(A)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

permutedims(A, perm)

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

ipermutedims(A, perm)

Подобно permutedims(), за исключением того, что применяется обратная перестановка.

permutedims!(dest, src, perm)

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

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

vec(a::AbstractArray) → Vector

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

promote_shape(s1, s2)

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

checkbounds(A, I...)

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

checkbounds(Bool, A, I...)

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

См. также checkindex.

checkindex(Bool, inds::AbstractUnitRange, index)

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

randsubseq(A, p) → Vector

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

randsubseq!(S, A, p)

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

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

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

cumprod!(B, A[, dim])

Кумулятивное произведение A по размерности, сохраняющее результат в B. Размерность по умолчанию 1.

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

cumsum!(B, A[, dim])

Кумулятивная сумма A по размерности, сохраняющее результат в B . Размерность по умолчанию 1.

cumsum_kbn(A[, dim])

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

cummin(A[, dim])

Кумулятивный минимум по размерности. Размерность по умолчанию 1.

cummax(A[, dim])

Кумулятивный максимум по размерности. Размерность по умолчанию 1.

diff(A[, dim])

Оператор конечной разности матрицы или вектора.

gradient(F[, h])

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

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

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

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

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

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

mapslices(f, A, dims)

Преобразуйте заданные размеры массива A с помощью функции f. f вызывается для каждого слайса A вида A[...,:,...,:,...]. dims — целочисленный вектор, определяющий, где в этом выражении стоят двоеточия. Результаты конкатенируются по оставшимся измерениям. Например, если dims — [1,2] и A — четырёхмерный, 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

sum_kbn(A)

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

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

randperm([rng, ]n)

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

invperm(v)

Возвращает обратную перестановку v

isperm(v) → Bool

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

permute!(v, p)

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

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

ipermute!(v, p)

Аналогично permute!, но применяется обратная перестановка.

randcycle([rng, ]n)

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

shuffle([rng, ]v)

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

shuffle!([rng, ]v)

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

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

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

reverseind(v, i)

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

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

Функция на месте, аналогичная reverse().

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

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

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

rol!(dest::BitVector, src::BitVector, i::Integer) → BitVector

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

rol!(B::BitVector, i::Integer) → BitVector

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

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

ror!(dest::BitVector, src::BitVector, i::Integer) → BitVector

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

ror!(B::BitVector, i::Integer) → BitVector

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

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

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

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

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

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

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

sparsevec(D::Dict[, m])

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

issparse(S)

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

sparse(A)

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

sparsevec(A)

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

full(S)

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

nnz(A)

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

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

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

spones(S)

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

julia> A = sparse([1,2,3,4],[2,4,3,1],[5.,4.,3.,2.])
4×4 sparse matrix with 4 Float64 nonzero entries:
        [4, 1]  =  2.0
        [1, 2]  =  5.0
        [3, 3]  =  3.0
        [2, 4]  =  4.0

julia> spones(A)
4×4 sparse matrix with 4 Float64 nonzero entries:
        [4, 1]  =  1.0
        [1, 2]  =  1.0
        [3, 3]  =  1.0
        [2, 4]  =  1.0

Обратите внимание на различие от speye().

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

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

speye(S)

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

julia> A = sparse([1,2,3,4],[2,4,3,1],[5.,4.,3.,2.])
4×4 sparse matrix with 4 Float64 nonzero entries:
        [4, 1]  =  2.0
        [1, 2]  =  5.0
        [3, 3]  =  3.0
        [2, 4]  =  4.0

julia> speye(A)
4×4 sparse matrix with 4 Float64 nonzero entries:
        [1, 1]  =  1.0
        [2, 2]  =  1.0
        [3, 3]  =  1.0
        [4, 4]  =  1.0

Обратите внимание на различие от spones().

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 sparse matrix with 8 Int64 nonzero 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

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

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

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

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

nonzeros(A)

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

rowvals(A::SparseMatrixCSC)

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

nzrange(A::SparseMatrixCSC, col)

Возвращает диапазон индексов ненулевых значений столбца разреженной матрицы. В сочетании с 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

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

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

Для внеполосной версии см. dropzeros(). Для алгоритмической информации см. Base.SparseArrays.fkeep!().

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

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

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

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

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

Для внеполосной версии см. Base.SparseArrays.dropzeros(). Для алгоритмической информации см. Base.SparseArrays.fkeep!().

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

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

Для ин-плой версии и алгоритмической информации см. Base.SparseArrays.dropzeros!().

permute{Tv,Ti,Tp<:Integer,Tq<:Integer}(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{Tp},

q::AbstractVector{Tq})()

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

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

permute!{Tv,Ti,Tp<:Integer,Tq<:Integer}(X::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti},

p::AbstractVector{Tp}, q::AbstractVector{Tq}[, 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,Tp<:Integer,Tq<:Integer}(A::SparseMatrixCSC{Tv,Ti}, p::AbstractVector{Tp},
    q::AbstractVector{Tq}[, 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)``and``length(C.nzval) >= nnz(A)`).

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

См. также: Base.SparseArrays.permute()