Julia Language
Массивы

Синтаксис

• [1,2,3]
• [1 2 3]
• [1 2 3; 4 5 6; 7 8 9]
• Массив (тип, dims ...)
• (тип, тускнеет ...)
• нули (тип, тускне ...)
• истины (тип, тускнеет ...)
• falses (type, dims ...)
• push! (A, x)
• поп! (А)
• unshift! (A, x)
• сдвиг! (А)

параметры

Ручная конструкция простого массива

Можно инициализировать массив Julia вручную, используя синтаксис квадратных скобок:

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

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

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

Чтобы создать неинициализированный массив, вы можете использовать метод Array(type, dims...) :

julia> Array(Int64, 3, 3)
3x3 Array{Int64,2}:
 0  0  0
 0  0  0
 0  0  0

Функции zeros , ones , trues , falses имеют методы, которые ведут себя точно так же, но создают массивы, полные 0.0 , 1.0 , True или False соответственно.

Типы массивов

В Julia массивы имеют типы, параметризованные двумя переменными: тип T и размерность D ( Array{T, D} ). Для одномерного массива целых чисел тип:

julia> x = [1, 2, 3];
julia> typeof(x)
Array{Int64, 1}

Если массив является двумерной матрицей, D равно 2:

julia> x = [1 2 3; 4 5 6; 7 8 9]
julia> typeof(x)
Array{Int64, 2}

Тип элемента также может быть абстрактным:

julia> x = [1 2 3; 4 5 "6"; 7 8 9]
3x3 Array{Any,2}:
 1  2  3   
 4  5 "6"
 7  8  9

Здесь Any (абстрактный тип) является типом результирующего массива.

Указание типов при создании массивов

Когда мы создаем Array так, как описано выше, Julia сделает все возможное, чтобы вывести нужный тип, который нам может понадобиться. В начальных примерах выше мы вводили входы, которые выглядели как целые числа, и поэтому Джулия по умолчанию Int64 тип Int64 по умолчанию. Время от времени, однако, мы могли бы быть более конкретными. В следующем примере мы указываем, что мы хотим, чтобы тип был вместо Int8 :

x1 = Int8[1 2 3; 4 5 6; 7 8 9]
typeof(x1)  ## Array{Int8,2}

Мы могли бы даже указать тип как-то наподобие Float64 , даже если мы записываем входы таким образом, который по умолчанию мог бы интерпретироваться как целые числа (например, писать 1 вместо 1.0 ). например

x2 = Float64[1 2 3; 4 5 6; 7 8 9]

Массивы массивов - свойства и конструкция

В Julia вы можете иметь массив, содержащий другие объекты типа Array. Рассмотрим следующие примеры инициализации различных типов массивов:

A = Array{Float64}(10,10)  # A single Array, dimensions 10 by 10, of Float64 type objects

B = Array{Array}(10,10,10)  # A 10 by 10 by 10 Array.  Each element is an Array of unspecified type and dimension.

C = Array{Array{Float64}}(10)  ## A length 10, one-dimensional Array.  Each element is an Array of Float64 type objects but unspecified dimensions

D = Array{Array{Float64, 2}}(10)  ## A length 10, one-dimensional Array.  Each element of is an 2 dimensional array of Float 64 objects

Рассмотрим, например, различия между C и D здесь:

julia> C[1] = rand(3)
3-element Array{Float64,1}:
 0.604771
 0.985604
 0.166444

julia> D[1] = rand(3)
ERROR: MethodError: 

rand(3) создает объект типа Array{Float64,1} . Поскольку единственная спецификация для элементов C состоит в том, что они являются массивами с элементами типа Float64, это соответствует определению C Но для D мы указали, что элементы должны быть 2 мерными массивами. Таким образом, поскольку rand(3) не создает двумерный массив, мы не можем использовать его для назначения значения определенному элементу D

Укажите конкретные размеры массивов в массиве

Хотя мы можем указать, что Array будет содержать элементы, которые имеют тип Array, и мы можем указать, что, например, эти элементы должны быть двумерными массивами, мы не можем напрямую указывать размеры этих элементов. Например, мы не можем напрямую указать, что мы хотим, чтобы Array держал 10 массивов, каждый из которых составлял 5,5. Мы можем видеть это из синтаксиса для функции Array() используемой для построения массива:

Массив {T} (тускнеет)

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

Тип массива в Джулии охватывает количество измерений, но не размер этих размеров. Таким образом, в этом синтаксисе нет места для указания точных измерений. Тем не менее аналогичный эффект может быть достигнут с использованием понимания Array:

E = [Array{Float64}(5,5) for idx in 1:10]

Примечание: эта документация отражает следующий SO-ответ

Инициализировать пустой массив

Мы можем использовать [] для создания пустого массива в Джулии. Самый простой пример:

A = [] # 0-element Array{Any,1}

Массивы типа Any , как правило, не выполняются так же, как те, которые имеют заданный тип. Так, например, мы можем использовать:

B = Float64[]  ## 0-element Array{Float64,1}
C = Array{Float64}[]  ## 0-element Array{Array{Float64,N},1}
D = Tuple{Int, Int}[] ## 0-element Array{Tuple{Int64,Int64},1}

См. Инициализация пустого массива кортежей в Джулии для источника последнего примера.

векторы

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

Во-первых, заметим, что Vector{T} где T - некоторый тип, означает то же самое, что и Array{T,1} .

julia> Vector{Int}
Array{Int64,1}

julia> Vector{Float64}
Array{Float64,1}

Один читает Array{Int64,1} как «одномерный массив Int64 ».

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

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

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

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

julia> pop!(A)
4

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

julia> unshift!(A, 0)
4-element Array{Int64,1}:
 0
 1
 2
 3

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

julia> shift!(A)
0

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

Как принято, каждая из этих функций push! , pop! , unshift! , и shift! заканчивается восклицательным знаком, чтобы указать, что они мутируют их аргументы. Функции push! и не unshift! верните массив, тогда как pop! и shift! вернуть элемент.

конкатенация

Часто бывает полезно создавать матрицы из меньших матриц.

Горизонтальная конкатенация

Матрицы (и векторы, которые рассматриваются как векторы столбцов) могут быть объединены по горизонтали с использованием функции hcat .

julia> hcat([1 2; 3 4], [5 6 7; 8 9 10], [11, 12])
2×6 Array{Int64,2}:
 1  2  5  6   7  11
 3  4  8  9  10  12

Существует удобный синтаксис, использующий квадратные обозначения и пробелы:

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

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

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

julia> B = [5 6; 7 8]
2×2 Array{Int64,2}:
 5  6
 7  8

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

Обратите внимание, что вы не можете горизонтально конкатенировать одну матрицу с использованием синтаксиса [] , поскольку вместо этого будет создан одноэлементный вектор матриц:

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

Вертикальная конкатенация

Вертикальная конкатенация похожа на горизонтальную конкатенацию, но в вертикальном направлении. Функция вертикальной конкатенации - vcat .

julia> vcat([1 2; 3 4], [5 6; 7 8; 9 10], [11 12])
6×2 Array{Int64,2}:
  1   2
  3   4
  5   6
  7   8
  9  10
 11  12

Альтернативно, квадратные скобки могут использоваться с точкой с запятой ; как разделитель:

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

Векторы также могут быть объединены по вертикали; результатом является вектор:

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

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

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

Горизонтальная и вертикальная конкатенация могут комбинироваться:

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

julia> B = [5 6 7]
1×3 Array{Int64,2}:
 5  6  7

julia> C = [8, 9]
2-element Array{Int64,1}:
 8
 9

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