Julia Language
배열

통사론

• [1,2,3]
• [1 2 3]
• [1 2 3; 4 5 6; 7 8 9]
• 배열 (유형, 희미한 ...)
• 사람 (유형, 희미한 ...)
• 0 (유형, 희미한 ...)
• trues (유형, 희미한 ...)
• 거짓 (유형, 희미한 ...)
• 푸시! (A, x)
• 팝! (A)
• unshift! (A, x)
• 교대! (A)

매개 변수

간단한 배열의 수동 생성

다음과 같이 대괄호 문법을 사용하여 줄리아 배열을 손으로 초기화 할 수 있습니다.

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

명령 뒤의 첫 번째 행은 작성한 배열의 크기를 표시합니다. 또한 요소의 유형과 차원 (이 경우 Int64 및 1 , 각각)을 보여줍니다. 2 차원 배열의 경우 공백과 세미콜론을 사용할 수 있습니다.

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} ). 1 차원의 정수 배열의 경우 유형은 다음과 같습니다.

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

배열이 2 차원 행렬 인 경우 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 유형을 기본값으로 사용했습니다. 그러나 때로는 더 구체적으로하고 싶을 수도 있습니다. 다음 예제에서는 Int8 대신 유형을 지정합니다.

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

비록 우리가 기본적으로 정수로 해석 될 수있는 방법으로 입력을 쓰더라도 (예를 들어, 1.0 대신에 1 을 쓰는 것과 같이), 입력을 Float64 와 같은 것으로 지정할 수도 있습니다. 예

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

배열의 배열 - 속성 및 구조

Julia에서는 다른 Array 유형의 객체를 포함하는 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) 은 2 차원 배열을 생성하지 않기 때문에, 그것을 사용하여 D 의 특정 원소에 값을 할당 할 수 없다.

배열 내의 특정 배열 치수 지정

Array가 Array 유형의 요소를 보유하도록 지정할 수 있지만이를 지정할 수 있습니다. 예를 들어 이러한 요소는 2 차원 배열이어야하며 해당 요소의 차원을 직접 지정할 수는 없습니다. 예를 들어, 우리는 10 개의 배열을 가진 배열을 원한다고 직접적으로 지정할 수는 없으며 각각의 배열은 5,5입니다. Array() 를 생성하는 데 사용되는 Array() 함수의 구문을 보면 알 수 있습니다.

배열 {T} (희미한)

요소 유형이 T 인 초기화되지 않은 고밀도 배열을 생성합니다. dims는 튜플 또는 일련의 정수 인수가 될 수 있습니다. 구문 Array (T, dims)도 사용할 수 있지만 더 이상 사용되지 않습니다.

줄리아의 배열 유형은 차원의 수를 포함 하나 해당 차원의 크기는 포함하지 않습니다. 따라서이 구문에는 정확한 차원을 지정하는 위치가 없습니다. 그럼에도 불구하고 Array Comprehension을 사용하면 비슷한 효과를 얻을 수 있습니다.

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

참고 :이 설명서는 다음 SO 답변을 반영합니다.

빈 배열 초기화

Julia에서 [] 를 사용하여 빈 Array를 만들 수 있습니다. 가장 간단한 예는 다음과 같습니다.

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}

마지막 예제 소스를 위해 Julia에서 빈 배열 튜플 초기화를 참조하십시오.

벡터

벡터는 1 차원 배열이며, 다차원의 대응 물과 거의 동일한 인터페이스를 지원합니다. 그러나 벡터는 추가 작업도 지원합니다.

첫째, Vector{T} 는 T 가 어떤 타입 인 경우 Array{T,1} 과 같은 것을 의미합니다.

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

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

하나는 Array{Int64,1} 을 " Int64 1 차원 배열"로 읽습니다.

다차원 배열과 달리 벡터는 크기를 조정할 수 있습니다. 벡터의 앞이나 뒤에 요소를 추가하거나 제거 할 수 있습니다. 이러한 작업은 모두 일정한 상각 시간 입니다.

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! 반면 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