학습 줄리아(4): 배열

수치 및 과학 컴퓨팅을 위한 훌륭한 도구인 Julia는 매우 현대적인 디자인과 배열에 대한 풍부한 방법을 가지고 있습니다.

무엇보다 모듈에서 내보낸 이름을 표시하는 방법names()을 언급해야 합니다. 그것은 나에게 매우 유용합니다. 다음은 Core 모듈에서 내보낸 이름을 가져오는 예입니다. (Python에서 여전히 dir() 메서드가 그리워요).

#  Get an array of the names exported by Module Core
ns = names(Core)  
println(ns)

위에 표시된 출력에서 ​​볼 수 있듯이 이 Core 모듈에는 AbstractArray 유형이 있습니다. 공식 문서에서 인용합니다. 배열 및 기타 유형은 이것의 하위 유형입니다.AbstractArray{T,N} == T .Base.AbstractVector: AbstractVector{T} == AbstractArray{T,1} .
Base.AbstractMatrix: AbstractMatrix{T}는 T 유형의 요소가 있는 N차원 고밀도 배열을 정의하는 유형 AbstractArray{T,2}에서 파생됩니다.
Array{T,N} : AbstractArray{T,N} 에 대한 별칭으로, 배열 생성자 호출자가 초기화되지 않은 배열을 원함을 나타내기 위해 배열 초기화에 사용되는 싱글톤 유형 UndefInitializer의 인스턴스를 구성합니다.


내 테스트는 다음과 같습니다.

# same as in Python
a = [1, 2, 4, 8]   ## Type shall be Array{Int64,1}
println("a: ", a, ", size:", size(a))    # get size
println("a: ", a, ", length:", length(a))  # get length 
### ATTENTION: first element's index is 1, not 0
println("a[1]: ", a[1])           # a[1]  => 1
println("a[3]: ", a[3])           # a[3]  => 4
println("a[end]: ", a[end])       # a[end] => 6


a1 = Array{Int64,1}(undef, 4)
a2 = Array{Int64}(undef, 4)

println(" a and a1 are of same type:", typeof(a) == typeof(a1))
println(" a and a2 are of same type:", typeof(a) == typeof(a2))

# Empty array with datatype
b = Int64[] # similar to C#
println("b:", b, ", size: ", size(b))  

# Array with two elements
c = Int16[12, 34]  # attention, here 12 and 34 inside the brackets are not dimensions, they are elements of the array
println("c:", c, ", size: ", size(c))  



# 2-dimension matrix 
matrix22 = [11 22; 33 44] # => 2x2 matrix of type Int64: [1 2; 3 4]
println("matrix22: ", matrix22, ", size: ", size(matrix22)) 
println("matrix22: ", matrix22, ", length:", length(matrix22))  # get length 

matrix = Array{Int64,2}(undef, 2, 2)

println(" matrix22 and matrix are of same type:", typeof(matrix22) == typeof(matrix))

# Use push! and append! to add elements to an array
# Use pop! to remove the last element of an array
##  method ending with ! means that this method modifies the input argument
e = [1,3,5,7]
push!(e,9)     # => [1,3,5,7,9]
println("e:", e, ", size: ", size(e))  
push!(e,11)     # => [1,3,5,7,9,11]
println("e:", e, ", size: ", size(e))  
pop!(e)     # => [1,3,5,7,9] with 11 been removed
println("e:", e, ", size: ", size(e))  
## append can concatenate an array to another
append!(e,[15,17,19]) # => [1,3,5,7,9,15,17,19]
println("e:", e, ", size: ", size(e))  


println("               ")


#  pushfirst! and popfirst!

f = [1,2,3,4,5,6]
popfirst!(f) # => pops the first element 1， a changed to [2,3,4,5,6]
println("f:", f, ", size: ", size(f))  
pushfirst!(f,5) # => push 5 in the first place of the array: [5,2,3,4,5,6]
println("f:", f, ", size: ", size(f))  

## sort and sort!
prices = [7,4,6,9,3]
s1 = sort(prices) # s1 is a new array sorted in incremental order; prices is still [7,4,6,9,3]
println("s1:", s1, ", prices: ", prices) 
s2 = sort!(prices) # s2 and prices are both sorted in incremental order
println("s2:", s2, ", prices: ", prices)


println("               ")


# using ranging to initialize an array
g = collect(1:5) # => 5-element Int64 Array: [1,2,3,4,5]

# partial reading of an array 
g1 = g[1:3] # => [1, 2, 3]
g2 = g[2:end] # => [2, 3, 4, 5]
println("g1:", g1, ", g2: ", g2) 

# splice! 
h = [3,4,5]
h1 = splice!(h,2) # => 4 ; arr updated to [3,5]
println("h1:", h1, ", h: ", h) 

# check if 3 exists in array h
i = in(3, h) # => true
println("3 is in array h:", i) 

# Exception BoundsError 
try
    h[0] # => ERROR: BoundsError() in getindex at array.jl:270
    h[end+1] # => ERROR: BoundsError() in getindex at array.jl:270
catch e
    println(e)
end

이 테스트의 출력: