GitHub

Arrays

Constructors and Types

Core.Array — Type
Array{T,N} <: AbstractArray{T,N}

N차원 밀집 배열로, 요소의 타입은 T입니다.

source
Core.Array — Method
Array{T}(undef, dims)
Array{T,N}(undef, dims)

초기화되지 않은 N-차원 Array를 생성하여 타입 T의 요소를 포함합니다. N은 Array{T,N}(undef, dims)와 같이 명시적으로 제공되거나 dims의 길이나 개수에 의해 결정될 수 있습니다. dims는 각 차원의 길이에 해당하는 정수 인수의 튜플 또는 시리즈일 수 있습니다. 랭크 N이 명시적으로 제공되면, dims의 길이나 개수와 일치해야 합니다. 여기서 undef는 UndefInitializer입니다.

예제

julia> A = Array{Float64, 2}(undef, 2, 3) # N이 명시적으로 주어짐
2×3 Matrix{Float64}:
 6.90198e-310  6.90198e-310  6.90198e-310
 6.90198e-310  6.90198e-310  0.0

julia> B = Array{Float64}(undef, 4) # N이 입력에 의해 결정됨
4-element Vector{Float64}:
   2.360075077e-314
 NaN
   2.2671131793e-314
   2.299821756e-314

julia> similar(B, 2, 4, 1) # typeof(B)와 주어진 크기를 사용
2×4×1 Array{Float64, 3}:
[:, :, 1] =
 2.26703e-314  2.26708e-314  0.0           2.80997e-314
 0.0           2.26703e-314  2.26708e-314  0.0
source
Core.Array — Method
Array{T}(nothing, dims)
Array{T,N}(nothing, dims)

T 유형의 요소를 포함하는 N-차원 Array를 생성하며, nothing 항목으로 초기화됩니다. 요소 유형 T는 이러한 값을 수용할 수 있어야 하며, 즉 Nothing <: T 여야 합니다.

예제

julia> Array{Union{Nothing, String}}(nothing, 2)
2-element Vector{Union{Nothing, String}}:
 nothing
 nothing

julia> Array{Union{Nothing, Int}}(nothing, 2, 3)
2×3 Matrix{Union{Nothing, Int64}}:
 nothing  nothing  nothing
 nothing  nothing  nothing
source
Core.Array — Method
Array{T}(missing, dims)
Array{T,N}(missing, dims)

T 유형의 요소를 포함하는 N-차원 Array를 생성하며, missing 항목으로 초기화됩니다. 요소 유형 T는 이러한 값을 수용할 수 있어야 하며, 즉 Missing <: T 여야 합니다.

예제

julia> Array{Union{Missing, String}}(missing, 2)
2-element Vector{Union{Missing, String}}:
 missing
 missing

julia> Array{Union{Missing, Int}}(missing, 2, 3)
2×3 Matrix{Union{Missing, Int64}}:
 missing  missing  missing
 missing  missing  missing
source
Core.UndefInitializer — Type
UndefInitializer

배열 초기화에 사용되는 싱글톤 타입으로, 배열 생성자가 초기화되지 않은 배열을 원한다는 것을 나타냅니다. 또한 undef를 참조하십시오. 이는 UndefInitializer()의 별칭입니다.

예제

julia> Array{Float64, 1}(UndefInitializer(), 3)
3-element Array{Float64, 1}:
 2.2752528595e-314
 2.202942107e-314
 2.275252907e-314
source
Core.undef — Constant
undef

UndefInitializer()의 별칭으로, 배열 초기화에서 배열 생성 호출자가 초기화되지 않은 배열을 원한다는 것을 나타내기 위해 사용되는 단일 인스턴스 유형 UndefInitializer를 구성합니다.

참고: missing, similar.

예제

julia> Array{Float64, 1}(undef, 3)
3-element Vector{Float64}:
 2.2752528595e-314
 2.202942107e-314
 2.275252907e-314
source
Base.Vector — Type
Vector{T} <: AbstractVector{T}

타입 T의 요소를 가진 1차원 밀집 배열로, 종종 수학적 벡터를 나타내는 데 사용됩니다. Array{T,1}의 별칭입니다.

벡터 생성을 위한 empty, similar 및 zero도 참조하세요.

source
Base.Vector — Method
Vector{T}(undef, n)

길이 n의 초기화되지 않은 Vector{T}를 생성합니다.

예제

julia> Vector{Float64}(undef, 3)
3-element Array{Float64, 1}:
 6.90966e-310
 6.90966e-310
 6.90966e-310
source
Base.Vector — Method
Vector{T}(nothing, m)

길이가 m인 Vector{T}를 생성하며, nothing 항목으로 초기화됩니다. 요소 유형 T는 이러한 값을 저장할 수 있어야 하며, 즉 Nothing <: T여야 합니다.

예제

julia> Vector{Union{Nothing, String}}(nothing, 2)
2-element Vector{Union{Nothing, String}}:
 nothing
 nothing
source
Base.Vector — Method
Vector{T}(missing, m)

길이가 m인 Vector{T}를 생성하며, missing 항목으로 초기화됩니다. 요소 유형 T는 이러한 값을 수용할 수 있어야 하며, 즉 Missing <: T여야 합니다.

예제

julia> Vector{Union{Missing, String}}(missing, 2)
2-element Vector{Union{Missing, String}}:
 missing
 missing
source
Base.Matrix — Type
Matrix{T} <: AbstractMatrix{T}

타입 T의 요소를 가진 2차원 밀집 배열로, 종종 수학적 행렬을 나타내는 데 사용됩니다. Array{T,2}의 별칭입니다.

행렬을 생성하기 위한 fill, zeros, undef 및 similar도 참조하십시오.

source
Base.Matrix — Method
Matrix{T}(undef, m, n)

초기화되지 않은 Matrix{T} 크기 m×n의 행렬을 생성합니다.

예제

julia> Matrix{Float64}(undef, 2, 3)
2×3 Array{Float64, 2}:
 2.36365e-314  2.28473e-314    5.0e-324
 2.26704e-314  2.26711e-314  NaN

julia> similar(ans, Int32, 2, 2)
2×2 Matrix{Int32}:
 490537216  1277177453
         1  1936748399
source
Base.Matrix — Method
Matrix{T}(nothing, m, n)

m×n 크기의 Matrix{T}를 생성하며, nothing 항목으로 초기화됩니다. 요소 유형 T는 이러한 값을 저장할 수 있어야 하며, 즉 Nothing <: T 여야 합니다.

예제

julia> Matrix{Union{Nothing, String}}(nothing, 2, 3)
2×3 Matrix{Union{Nothing, String}}:
 nothing  nothing  nothing
 nothing  nothing  nothing
source
Base.Matrix — Method
Matrix{T}(missing, m, n)

Matrix{T}의 크기 m×n을 생성하며, missing 항목으로 초기화됩니다. 요소 유형 T는 이러한 값을 저장할 수 있어야 하며, 즉 Missing <: T이어야 합니다.

예제

julia> Matrix{Union{Missing, String}}(missing, 2, 3)
2×3 Matrix{Union{Missing, String}}:
 missing  missing  missing
 missing  missing  missing
source
Base.VecOrMat — Type
VecOrMat{T}

Vector{T}와 Matrix{T}의 유니온 타입으로, 함수가 행렬 또는 벡터를 모두 수용할 수 있도록 합니다.

예제

julia> Vector{Float64} <: VecOrMat{Float64}
true

julia> Matrix{Float64} <: VecOrMat{Float64}
true

julia> Array{Float64, 3} <: VecOrMat{Float64}
false
source
Core.DenseArray — Type
DenseArray{T, N} <: AbstractArray{T,N}

N-차원 밀집 배열로, 요소의 타입은 T입니다. 밀집 배열의 요소는 메모리에 연속적으로 저장됩니다.

source
Base.StridedArray — Type
StridedArray{T, N}

일반적인 배열 유형의 하드코딩된 Union으로, 스트라이드 배열 인터페이스를 따르며, 요소는 타입 T와 N 차원을 가집니다.

A가 StridedArray인 경우, 그 요소는 메모리에 오프셋으로 저장되며, 이는 차원 간에 다를 수 있지만 차원 내에서는 일정합니다. 예를 들어, A는 차원 1에서 스트라이드 2를 가질 수 있고, 차원 2에서 스트라이드 3을 가질 수 있습니다. 차원 d를 따라 A를 증가시키면 메모리에서 [stride(A, d)] 슬롯만큼 점프합니다. 스트라이드 배열은 때때로 BLAS와 같은 외부 언어 라이브러리에 포인터로 직접 전달될 수 있기 때문에 특히 중요하고 유용합니다.

source
Core.GenericMemory — Type
GenericMemory{kind::Symbol, T, addrspace=Core.CPU} <: DenseVector{T}

고정 크기 DenseVector{T}.

kind는 현재 :not_atomic 또는 :atomic일 수 있습니다. :atomic이 의미하는 바에 대한 자세한 내용은 AtomicMemory를 참조하십시오.

addrspace는 현재 Core.CPU로만 설정할 수 있습니다. 이는 GPU와 같은 다른 시스템에 의해 확장이 가능하도록 설계되었으며, 이러한 시스템은 다음과 같은 값을 정의할 수 있습니다:

module CUDA
const Generic = bitcast(Core.AddrSpace{CUDA}, 0)
const Global = bitcast(Core.AddrSpace{CUDA}, 1)
end

이러한 다른 addrspace의 정확한 의미는 특정 백엔드에 의해 정의되지만, 사용자가 CPU에서 이를 접근하려고 할 경우 오류가 발생합니다.

Julia 1.11

이 유형은 Julia 1.11 이상이 필요합니다.

source
Core.Memory — Type
Memory{T} == GenericMemory{:not_atomic, T, Core.CPU}

고정 크기 DenseVector{T}.

Julia 1.11

이 타입은 Julia 1.11 이상이 필요합니다.

source
Core.memoryref — Function
`memoryref(::GenericMemory)`

메모리 객체로부터 GenericMemoryRef를 생성합니다. 이는 실패하지 않지만, 결과 메모리는 메모리가 비어 있는 경우에만 범위를 벗어난 위치를 가리킵니다.

source
memoryref(::GenericMemory, index::Integer)
memoryref(::GenericMemoryRef, index::Integer)

메모리 객체와 오프셋 인덱스(1부터 시작)로 GenericMemoryRef를 생성합니다. 이 인덱스는 음수일 수도 있습니다. 이는 항상 유효한 객체를 반환하며, 불가능할 경우 오류를 발생시킵니다(인덱스가 기본 메모리의 경계를 넘어서는 이동을 초래할 경우).

source
Base.Slices — Type
Slices{P,SM,AX,S,N} <: AbstractSlices{S,N}

지정된 차원에서 부모 배열로의 슬라이스를 나타내는 AbstractArray로, 다른 차원에서 모든 데이터를 선택하는 뷰를 반환합니다.

이들은 일반적으로 eachslice, eachcol 또는 eachrow로 구성되어야 합니다.

parent(s::Slices)는 부모 배열을 반환합니다.

source
Base.RowSlices — Type
RowSlices{M,AX,S}

행렬의 행 슬라이스 벡터인 Slices의 특별한 경우로, eachrow에 의해 구성됩니다.

parent를 사용하여 기본 행렬을 가져올 수 있습니다.

source
Base.ColumnSlices — Type
ColumnSlices{M,AX,S}

행렬의 열 슬라이스 벡터인 Slices의 특별한 경우로, eachcol에 의해 구성됩니다.

parent를 사용하여 기본 행렬을 가져올 수 있습니다.

source
Base.getindex — Method
getindex(type[, elements...])

지정된 유형의 1차원 배열을 생성합니다. 이는 일반적으로 Type[] 구문으로 호출됩니다. 요소 값은 Type[a,b,c,...]를 사용하여 지정할 수 있습니다.

예제

julia> Int8[1, 2, 3]
3-element Vector{Int8}:
 1
 2
 3

julia> getindex(Int8, 1, 2, 3)
3-element Vector{Int8}:
 1
 2
 3
source
Base.zeros — Function
zeros([T=Float64,] dims::Tuple)
zeros([T=Float64,] dims...)

T 타입의 요소를 가지며, dims로 지정된 크기의 모든 요소가 0인 Array를 생성합니다. fill, ones, zero도 참조하세요.

예제

julia> zeros(1)
1-element Vector{Float64}:
 0.0

julia> zeros(Int8, 2, 3)
2×3 Matrix{Int8}:
 0  0  0
 0  0  0
source
Base.ones — Function
모든 요소가 1인 `Array`를 생성하며, 요소 유형 `T`와 크기는 `dims`로 지정됩니다. [`fill`](@ref), [`zeros`](@ref)도 참조하십시오.

# 예제

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

julia> ones(ComplexF64, 2, 3) 2×3 Matrix{ComplexF64}: 1.0+0.0im 1.0+0.0im 1.0+0.0im 1.0+0.0im 1.0+0.0im 1.0+0.0im

source
Base.BitArray — Type
BitArray{N} <: AbstractArray{Bool, N}

공간 효율적인 N차원 불리언 배열로, 각 불리언 값에 대해 단 하나의 비트만 사용합니다.

BitArray는 8바이트마다 최대 64개의 값을 압축하여 저장하므로 Array{Bool, N}에 비해 8배의 공간 효율성을 제공하며, 일부 연산은 64개의 값을 동시에 처리할 수 있습니다.

기본적으로, Julia는 불리언 요소를 생성하는 브로드캐스팅 연산(예: .==와 같은 점 연산)과 trues 및 falses 함수에서 BitArrays를 반환합니다.

Note

압축된 저장 형식으로 인해, BitArray의 요소에 대한 동시 접근은 적어도 하나의 요소가 쓰기인 경우 스레드 안전하지 않습니다.

source
Base.BitArray — Method
BitArray(undef, dims::Integer...)
BitArray{N}(undef, dims::NTuple{N,Int})

주어진 차원으로 undef BitArray를 생성합니다. Array 생성자와 동일하게 동작합니다. undef를 참조하세요.

예제

julia> BitArray(undef, 2, 2)
2×2 BitMatrix:
 0  0
 0  0

julia> BitArray(undef, (3, 1))
3×1 BitMatrix:
 0
 0
 0
source
Base.BitArray — Method
BitArray(itr)

주어진 반복 가능한 객체로 생성된 BitArray를 구성합니다. 형태는 itr 객체에서 유추됩니다.

예제

julia> BitArray([1 0; 0 1])
2×2 BitMatrix:
 1  0
 0  1

julia> BitArray(x+y == 3 for x = 1:2, y = 1:3)
2×3 BitMatrix:
 0  1  0
 1  0  0

julia> BitArray(x+y == 3 for x = 1:2 for y = 1:3)
6-element BitVector:
 0
 1
 0
 1
 0
 0
source
Base.trues — Function
trues(dims)

모든 값이 true로 설정된 BitArray를 생성합니다.

예제

julia> trues(2,3)
2×3 BitMatrix:
 1  1  1
 1  1  1
source
Base.falses — Function
falses(dims)

모든 값이 false로 설정된 BitArray를 생성합니다.

예제

julia> falses(2,3)
2×3 BitMatrix:
 0  0  0
 0  0  0
source
Base.fill — Function
fill(value, dims::Tuple)
fill(value, dims...)

모든 위치가 value로 설정된 크기 dims의 배열을 생성합니다.

예를 들어, fill(1.0, (5,5))는 배열의 모든 위치에 1.0이 있는 5×5 부동 소수점 배열을 반환합니다.

차원 길이 dims는 튜플 또는 인수 시퀀스로 지정할 수 있습니다. N 길이의 튜플 또는 value 다음에 오는 N 개의 인수는 N 차원 배열을 지정합니다. 따라서, 유일한 위치가 x로 설정된 0차원 배열을 생성하는 일반적인 관용구는 fill(x)입니다.

반환된 배열의 모든 위치는 전달된 value에 설정되어 있으며, 따라서 ===와 같습니다. 이는 value가 수정되면 fill된 배열의 모든 요소가 그 수정 사항을 반영한다는 것을 의미합니다. 왜냐하면 그들은 여전히 그 value이기 때문입니다. fill(1.0, (5,5))의 경우 value인 1.0은 불변이므로 수정할 수 없지만, 배열과 같은 가변 값에서는 예상치 못한 결과를 초래할 수 있습니다. 예를 들어, fill([], 3)은 반환된 벡터의 세 위치에 같은 빈 배열을 배치합니다:

julia> v = fill([], 3)
3-element Vector{Vector{Any}}:
 []
 []
 []

julia> v[1] === v[2] === v[3]
true

julia> value = v[1]
Any[]

julia> push!(value, 867_5309)
1-element Vector{Any}:
 8675309

julia> v
3-element Vector{Vector{Any}}:
 [8675309]
 [8675309]
 [8675309]

많은 독립적인 내부 배열을 생성하려면 대신 comprehension을 사용하십시오. 이는 루프의 각 반복에서 새롭고 독립적인 배열을 생성합니다:

julia> v2 = [[] for _ in 1:3]
3-element Vector{Vector{Any}}:
 []
 []
 []

julia> v2[1] === v2[2] === v2[3]
false

julia> push!(v2[1], 8675309)
1-element Vector{Any}:
 8675309

julia> v2
3-element Vector{Vector{Any}}:
 [8675309]
 []
 []

또한 참조하십시오: fill!, zeros, ones, similar.

예제

julia> fill(1.0, (2,3))
2×3 Matrix{Float64}:
 1.0  1.0  1.0
 1.0  1.0  1.0

julia> fill(42)
0-dimensional Array{Int64, 0}:
42

julia> A = fill(zeros(2), 2) # 두 요소를 동일한 [0.0, 0.0] 벡터로 설정
2-element Vector{Vector{Float64}}:
 [0.0, 0.0]
 [0.0, 0.0]

julia> A[1][1] = 42; # 채워진 값을 [42.0, 0.0]으로 수정

julia> A # A[1]과 A[2]는 동일한 벡터입니다
2-element Vector{Vector{Float64}}:
 [42.0, 0.0]
 [42.0, 0.0]
source
Base.fill! — Function
fill!(A, x)

배열 A를 값 x로 채웁니다. x가 객체 참조인 경우, 모든 요소는 동일한 객체를 참조합니다. fill!(A, Foo())는 Foo()를 한 번 평가한 결과로 채워진 A를 반환합니다.

예제

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

julia> fill!(A, 2.)
2×3 Matrix{Float64}:
 2.0  2.0  2.0
 2.0  2.0  2.0

julia> a = [1, 1, 1]; A = fill!(Vector{Vector{Int}}(undef, 3), a); a[1] = 2; A
3-element Vector{Vector{Int64}}:
 [2, 1, 1]
 [2, 1, 1]
 [2, 1, 1]

julia> x = 0; f() = (global x += 1; x); fill!(Vector{Int}(undef, 3), f())
3-element Vector{Int64}:
 1
 1
 1
source
Base.empty — Function
empty(x::Tuple)

빈 튜플 ()을 반환합니다.

source
empty(v::AbstractVector, [eltype])

v와 유사한 빈 벡터를 생성하며, 선택적으로 eltype을 변경할 수 있습니다.

참고: empty!, isempty, isassigned.

예제

julia> empty([1.0, 2.0, 3.0])
Float64[]

julia> empty([1.0, 2.0, 3.0], String)
String[]
source
empty(a::AbstractDict, [index_type=keytype(a)], [value_type=valtype(a)])

빈 AbstractDict 컨테이너를 생성하여 index_type 유형의 인덱스와 value_type 유형의 값을 수용할 수 있습니다. 두 번째 및 세 번째 인수는 선택 사항이며 각각 입력의 keytype 및 valtype으로 기본 설정됩니다. (두 유형 중 하나만 지정된 경우, 이는 value_type으로 간주되며, 기본적으로 index_type은 keytype(a)로 설정됩니다).

사용자 정의 AbstractDict 하위 유형은 세 개의 인수를 사용하는 서명에 특화하여 주어진 인덱스 및 값 유형에 가장 적합한 특정 사전 유형을 선택할 수 있습니다. 기본값은 빈 Dict를 반환하는 것입니다.

source
Base.similar — Function
유사한(A::AbstractSparseMatrixCSC{Tv,Ti}, [::Type{TvNew}, ::Type{TiNew}, m::Integer, n::Integer]) where {Tv,Ti}

주어진 요소 유형, 인덱스 유형 및 크기를 기반으로 주어진 소스 SparseMatrixCSC로 초기화되지 않은 가변 배열을 생성합니다. 새로운 희소 행렬은 원래 희소 행렬의 구조를 유지하지만 출력 행렬의 차원이 다를 경우를 제외합니다.

출력 행렬은 입력과 동일한 위치에 0이 있지만 비영(非零) 위치에는 초기화되지 않은 값이 있습니다.

source
similar(array, [element_type=eltype(array)], [dims=size(array)])

주어진 원본 배열을 기반으로 지정된 요소 유형과 크기로 초기화되지 않은 가변 배열을 생성합니다. 두 번째 및 세 번째 인수는 모두 선택 사항이며, 주어진 배열의 eltype 및 size로 기본값이 설정됩니다. 차원은 단일 튜플 인수로 지정하거나 일련의 정수 인수로 지정할 수 있습니다.

사용자 정의 AbstractArray 하위 유형은 주어진 요소 유형과 차원에 가장 적합한 배열 유형을 선택할 수 있습니다. 이 메서드를 전문화하지 않으면 기본값은 Array{element_type}(undef, dims...)입니다.

예를 들어, similar(1:10, 1, 4)는 범위가 가변적이지 않으며 2차원을 지원하지 않기 때문에 초기화되지 않은 Array{Int,2}를 반환합니다:

julia> similar(1:10, 1, 4)
1×4 Matrix{Int64}:
 4419743872  4374413872  4419743888  0

반대로, similar(trues(10,10), 2)는 두 개의 요소를 가진 초기화되지 않은 BitVector를 반환합니다. BitArray는 가변적이며 1차원 배열을 지원할 수 있습니다:

julia> similar(trues(10,10), 2)
2-element BitVector:
 0
 0

그러나 BitArray는 Bool 유형의 요소만 저장할 수 있으므로, 다른 요소 유형을 요청하면 일반 Array가 대신 생성됩니다:

julia> similar(falses(10), Float64, 2, 4)
2×4 Matrix{Float64}:
 2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314
 2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314

자세한 내용은: undef, isassigned.

source
similar(storagetype, axes)

storagetype에 의해 지정된 것과 유사한 초기화되지 않은 가변 배열을 생성하지만, 마지막 인수로 지정된 axes를 사용합니다.

예제:

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

는 Array{Int}처럼 "작동하는" 배열을 생성합니다(실제로 하나에 의해 지원될 수도 있음) 그러나 인덱스는 A와 동일하게 지정됩니다. 만약 A가 일반적인 인덱싱을 가지고 있다면, 이는 Array{Int}(undef, size(A))와 동일하지만, 만약 A가 비정상적인 인덱싱을 가지고 있다면 결과의 인덱스는 A와 일치합니다.

similar(BitArray, (axes(A, 2),))

는 A의 열 인덱스와 일치하는 1차원 논리 배열을 생성합니다.

source

Basic functions

Base.ndims — Function
ndims(A::AbstractArray) -> Integer

A의 차원 수를 반환합니다.

참고: size, axes.

예제

julia> A = fill(1, (3,4,5));

julia> ndims(A)
3
source
Base.size — Function
size(A::AbstractArray, [dim])

A의 차원을 포함하는 튜플을 반환합니다. 선택적으로 특정 차원을 지정하여 해당 차원의 길이만 가져올 수 있습니다.

size는 비표준 인덱스를 가진 배열에 대해 정의되지 않을 수 있으며, 이 경우 axes가 유용할 수 있습니다. 사용자 정의 인덱스를 가진 배열에 대한 매뉴얼 장을 참조하십시오.

또한: length, ndims, eachindex, sizeof.

예제

julia> A = fill(1, (2,3,4));

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

julia> size(A, 2)
3
source
Base.axes — Method
axes(A)

배열 A에 대한 유효한 인덱스의 튜플을 반환합니다.

참고: size, keys, eachindex.

예제

julia> A = fill(1, (5,6,7));

julia> axes(A)
(Base.OneTo(5), Base.OneTo(6), Base.OneTo(7))
source
Base.axes — Method
axes(A, d)

배열 A의 차원 d에 대한 유효한 인덱스 범위를 반환합니다.

또한 size 및 사용자 정의 인덱스를 가진 배열에 대한 매뉴얼 장을 참조하십시오.

예제

julia> A = fill(1, (5,6,7));

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

julia> axes(A, 4) == 1:1  # 모든 차원 d > ndims(A)는 크기가 1입니다.
true

사용 주의사항

각 인덱스는 AbstractUnitRange{<:Integer} 여야 하지만, 동시에 사용자 정의 인덱스를 사용하는 타입일 수도 있습니다. 예를 들어, 하위 집합이 필요하다면 begin/end 또는 firstindex/lastindex와 같은 일반화된 인덱싱 구조를 사용하십시오:

ix = axes(v, 1)
ix[2:end]          # 예를 들어 Vector에 대해 작동하지만 일반적으로 실패할 수 있습니다.
ix[(begin+1):end]  # 일반화된 인덱스에 대해 작동합니다.
source
Base.length — Method
length(A::AbstractArray)

배열의 요소 수를 반환하며, 기본값은 prod(size(A))입니다.

예제

julia> length([1, 2, 3, 4])
4

julia> length([1 2; 3 4])
4
source
Base.keys — Method
keys(a::AbstractArray)

a에 대한 모든 유효한 인덱스를 a 자체의 형태로 배열로 설명하는 효율적인 배열을 반환합니다.

1차원 배열(벡터)의 키는 정수인 반면, 모든 다른 N차원 배열은 CartesianIndex를 사용하여 위치를 설명합니다. 종종 특수 배열 유형인 LinearIndices와 CartesianIndices는 각각 이러한 정수 배열과 CartesianIndex를 효율적으로 표현하는 데 사용됩니다.

배열의 keys가 가장 효율적인 인덱스 유형이 아닐 수 있다는 점에 유의하십시오. 최대 성능을 위해서는 대신 eachindex를 사용하십시오.

예제

julia> keys([4, 5, 6])
3-element LinearIndices{1, Tuple{Base.OneTo{Int64}}}:
 1
 2
 3

julia> keys([4 5; 6 7])
CartesianIndices((2, 2))
source
Base.eachindex — Function
eachindex(A...)
eachindex(::IndexStyle, A::AbstractArray...)

AbstractArray A의 각 인덱스를 효율적으로 방문하기 위한 반복 가능한 객체를 생성합니다. 빠른 선형 인덱싱을 선택한 배열 유형(예: Array)의 경우, 이는 1 기반 인덱싱을 사용하는 경우 단순히 1:length(A) 범위입니다. 빠른 선형 인덱싱을 선택하지 않은 배열 유형의 경우, 일반적으로 모든 차원에 대해 지정된 인덱스로 배열에 효율적으로 인덱싱하기 위해 특수화된 카르테시안 범위가 반환됩니다.

일반적으로 eachindex는 문자열 및 사전을 포함한 임의의 반복 가능한 객체를 허용하며, 임의의 인덱스 유형(예: 불균형 간격 또는 비정수 인덱스)을 지원하는 반복자 객체를 반환합니다.

A가 AbstractArray인 경우, eachindex가 반환해야 하는 인덱스 스타일을 명시적으로 지정할 수 있으며, 첫 번째 인수로 IndexStyle 유형의 값을 전달합니다(일반적으로 선형 인덱스가 필요한 경우 IndexLinear() 또는 카르테시안 범위가 필요한 경우 IndexCartesian()).

하나 이상의 AbstractArray 인수를 제공하면, eachindex는 모든 인수에 대해 빠른 반복 가능한 객체를 생성합니다(일반적으로 모든 입력이 빠른 선형 인덱싱을 가지면 UnitRange, 그렇지 않으면 CartesianIndices). 배열의 크기 및/또는 차원이 다르면 DimensionMismatch 예외가 발생합니다.

인덱스와 값을 함께 반복하려면 pairs(A)를 참조하고, 한 차원에 대한 유효한 인덱스를 보려면 axes(A, 2)를 참조하십시오.

예제

julia> A = [10 20; 30 40];

julia> for i in eachindex(A) # 선형 인덱싱
           println("A[", i, "] == ", A[i])
       end
A[1] == 10
A[2] == 30
A[3] == 20
A[4] == 40

julia> for i in eachindex(view(A, 1:2, 1:1)) # 카르테시안 인덱싱
           println(i)
       end
CartesianIndex(1, 1)
CartesianIndex(2, 1)
source
Base.IndexStyle — Type
IndexStyle(A)
IndexStyle(typeof(A))

IndexStyle은 배열 A의 "기본 인덱싱 스타일"을 지정합니다. 새로운 AbstractArray 유형을 정의할 때, 선형 인덱싱(IndexLinear) 또는 카르테시안 인덱싱 중 하나를 구현하도록 선택할 수 있습니다. 선형 인덱싱만 구현하기로 결정한 경우, 배열 유형에 대해 이 특성을 설정해야 합니다:

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

기본값은 IndexCartesian()입니다.

Julia의 내부 인덱싱 기계는 모든 인덱싱 작업을 자동으로(그리고 보이지 않게) 선호하는 스타일로 재계산합니다. 이를 통해 사용자는 명시적인 방법이 제공되지 않은 경우에도 모든 인덱싱 스타일을 사용하여 배열의 요소에 접근할 수 있습니다.

AbstractArray에 대해 두 가지 인덱싱 스타일을 모두 정의하는 경우, 이 특성을 사용하여 가장 성능이 좋은 인덱싱 스타일을 선택할 수 있습니다. 일부 메서드는 입력에 대해 이 특성을 확인하고, 가장 효율적인 접근 패턴에 따라 다른 알고리즘으로 분기합니다. 특히, eachindex는 이 특성의 설정에 따라 유형이 달라지는 반복자를 생성합니다.

source
Base.IndexLinear — Type
IndexLinear()

IndexStyle의 하위 유형으로, 하나의 선형 인덱스로 최적화된 배열을 설명하는 데 사용됩니다.

선형 인덱싱 스타일은 배열 내의 위치를 설명하기 위해 하나의 정수 인덱스를 사용하며(다차원 배열일지라도) 열 우선 순서(column-major ordering)를 사용하여 요소에 효율적으로 접근합니다. 이는 IndexLinear인 배열에서 eachindex를 요청하면 단순한 1차원 범위가 반환됨을 의미합니다. 다차원 배열일지라도 마찬가지입니다.

IndexLinear로 IndexStyle을 보고하는 사용자 정의 배열은 단일 Int 인덱스를 사용하여 인덱싱(및 인덱스 할당)을 구현하기만 하면 됩니다. 모든 다른 인덱싱 표현식(다차원 접근 포함)은 선형 인덱스로 재계산됩니다. 예를 들어, A가 선형 인덱싱을 가진 2×3 사용자 정의 행렬이라면, A[1, 3]를 참조할 경우 이는 동등한 선형 인덱스로 재계산되어 A[5]를 호출하게 됩니다. 이는 1 + 2*(3 - 1) = 5이기 때문입니다.

또한 IndexCartesian도 참조하십시오.

source
Base.IndexCartesian — Type
IndexCartesian()

IndexStyle의 하위 유형으로, 카르테시안 인덱스로 최적화된 배열을 설명하는 데 사용됩니다. 이는 새로운 사용자 정의 AbstractArray 하위 유형의 기본값입니다.

카르테시안 인덱싱 스타일은 다차원 배열에서 위치를 설명하기 위해 여러 개의 정수 인덱스를 사용하며, 각 차원마다 정확히 하나의 인덱스를 사용합니다. 이는 IndexCartesian인 배열에서 eachindex를 요청하면 CartesianIndices의 범위를 반환함을 의미합니다.

IndexCartesian으로 IndexStyle을 보고하는 N차원 사용자 정의 배열은 정확히 N개의 Int 인덱스를 사용하여 인덱싱(및 인덱스 할당)을 구현해야 합니다. 모든 다른 인덱싱 표현식 — 선형 인덱싱을 포함하여 — 은 동등한 카르테시안 위치로 재계산됩니다. 예를 들어, A가 카르테시안 인덱싱을 가진 2×3 사용자 정의 행렬이라면, A[5]를 참조할 경우 이는 동등한 카르테시안 인덱스로 재계산되어 A[1, 3]을 호출하게 됩니다. 이는 5 = 1 + 2*(3 - 1)이기 때문입니다.

선형 인덱스에서 카르테시안 인덱스를 계산하는 것은 반대 방향으로 가는 것보다 훨씬 더 비쌉니다. 전자는 나눗셈을 요구하는데, 이는 매우 비용이 많이 드는 작업입니다. 반면 후자는 곱셈과 덧셈만 사용하며 본질적으로 무료입니다. 이러한 비대칭성은 IndexCartesian 배열에서 선형 인덱싱을 사용하는 것이 IndexLinear 배열에서 카르테시안 인덱싱을 사용하는 것보다 훨씬 더 비용이 많이 든다는 것을 의미합니다.

또한 IndexLinear를 참조하십시오.

source
Base.conj! — Function
conj!(A)

배열을 제자리에서 복소수 켤레로 변환합니다.

자세한 내용은 conj를 참조하세요.

예제

julia> A = [1+im 2-im; 2+2im 3+im]
2×2 Matrix{Complex{Int64}}:
 1+1im  2-1im
 2+2im  3+1im

julia> conj!(A);

julia> A
2×2 Matrix{Complex{Int64}}:
 1-1im  2+1im
 2-2im  3-1im
source
Base.stride — Function
stride(A, k::Integer)

차원 k에서 인접한 요소 간의 메모리 거리(요소 수)를 반환합니다.

참고: strides.

예제

julia> A = fill(1, (3,4,5));

julia> stride(A,2)
3

julia> stride(A,3)
12
source
Base.strides — Function
strides(A)

각 차원에서 메모리 스트라이드를 튜플로 반환합니다.

참고: stride.

예제

julia> A = fill(1, (3,4,5));

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

Broadcast and vectorization

또한 dot syntax for vectorizing functions를 참조하십시오. 예를 들어, f.(args...)는 암묵적으로 broadcast(f, args...)를 호출합니다. sin과 같은 함수의 "벡터화된" 메서드에 의존하기보다는, sin.(a)를 사용하여 broadcast를 통해 벡터화해야 합니다.

Base.Broadcast.broadcast — Function
broadcast(f, As...)

함수 f를 배열, 튜플, 컬렉션, Refs 및/또는 스칼라 As에 대해 브로드캐스트합니다.

브로드캐스팅은 컨테이너 인수의 요소와 As의 스칼라 자체에 대해 함수 f를 적용합니다. 단일 및 결측 차원은 값을 가상으로 반복하여 다른 인수의 범위에 맞게 확장됩니다. 기본적으로, Numbers, Strings, Symbols, Types, Functions 및 missing 및 nothing과 같은 일반적인 단일 항목을 포함하여 제한된 수의 유형만 스칼라로 간주됩니다. 다른 모든 인수는 요소별로 반복되거나 인덱싱됩니다.

결과 컨테이너 유형은 다음 규칙에 의해 결정됩니다:

  • 모든 인수가 스칼라 또는 0차원 배열인 경우, 언랩된 스칼라를 반환합니다.
  • 적어도 하나의 인수가 튜플이고 나머지가 스칼라 또는 0차원 배열인 경우, 튜플을 반환합니다.
  • 다른 모든 인수 조합은 기본적으로 Array를 반환하지만, 사용자 정의 컨테이너 유형은 인수로 나타날 때 결과를 사용자 정의하기 위해 자체 구현 및 승격과 유사한 규칙을 정의할 수 있습니다.

브로드캐스팅을 위한 특별한 구문이 존재합니다: f.(args...)는 broadcast(f, args...)와 동일하며, 중첩된 f.(g.(args...)) 호출은 단일 브로드캐스트 루프로 융합됩니다.

예제

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

julia> B = [1 2; 3 4; 5 6; 7 8; 9 10]
5×2 Matrix{Int64}:
 1   2
 3   4
 5   6
 7   8
 9  10

julia> broadcast(+, A, B)
5×2 Matrix{Int64}:
  2   3
  5   6
  8   9
 11  12
 14  15

julia> parse.(Int, ["1", "2"])
2-element Vector{Int64}:
 1
 2

julia> abs.((1, -2))
(1, 2)

julia> broadcast(+, 1.0, (0, -2.0))
(1.0, -1.0)

julia> (+).([[0,2], [1,3]], Ref{Vector{Int}}([1,-1]))
2-element Vector{Vector{Int64}}:
 [1, 1]
 [2, 2]

julia> string.(("one","two","three","four"), ": ", 1:4)
4-element Vector{String}:
 "one: 1"
 "two: 2"
 "three: 3"
 "four: 4"
source
Base.Broadcast.broadcast! — Function
broadcast!(f, dest, As...)

broadcast와 유사하지만, broadcast(f, As...)의 결과를 dest 배열에 저장합니다. dest는 결과를 저장하는 데만 사용되며, As에 나열되지 않는 한 f에 인수를 제공하지 않습니다. 예를 들어 broadcast!(f, A, A, B)는 A[:] = broadcast(f, A, B)를 수행합니다.

예제

julia> A = [1.0; 0.0]; B = [0.0; 0.0];

julia> broadcast!(+, B, A, (0, -2.0));

julia> B
2-element Vector{Float64}:
  1.0
 -2.0

julia> A
2-element Vector{Float64}:
 1.0
 0.0

julia> broadcast!(+, A, A, (0, -2.0));

julia> A
2-element Vector{Float64}:
  1.0
 -2.0
source
Base.Broadcast.@__dot__ — Macro
@. 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 Vector{Float64}:
 3.5244129544236893
 4.727892280477045
 3.4233600241796016
source

사용자 정의 유형에 대한 전문 방송을 보려면 다음을 참조하십시오.

Base.Broadcast.BroadcastStyle — Type

BroadcastStyle는 브로드캐스팅 하에서 객체의 동작을 결정하는 데 사용되는 추상 타입 및 특성 함수입니다. BroadcastStyle(typeof(x))는 x와 관련된 스타일을 반환합니다. 타입의 브로드캐스팅 동작을 사용자 정의하려면, 타입/메서드 쌍을 정의하여 스타일을 선언할 수 있습니다.

struct MyContainerStyle <: BroadcastStyle end
Base.BroadcastStyle(::Type{<:MyContainer}) = MyContainerStyle()

그런 다음 Broadcasted{MyContainerStyle}에서 작동하는 메서드(최소한 similar)를 작성합니다. 또한 활용할 수 있는 여러 미리 정의된 BroadcastStyle의 하위 타입이 있습니다. 더 많은 정보는 Interfaces chapter를 참조하세요.

source
Base.Broadcast.AbstractArrayStyle — Type

Broadcast.AbstractArrayStyle{N} <: BroadcastStyle는 AbstractArray 유형과 관련된 모든 스타일의 추상 슈퍼타입입니다. N 매개변수는 차원 수를 나타내며, 특정 차원 수만 지원하는 AbstractArray 유형에 유용할 수 있습니다:

struct SparseMatrixStyle <: Broadcast.AbstractArrayStyle{2} end
Base.BroadcastStyle(::Type{<:SparseMatrixCSC}) = SparseMatrixStyle()

임의의 차원 수를 지원하는 AbstractArray 유형의 경우, N을 Any로 설정할 수 있습니다:

struct MyArrayStyle <: Broadcast.AbstractArrayStyle{Any} end
Base.BroadcastStyle(::Type{<:MyArray}) = MyArrayStyle()

여러 AbstractArrayStyle을 혼합하고 차원 수를 추적할 수 있도록 하려면, 스타일이 Val 생성자를 지원해야 합니다:

struct MyArrayStyleDim{N} <: Broadcast.AbstractArrayStyle{N} end
(::Type{<:MyArrayStyleDim})(::Val{N}) where N = MyArrayStyleDim{N}()

두 개 이상의 AbstractArrayStyle 서브타입이 충돌하는 경우, 브로드캐스팅 기계는 Array를 생성하는 것으로 되돌아갑니다. 이것이 바람직하지 않은 경우, 출력 유형을 제어하기 위해 이진 BroadcastStyle 규칙을 정의해야 할 수 있습니다.

또한 Broadcast.DefaultArrayStyle를 참조하십시오.

source
Base.Broadcast.ArrayStyle — Type

Broadcast.ArrayStyle{MyArrayType}()는 객체가 브로드캐스팅을 위해 배열처럼 동작함을 나타내는 BroadcastStyle입니다. 이는 특정 AbstractArray 컨테이너 유형에 대한 Broadcast.AbstractArrayStyle를 구성하는 간단한 방법을 제공합니다. 이렇게 생성된 브로드캐스트 스타일은 차원 정보를 잃게 되며, 만약 차원 정보를 유지하는 것이 당신의 유형에 중요하다면, 자신만의 사용자 정의 Broadcast.AbstractArrayStyle를 생성해야 합니다.

source
Base.Broadcast.DefaultArrayStyle — Type

Broadcast.DefaultArrayStyle{N}()는 브로드캐스팅을 위해 객체가 N차원 배열처럼 동작함을 나타내는 BroadcastStyle입니다. 구체적으로, DefaultArrayStyle은 특수화된 스타일을 정의하지 않은 모든 AbstractArray 유형에 사용되며, 다른 broadcast 인수에서 오버라이드가 없을 경우 결과 출력 유형은 Array입니다. broadcast에 여러 입력이 있을 때, DefaultArrayStyle은 다른 모든 Broadcast.ArrayStyle에게 "패배"합니다.

source
Base.Broadcast.broadcastable — Function
Broadcast.broadcastable(x)

x 또는 x와 유사한 객체를 반환하여 axes, 인덱싱을 지원하고 그 타입이 ndims를 지원하도록 합니다.

x가 반복(iteration)을 지원하는 경우, 반환된 값은 collect(x)와 동일한 axes 및 인덱싱 동작을 가져야 합니다.

x가 AbstractArray가 아니지만 axes, 인덱싱을 지원하고 그 타입이 ndims를 지원하는 경우, broadcastable(::typeof(x))는 단순히 자신을 반환하도록 구현될 수 있습니다. 또한, x가 자신의 BroadcastStyle를 정의하는 경우, 사용자 정의 스타일에 효과가 있으려면 broadcastable 메서드를 정의하여 자신을 반환해야 합니다.

예제

julia> Broadcast.broadcastable([1,2,3]) # 배열은 이미 axes와 인덱싱을 지원하므로 `identity`와 같음
3-element Vector{Int64}:
 1
 2
 3

julia> Broadcast.broadcastable(Int) # 타입은 axes, 인덱싱 또는 반복을 지원하지 않지만 일반적으로 스칼라로 사용됨
Base.RefValue{Type{Int64}}(Int64)

julia> Broadcast.broadcastable("hello") # 문자열은 반복과 일치하는 관습을 깨고 스칼라처럼 작동함
Base.RefValue{String}("hello")
source
Base.Broadcast.combine_axes — Function
combine_axes(As...) -> Tuple

As의 모든 값에 대해 브로드캐스팅을 위한 결과 축을 결정합니다.

julia> Broadcast.combine_axes([1], [1 2; 3 4; 5 6])
(Base.OneTo(3), Base.OneTo(2))

julia> Broadcast.combine_axes(1, 1, 1)
()
source
Base.Broadcast.combine_styles — Function
combine_styles(cs...) -> BroadcastStyle

값 인수의 수에 따라 사용할 BroadcastStyle을 결정합니다. 각 인수에 대한 스타일을 얻기 위해 BroadcastStyle를 사용하고, 스타일을 결합하기 위해 result_style를 사용합니다.

예제

julia> Broadcast.combine_styles([1], [1 2; 3 4])
Base.Broadcast.DefaultArrayStyle{2}()
source
Base.Broadcast.result_style — Function
result_style(s1::BroadcastStyle[, s2::BroadcastStyle]) -> BroadcastStyle

하나 또는 두 개의 BroadcastStyle을 받아들이고, BroadcastStyle를 사용하여 공통 BroadcastStyle을 결정합니다.

예제

julia> Broadcast.result_style(Broadcast.DefaultArrayStyle{0}(), Broadcast.DefaultArrayStyle{3}())
Base.Broadcast.DefaultArrayStyle{3}()

julia> Broadcast.result_style(Broadcast.Unknown(), Broadcast.DefaultArrayStyle{1}())
Base.Broadcast.DefaultArrayStyle{1}()
source

Indexing and assignment

Base.getindex — Method
getindex(A, inds...)

인덱스 inds에 의해 선택된 배열 A의 하위 집합을 반환합니다.

각 인덱스는 Integer, CartesianIndex, 범위, 또는 지원되는 인덱스의 배열과 같은 지원되는 인덱스 유형일 수 있습니다. 특정 차원에서 모든 요소를 선택하기 위해 :를 사용할 수 있으며, 해당 인덱스가 true인 요소를 필터링하기 위해 불리언 배열(예: Array{Bool} 또는 BitArray)을 사용할 수 있습니다.

inds가 여러 요소를 선택할 때, 이 함수는 새로 할당된 배열을 반환합니다. 복사 없이 여러 요소에 인덱싱하려면 대신 view를 사용하십시오.

자세한 내용은 배열 인덱싱 매뉴얼 섹션을 참조하십시오.

예제

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

julia> getindex(A, 1)
1

julia> getindex(A, [2, 1])
2-element Vector{Int64}:
 3
 1

julia> getindex(A, 2:4)
3-element Vector{Int64}:
 3
 2
 4

julia> getindex(A, 2, 1)
3

julia> getindex(A, CartesianIndex(2, 1))
3

julia> getindex(A, :, 2)
2-element Vector{Int64}:
 2
 4

julia> getindex(A, 2, :)
2-element Vector{Int64}:
 3
 4

julia> getindex(A, A .> 2)
2-element Vector{Int64}:
 3
 4
source
Base.setindex! — Method
setindex!(A, X, inds...)
A[inds...] = X

배열 X의 값을 inds로 지정된 A의 일부 하위 집합에 저장합니다. 구문 A[inds...] = X는 (setindex!(A, X, inds...); X)와 동일합니다.

!!! 경고 변형된 인수가 다른 인수와 메모리를 공유할 때 동작이 예기치 않게 될 수 있습니다.

예제

julia> A = zeros(2,2);

julia> setindex!(A, [10, 20], [1, 2]);

julia> A[[3, 4]] = [30, 40];

julia> A
2×2 Matrix{Float64}:
 10.0  30.0
 20.0  40.0
source
Base.nextind — Function
nextind(A, i)

A에서 i 다음의 인덱스를 반환합니다. 반환된 인덱스는 종종 정수 i에 대해 i + 1과 동일합니다. 이 함수는 일반적인 코드에 유용할 수 있습니다.

!!! 경고 반환된 인덱스가 범위를 벗어날 수 있습니다. checkbounds 사용을 고려하세요.

또한: prevind.

예제

julia> x = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> nextind(x, 1) # 유효한 결과
2

julia> nextind(x, 4) # 유효하지 않은 결과
5

julia> nextind(x, CartesianIndex(1, 1)) # 유효한 결과
CartesianIndex(2, 1)

julia> nextind(x, CartesianIndex(2, 2)) # 유효하지 않은 결과
CartesianIndex(1, 3)
source
Base.prevind — Function
prevind(A, i)

A에서 i 이전의 인덱스를 반환합니다. 반환된 인덱스는 정수 i에 대해 종종 i - 1과 동일합니다. 이 함수는 일반적인 코드에 유용할 수 있습니다.

!!! 경고 반환된 인덱스가 범위를 벗어날 수 있습니다. checkbounds 사용을 고려하세요.

참고: nextind.

예제

julia> x = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> prevind(x, 4) # 유효한 결과
3

julia> prevind(x, 1) # 유효하지 않은 결과
0

julia> prevind(x, CartesianIndex(2, 2)) # 유효한 결과
CartesianIndex(1, 2)

julia> prevind(x, CartesianIndex(1, 1)) # 유효하지 않은 결과
CartesianIndex(2, 0)
source
Base.copyto! — Method
copyto!(dest, Rdest::CartesianIndices, src, Rsrc::CartesianIndices) -> dest

Rsrc 범위의 src 블록을 Rdest 범위의 dest 블록으로 복사합니다. 두 영역의 크기는 일치해야 합니다.

예제

julia> A = zeros(5, 5);

julia> B = [1 2; 3 4];

julia> Ainds = CartesianIndices((2:3, 2:3));

julia> Binds = CartesianIndices(B);

julia> copyto!(A, Ainds, B, Binds)
5×5 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0
 0.0  1.0  2.0  0.0  0.0
 0.0  3.0  4.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
source
Base.copy! — Function
copy!(dst, src) -> dst

src의 제자리 copy를 dst에 수행하며, dst에 있는 기존 요소는 모두 버립니다. dst와 src가 동일한 유형인 경우, 호출 후 dst == src가 성립해야 합니다. dst와 src가 다차원 배열인 경우, 두 배열은 동일한 axes를 가져야 합니다.

!!! 경고 변형된 인수가 다른 인수와 메모리를 공유할 경우 예상치 못한 동작이 발생할 수 있습니다.

또한 copyto!를 참조하세요.

!!! 호환성 "Julia 1.1" 이 메서드는 최소한 Julia 1.1이 필요합니다. Julia 1.0에서는 이 메서드가 Future 표준 라이브러리에서 Future.copy!로 제공됩니다.

source
Base.isassigned — Function
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 Vector{Foo}:
 #undef
 #undef
 #undef

julia> isassigned(v, 1)
false
source
Base.Colon — Type
Colon()

콜론(:)은 전체 객체나 차원을 한 번에 인덱싱하는 데 사용됩니다.

콜론에 대해 직접 정의된 연산은 매우 적습니다. 대신, 콜론은 to_indices에 의해 내부 벡터 타입(Base.Slice)으로 변환되어 사용되기 전에 그들이 포괄하는 인덱스의 모음을 나타냅니다.

Colon의 단일 인스턴스는 범위를 구성하는 데 사용되는 함수이기도 합니다. 자세한 내용은 :를 참조하세요.

source
Base.IteratorsMD.CartesianIndex — Type
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에 의해 생성되며, 항상 명시적인 CartesianIndices로 반복할 때 생성됩니다.

I::CartesianIndex는 broadcast에 대해 "스칼라" (컨테이너가 아님)로 처리됩니다. CartesianIndex의 구성 요소를 반복하려면 Tuple(I)로 변환하십시오.

예제

julia> A = reshape(Vector(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
Julia 1.10

broadcast에 대한 "스칼라"로서 CartesianIndex를 사용하려면 Julia 1.10이 필요합니다. 이전 릴리스에서는 Ref(I)를 사용하십시오.

source
Base.IteratorsMD.CartesianIndices — Type
CartesianIndices(sz::Dims) -> R
CartesianIndices((istart:[istep:]istop, jstart:[jstep:]jstop, ...)) -> R

다차원 직사각형 범위의 정수 인덱스를 포함하는 영역 R을 정의합니다. 이는 반복(iteration) 맥락에서 가장 일반적으로 사용되며, for I in R ... end는 중첩 루프에 해당하는 CartesianIndex 인덱스 I를 반환합니다.

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

따라서 이는 임의의 차원에서 작동하는 알고리즘을 작성하는 데 유용할 수 있습니다.

CartesianIndices(A::AbstractArray) -> R

편의상, 배열에서 CartesianIndices를 구성하면 해당 인덱스의 범위를 만듭니다.

Julia 1.6

단계 범위 방법 CartesianIndices((istart:istep:istop, jstart:[jstep:]jstop, ...))는 최소한 Julia 1.6이 필요합니다.

예제

julia> foreach(println, CartesianIndices((2, 2, 2)))
CartesianIndex(1, 1, 1)
CartesianIndex(2, 1, 1)
CartesianIndex(1, 2, 1)
CartesianIndex(2, 2, 1)
CartesianIndex(1, 1, 2)
CartesianIndex(2, 1, 2)
CartesianIndex(1, 2, 2)
CartesianIndex(2, 2, 2)

julia> CartesianIndices(fill(1, (2,3)))
CartesianIndices((2, 3))

선형 인덱스와 카르테시안 인덱스 간의 변환

선형 인덱스를 카르테시안 인덱스로 변환하는 것은 CartesianIndices가 AbstractArray이며 선형으로 인덱싱할 수 있다는 사실을 활용합니다:

julia> cartesian = CartesianIndices((1:3, 1:2))
CartesianIndices((1:3, 1:2))

julia> cartesian[4]
CartesianIndex(1, 2)

julia> cartesian = CartesianIndices((1:2:5, 1:2))
CartesianIndices((1:2:5, 1:2))

julia> cartesian[2, 2]
CartesianIndex(3, 2)

브로드캐스팅

CartesianIndices는 CartesianIndex와의 브로드캐스팅 산술(+ 및 -)을 지원합니다.

Julia 1.1

CartesianIndices의 브로드캐스팅은 최소한 Julia 1.1이 필요합니다.

julia> CIs = CartesianIndices((2:3, 5:6))
CartesianIndices((2:3, 5:6))

julia> CI = CartesianIndex(3, 4)
CartesianIndex(3, 4)

julia> CIs .+ CI
CartesianIndices((5:6, 9:10))

카르테시안에서 선형 인덱스로의 변환에 대해서는 LinearIndices를 참조하십시오. ```

source
Base.LinearIndices — Type
LinearIndices(A::AbstractArray)

A와 동일한 형태와 axes를 가진 LinearIndices 배열을 반환하며, A의 각 항목에 대한 선형 인덱스를 보유합니다. 이 배열을 카르테시안 인덱스로 인덱싱하면 선형 인덱스에 매핑할 수 있습니다.

전통적인 인덱싱(인덱스가 1에서 시작) 또는 다차원 배열의 경우, 선형 인덱스는 1에서 length(A)까지 범위입니다. 그러나 AbstractVector의 경우 선형 인덱스는 axes(A, 1)이며, 따라서 비전통적인 인덱싱을 가진 벡터의 경우 1에서 시작하지 않습니다.

이 함수를 호출하는 것은 선형 인덱싱을 활용하는 알고리즘을 작성하는 "안전한" 방법입니다.

예제

julia> A = fill(1, (5,6,7));

julia> b = LinearIndices(A);

julia> extrema(b)
(1, 210)
LinearIndices(inds::CartesianIndices) -> R
LinearIndices(sz::Dims) -> R
LinearIndices((istart:istop, jstart:jstop, ...)) -> R

지정된 형태 또는 axes를 가진 LinearIndices 배열을 반환합니다.

예제

이 생성자의 주요 목적은 카르테시안 인덱싱에서 선형 인덱싱으로의 직관적인 변환입니다:

julia> linear = LinearIndices((1:3, 1:2))
3×2 LinearIndices{2, Tuple{UnitRange{Int64}, UnitRange{Int64}}}:
 1  4
 2  5
 3  6

julia> linear[1,2]
4
source
Base.to_indices — Function
to_indices(A, I::Tuple)

튜플 I를 배열 A에 인덱싱하는 데 사용할 인덱스 튜플로 변환합니다.

반환된 튜플은 배열 A에서 지원하는 스칼라 인덱스의 Int 또는 AbstractArray만 포함해야 합니다. 처리할 수 없는 새로운 인덱스 유형을 만나면 오류가 발생합니다.

간단한 인덱스 유형의 경우, 각 인덱스 i를 처리하기 위해 비공식적으로 Base.to_index(A, i)에 위임합니다. 이 내부 함수는 직접 호출할 의도로 설계되지 않았지만, 사용자 정의 배열 또는 인덱스 유형에 의해 Base.to_index가 확장되어 사용자 정의 인덱싱 동작을 제공할 수 있습니다.

더 복잡한 인덱스 유형은 인덱싱하는 차원에 대한 더 많은 컨텍스트가 필요할 수 있습니다. 이러한 경우를 지원하기 위해 to_indices(A, I)는 to_indices(A, axes(A), I)를 호출하여 주어진 인덱스 튜플과 A의 차원 인덱스를 함께 재귀적으로 탐색합니다. 따라서 모든 인덱스 유형이 Base.to_index로 전파되는 것은 보장되지 않습니다.

예제

julia> A = zeros(1,2,3,4);

julia> to_indices(A, (1,1,2,2))
(1, 1, 2, 2)

julia> to_indices(A, (1,1,2,20)) # 경계 검사 없음
(1, 1, 2, 20)

julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # 이국적인 인덱스
(1, 2, 3, 4)

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

julia> to_indices(A, (1,2)) # 형태 검사 없음
(1, 2)
source
Base.checkbounds — Function
checkbounds(Bool, A, I...)

지정된 인덱스 I가 주어진 배열 A의 범위 내에 있으면 true를 반환합니다. 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
source
checkbounds(A, I...)

지정된 인덱스 I가 주어진 배열 A의 범위에 있지 않으면 오류를 발생시킵니다.

source
Base.checkindex — Function
checkindex(Bool, inds::AbstractUnitRange, index)

주어진 index가 inds의 경계 내에 있으면 true를 반환합니다. 모든 배열의 인덱스로 동작하고자 하는 사용자 정의 유형은 이 메서드를 확장하여 특화된 경계 검사 구현을 제공할 수 있습니다.

또한 checkbounds를 참조하십시오.

예제

julia> checkindex(Bool, 1:20, 8)
true

julia> checkindex(Bool, 1:20, 21)
false
source
Base.elsize — Function
elsize(type)

주어진 type 내에 저장된 eltype 요소 간의 메모리 스트라이드를 바이트 단위로 계산합니다. 배열 요소가 균일한 선형 스트라이드로 조밀하게 저장되는 경우입니다.

예제

julia> Base.elsize(rand(Float32, 10))
4
source

Views (SubArrays and other view types)

“뷰(view)”는 배열처럼 작동하는 데이터 구조(‘AbstractArray’의 하위 유형)지만, 기본 데이터는 실제로 다른 배열의 일부입니다.

예를 들어, x가 배열이고 v = @view x[1:10]인 경우, v는 10개 요소를 가진 배열처럼 작동하지만, 실제로는 x의 첫 10개 요소에 접근하고 있습니다. 뷰에 쓰기를 하면, 예를 들어 v[3] = 2는 기본 배열 x에 직접 쓰기를 하며 (이 경우 x[3]를 수정하게 됩니다).

슬라이싱 작업은 기본적으로 Julia에서 x[1:10]와 같이 복사본을 생성합니다. @view x[1:10]는 이를 뷰로 변경합니다. @views 매크로는 전체 코드 블록에 사용할 수 있으며(예: @views function foo() .... end 또는 @views begin ... end), 해당 블록의 모든 슬라이싱 작업을 뷰를 사용하도록 변경합니다. 때때로 데이터의 복사본을 만드는 것이 더 빠르고, 때때로 뷰를 사용하는 것이 더 빠릅니다. 이는 performance tips에서 설명됩니다.

Base.view — Function
view(A, inds...)

getindex와 유사하지만, 주어진 인덱스 또는 인덱스 집합 inds에서 부모 배열 A를 지연 참조(또는 사실상 view로)하는 경량 배열을 반환하며, 요소를 즉시 추출하거나 복사된 하위 집합을 구성하는 대신에 반환합니다. 반환된 값(종종 SubArray)에서 getindex 또는 setindex!를 호출하면 부모 배열에 접근하거나 수정하기 위한 인덱스가 즉석에서 계산됩니다. view가 호출된 후 부모 배열의 형태가 변경되면 동작이 정의되지 않으며, 부모 배열에 대한 경계 검사가 없기 때문에 세그멘테이션 오류를 일으킬 수 있습니다.

일부 불변 부모 배열(예: 범위)은 효율적이고 호환 가능한 의미를 제공하는 경우 SubArray를 반환하는 대신 새로운 배열을 재계산하기로 선택할 수 있습니다.

Julia 1.6

Julia 1.6 이상에서는 view를 AbstractString에 호출할 수 있으며, SubString을 반환합니다.

예제

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

julia> b = view(A, :, 1)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

julia> fill!(b, 0)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 0
 0

julia> A # b를 수정했음에도 A가 변경되었음을 주목하세요
2×2 Matrix{Int64}:
 0  2
 0  4

julia> view(2:5, 2:3) # 타입이 불변이므로 범위를 반환합니다
3:4
source
Base.@view — Macro
@view A[inds...]

인덱싱 표현식 A[inds...]를 동등한 view 호출로 변환합니다.

이는 단일 인덱싱 표현식에만 직접 적용할 수 있으며, A[begin, 2:end-1]와 같은 특별한 begin 또는 end 인덱싱 구문을 포함하는 표현식에 특히 유용합니다(이는 일반 view 함수에서 지원되지 않음).

@view는 일반 할당의 대상이 될 수 없으며(예: @view(A[1, 2:end]) = ...), 장식이 없는 인덱스 할당 (A[1, 2:end] = ...) 또는 브로드캐스트된 인덱스 할당 (A[1, 2:end] .= ...)도 복사본을 만들지 않습니다. 그러나 @view(A[1, 2:end]) .+= 1과 같은 브로드캐스트된 할당을 업데이트하는 데 유용할 수 있습니다. 이는 @view(A[1, 2:end]) .= @view(A[1, 2:end]) + 1에 대한 간단한 구문이며, 오른쪽의 인덱싱 표현식은 @view 없이 복사본을 만들 것입니다.

비스칼라 인덱싱에 대해 뷰를 사용하도록 전체 코드 블록을 전환하려면 @views도 참조하십시오.

Julia 1.5

인덱싱 표현식에서 첫 번째 인덱스를 참조하기 위해 begin을 사용하는 것은 최소한 Julia 1.5가 필요합니다.

예제

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

julia> b = @view A[:, 1]
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

julia> fill!(b, 0)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 0
 0

julia> A
2×2 Matrix{Int64}:
 0  2
 0  4
source
Base.@views — Macro
@views 표현식

주어진 표현식(이는 begin/end 블록, 루프, 함수 등일 수 있음)에서 모든 배열 슬라이싱 작업을 뷰를 반환하도록 변환합니다. 스칼라 인덱스, 비배열 유형 및 명시적 getindex 호출(즉, array[...]가 아닌)은 영향을 받지 않습니다.

유사하게, @views는 문자열 슬라이스를 SubString 뷰로 변환합니다.

!!! 주의 @views 매크로는 주어진 expression에 명시적으로 나타나는 array[...] 표현식에만 영향을 미치며, 해당 코드에 의해 호출되는 함수에서 발생하는 배열 슬라이싱에는 영향을 미치지 않습니다.

!!! 호환성 "Julia 1.5" 인덱싱 표현식에서 첫 번째 인덱스를 참조하기 위해 begin을 사용하는 것은 Julia 1.4에서 구현되었지만, Julia 1.5부터 @views에 의해 지원되었습니다.

예시

julia> A = zeros(3, 3);

julia> @views for row in 1:3
           b = A[row, :] # b는 복사가 아닌 뷰입니다
           b .= row      # 모든 요소를 행 인덱스로 할당
       end

julia> A
3×3 Matrix{Float64}:
 1.0  1.0  1.0
 2.0  2.0  2.0
 3.0  3.0  3.0
source
Base.parent — Function
parent(A)

뷰의 기본 부모 객체를 반환합니다. SubArray, SubString, ReshapedArray 또는 LinearAlgebra.Transpose 유형의 객체의 부모는 객체 생성 시 view, reshape, transpose 등에 인수로 전달된 것입니다. 입력이 래핑된 객체가 아닌 경우 입력 자체를 반환합니다. 입력이 여러 번 래핑된 경우 가장 바깥쪽 래퍼만 제거됩니다.

예제

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

julia> V = view(A, 1:2, :)
2×2 view(::Matrix{Int64}, 1:2, :) with eltype Int64:
 1  2
 3  4

julia> parent(V)
2×2 Matrix{Int64}:
 1  2
 3  4
source
Base.parentindices — Function
parentindices(A)

parent에 해당하는 인덱스를 반환합니다 A의 뷰.

예제

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

julia> V = view(A, 1, :)
2-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2

julia> parentindices(V)
(1, Base.Slice(Base.OneTo(2)))
source
Base.selectdim — Function
selectdim(A, d::Integer, i)

d 차원의 인덱스가 i인 A의 모든 데이터의 뷰를 반환합니다.

i가 d 위치에 있는 view(A,:,:,...,i,:,:,...)와 동등합니다.

참고: eachslice.

예제

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

julia> selectdim(A, 2, 3)
2-element view(::Matrix{Int64}, :, 3) with eltype Int64:
 3
 7

julia> selectdim(A, 2, 3:4)
2×2 view(::Matrix{Int64}, :, 3:4) with eltype Int64:
 3  4
 7  8
source
Base.reinterpret — Function
reinterpret(::Type{Out}, x::In)

이진 데이터의 타입 해석을 isbits 값 x에서 isbits 타입 Out으로 변경합니다. Out의 크기(패딩 무시)는 x의 타입과 동일해야 합니다. 예를 들어, reinterpret(Float32, UInt32(7))는 UInt32(7)에 해당하는 4바이트를 Float32로 해석합니다. reinterpret(In, reinterpret(Out, x)) === x임을 주의하세요.

julia> reinterpret(Float32, UInt32(7))
1.0f-44

julia> reinterpret(NTuple{2, UInt8}, 0x1234)
(0x34, 0x12)

julia> reinterpret(UInt16, (0x34, 0x12))
0x1234

julia> reinterpret(Tuple{UInt16, UInt8}, (0x01, 0x0203))
(0x0301, 0x02)
Note

패딩 처리 방식은 reinterpret(::DataType, ::AbstractArray)와 다릅니다.

Warning

Out의 일부 비트 조합이 유효하지 않다고 간주되며, 그렇지 않으면 타입의 생성자 및 메서드에 의해 방지될 수 있는 경우 주의하십시오. 추가 검증 없이 예기치 않은 동작이 발생할 수 있습니다.

source
reinterpret(T::DataType, A::AbstractArray)

주어진 배열과 동일한 이진 데이터를 가진 배열의 뷰를 생성하지만, T를 요소 유형으로 사용합니다.

이 함수는 요소가 명시적으로 검색될 때까지 계산되지 않는 "지연" 배열에서도 작동합니다. 예를 들어, 범위 1:6에 대한 reinterpret는 조밀한 벡터 collect(1:6)에 대한 것과 유사하게 작동합니다:

julia> reinterpret(Float32, UInt32[1 2 3 4 5])
1×5 reinterpret(Float32, ::Matrix{UInt32}):
 1.0f-45  3.0f-45  4.0f-45  6.0f-45  7.0f-45

julia> reinterpret(Complex{Int}, 1:6)
3-element reinterpret(Complex{Int64}, ::UnitRange{Int64}):
 1 + 2im
 3 + 4im
 5 + 6im

패딩 비트의 위치가 T와 eltype(A) 사이에 정렬되지 않으면, 결과 배열은 읽기 전용 또는 쓰기 전용이 되어, 각각 잘못된 비트가 쓰이거나 읽히는 것을 방지합니다.

julia> a = reinterpret(Tuple{UInt8, UInt32}, UInt32[1, 2])
1-element reinterpret(Tuple{UInt8, UInt32}, ::Vector{UInt32}):
 (0x01, 0x00000002)

julia> a[1] = 3
ERROR: Padding of type Tuple{UInt8, UInt32} is not compatible with type UInt32.

julia> b = reinterpret(UInt32, Tuple{UInt8, UInt32}[(0x01, 0x00000002)]); # showing will error

julia> b[1]
ERROR: Padding of type UInt32 is not compatible with type Tuple{UInt8, UInt32}.
source
reinterpret(reshape, T, A::AbstractArray{S}) -> B

A의 타입 해석을 변경하면서 "채널 차원"을 소비하거나 추가합니다.

sizeof(T) = n*sizeof(S)이고 n>1인 경우, A의 첫 번째 차원은 크기가 n이어야 하며 B는 A의 첫 번째 차원이 없습니다. 반대로, sizeof(S) = n*sizeof(T)이고 n>1인 경우, B는 크기가 n인 새로운 첫 번째 차원을 갖습니다. sizeof(T) == sizeof(S)인 경우 차원 수는 변경되지 않습니다.

Julia 1.6

이 메서드는 최소한 Julia 1.6이 필요합니다.

예제

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

julia> reinterpret(reshape, Complex{Int}, A)    # 결과는 벡터입니다
2-element reinterpret(reshape, Complex{Int64}, ::Matrix{Int64}) with eltype Complex{Int64}:
 1 + 3im
 2 + 4im

julia> a = [(1,2,3), (4,5,6)]
2-element Vector{Tuple{Int64, Int64, Int64}}:
 (1, 2, 3)
 (4, 5, 6)

julia> reinterpret(reshape, Int, a)             # 결과는 행렬입니다
3×2 reinterpret(reshape, Int64, ::Vector{Tuple{Int64, Int64, Int64}}) with eltype Int64:
 1  4
 2  5
 3  6
source
Base.reshape — Function
reshape(A, dims...) -> AbstractArray
reshape(A, dims) -> AbstractArray

A와 동일한 데이터를 가진 배열을 반환하지만, 차원 크기나 차원 수가 다릅니다. 두 배열은 동일한 기본 데이터를 공유하므로, 결과는 A가 변경 가능할 때만 변경 가능하며, 하나의 요소를 설정하면 다른 요소의 값이 변경됩니다.

새로운 차원은 인수 목록 또는 형태 튜플로 지정할 수 있습니다. 최대 하나의 차원만 :로 지정할 수 있으며, 이 경우 그 길이는 지정된 모든 차원과의 곱이 원래 배열 A의 길이와 같도록 계산됩니다. 총 요소 수는 변경될 수 없습니다.

예제

julia> A = Vector(1:16)
16-element Vector{Int64}:
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16

julia> reshape(A, (4, 4))
4×4 Matrix{Int64}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> reshape(A, 2, :)
2×8 Matrix{Int64}:
 1  3  5  7   9  11  13  15
 2  4  6  8  10  12  14  16

julia> reshape(1:6, 2, 3)
2×3 reshape(::UnitRange{Int64}, 2, 3) with eltype Int64:
 1  3  5
 2  4  6
source
Base.dropdims — Function
dropdims(A; dims)

dims로 지정된 차원이 제거된 A와 동일한 데이터를 가진 배열을 반환합니다. size(A,d)는 dims의 모든 d에 대해 1과 같아야 하며, 반복된 차원이나 1:ndims(A) 범위를 벗어난 숫자는 허용되지 않습니다.

결과는 A와 동일한 기본 데이터를 공유하므로, 결과는 A가 변경 가능할 때만 변경 가능하며, 하나의 요소를 설정하면 다른 요소의 값도 변경됩니다.

참고: reshape, vec.

예제

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

julia> b = dropdims(a; dims=3)
2×2×1 Array{Int64, 3}:
[:, :, 1] =
 1  3
 2  4

julia> b[1,1,1] = 5; a
2×2×1×1 Array{Int64, 4}:
[:, :, 1, 1] =
 5  3
 2  4
source
Base.vec — Function
vec(a::AbstractArray) -> AbstractVector

배열 a를 1차원 열 벡터로 변환합니다. a가 이미 AbstractVector인 경우 a를 반환합니다. 결과 배열은 a와 동일한 기본 데이터를 공유하므로, a가 변경 가능할 경우에만 변경 가능하며, 이 경우 하나를 수정하면 다른 것도 수정됩니다.

예제

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

julia> vec(a)
6-element Vector{Int64}:
 1
 4
 2
 5
 3
 6

julia> vec(1:3)
1:3

또한 reshape, dropdims를 참조하세요.

source
Base.SubArray — Type
SubArray{T,N,P,I,L} <: AbstractArray{T,N}

N-차원 부모 배열(유형 P)에 대한 뷰로, 요소 유형 T를 가지며, 인덱스 튜플(유형 I)로 제한됩니다. L은 빠른 선형 인덱싱을 지원하는 유형에 대해 true이고, 그렇지 않은 경우 false입니다.

view 함수를 사용하여 SubArray를 생성합니다.

source

Concatenation and permutation

Base.cat — Function
cat(A...; dims)

입력 배열을 dims에 지정된 차원에 따라 연결합니다.

차원 d in dims에 따라 출력 배열의 크기는 sum(size(a,d) for a in A)입니다. 다른 차원에서는 모든 입력 배열이 동일한 크기를 가져야 하며, 이는 해당 차원에서 출력 배열의 크기도 됩니다.

dims가 단일 숫자인 경우, 서로 다른 배열이 해당 차원에 따라 밀집되어 있습니다. dims가 여러 차원을 포함하는 iterable인 경우, 이러한 차원에 따라 위치가 각 입력 배열에 대해 동시에 증가하며, 다른 곳은 0으로 채워집니다. 이를 통해 cat(matrices...; dims=(1,2))와 같이 블록 대각 행렬을 구성할 수 있으며, 그 고차원 유사체도 가능합니다.

특수한 경우 dims=1은 vcat이고, dims=2는 hcat입니다. 또한 hvcat, hvncat, stack, repeat도 참조하십시오.

키워드는 Val(dims)도 허용합니다.

Julia 1.8

여러 차원에 대해 dims = Val(::Tuple)이 Julia 1.8에 추가되었습니다.

예제

서로 다른 차원에서 두 배열을 연결합니다:

julia> a = [1 2 3]
1×3 Matrix{Int64}:
 1  2  3

julia> b = [4 5 6]
1×3 Matrix{Int64}:
 4  5  6

julia> cat(a, b; dims=1)
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> cat(a, b; dims=2)
1×6 Matrix{Int64}:
 1  2  3  4  5  6

julia> cat(a, b; dims=(1, 2))
2×6 Matrix{Int64}:
 1  2  3  0  0  0
 0  0  0  4  5  6

확장 도움말

3D 배열을 연결합니다:

julia> a = ones(2, 2, 3);

julia> b = ones(2, 2, 4);

julia> c = cat(a, b; dims=3);

julia> size(c) == (2, 2, 7)
true

서로 다른 크기의 배열을 연결합니다:

julia> cat([1 2; 3 4], [pi, pi], fill(10, 2,3,1); dims=2)  # hcat과 동일
2×6×1 Array{Float64, 3}:
[:, :, 1] =
 1.0  2.0  3.14159  10.0  10.0  10.0
 3.0  4.0  3.14159  10.0  10.0  10.0

블록 대각 행렬을 구성합니다:

julia> cat(true, trues(2,2), trues(4)', dims=(1,2))  # 블록 대각
4×7 Matrix{Bool}:
 1  0  0  0  0  0  0
 0  1  1  0  0  0  0
 0  1  1  0  0  0  0
 0  0  0  1  1  1  1
julia> cat(1, [2], [3;;]; dims=Val(2))
1×3 Matrix{Int64}:
 1  2  3
Note

cat는 두 문자열을 결합하지 않으며, *를 사용해야 할 수 있습니다.

julia> a = "aaa";

julia> b = "bbb";

julia> cat(a, b; dims=1)
2-element Vector{String}:
 "aaa"
 "bbb"

julia> cat(a, b; dims=2)
1×2 Matrix{String}:
 "aaa"  "bbb"

julia> a * b
"aaabbb"
source
Base.vcat — Function
vcat(A...)

배열이나 숫자를 수직으로 연결합니다. cat(A...; dims=1)와 같으며, 구문 [a; b; c]와도 같습니다.

큰 배열 벡터를 연결할 때, reduce(vcat, A)는 A isa AbstractVector{<:AbstractVecOrMat}일 때 효율적인 방법을 호출하며, 쌍으로 작업하는 대신에 사용됩니다.

또한 hcat, Iterators.flatten, stack를 참조하세요.

예제

julia> v = vcat([1,2], [3,4])
4-element Vector{Int64}:
 1
 2
 3
 4

julia> v == vcat(1, 2, [3,4])  # 숫자도 허용
true

julia> v == [1; 2; [3,4]]  # 동일한 작업을 위한 구문
true

julia> summary(ComplexF64[1; 2; [3,4]])  # 요소 유형을 제공하는 구문
"4-element Vector{ComplexF64}"

julia> vcat(range(1, 2, length=3))  # 지연 범위를 수집
3-element Vector{Float64}:
 1.0
 1.5
 2.0

julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # 행 벡터와 행렬
([10 20 30], [4.0 5.0 6.0; 7.0 8.0 9.0])

julia> vcat(two...)
3×3 Matrix{Float64}:
 10.0  20.0  30.0
  4.0   5.0   6.0
  7.0   8.0   9.0

julia> vs = [[1, 2], [3, 4], [5, 6]];

julia> reduce(vcat, vs)  # vcat(vs...)보다 더 효율적
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

julia> ans == collect(Iterators.flatten(vs))
true
source
Base.hcat — Function
hcat(A...)

배열이나 숫자를 수평으로 연결합니다. cat(A...; dims=2)와 같으며, 구문 [a b c] 또는 [a;; b;; c]와도 같습니다.

큰 배열 벡터의 경우, reduce(hcat, A)는 A isa AbstractVector{<:AbstractVecOrMat}일 때 효율적인 방법을 호출합니다. 벡터의 벡터의 경우, 이것은 stack(A)로도 작성할 수 있습니다.

또한 vcat, hvcat를 참조하십시오.

예제

julia> hcat([1,2], [3,4], [5,6])
2×3 Matrix{Int64}:
 1  3  5
 2  4  6

julia> hcat(1, 2, [30 40], [5, 6, 7]')  # 숫자도 허용
1×7 Matrix{Int64}:
 1  2  30  40  5  6  7

julia> ans == [1 2 [30 40] [5, 6, 7]']  # 동일한 작업을 위한 구문
true

julia> Float32[1 2 [30 40] [5, 6, 7]']  # eltype을 제공하는 구문
1×7 Matrix{Float32}:
 1.0  2.0  30.0  40.0  5.0  6.0  7.0

julia> ms = [zeros(2,2), [1 2; 3 4], [50 60; 70 80]];

julia> reduce(hcat, ms)  # hcat(ms...)보다 더 효율적
2×6 Matrix{Float64}:
 0.0  0.0  1.0  2.0  50.0  60.0
 0.0  0.0  3.0  4.0  70.0  80.0

julia> stack(ms) |> summary  # 행렬 벡터에 대해 불일치
"2×2×3 Array{Float64, 3}"

julia> hcat(Int[], Int[], Int[])  # 크기 (0,)인 빈 벡터
0×3 Matrix{Int64}

julia> hcat([1.1, 9.9], Matrix(undef, 2, 0))  # 빈 2×0 행렬과 함께 hcat
2×1 Matrix{Any}:
 1.1
 9.9
source
Base.hvcat — Function
hvcat(blocks_per_row::Union{Tuple{Vararg{Int}}, Int}, values...)

한 번의 호출로 수평 및 수직 연결. 이 함수는 블록 행렬 구문에 대해 호출됩니다. 첫 번째 인수는 각 블록 행에서 연결할 인수의 수를 지정합니다. 첫 번째 인수가 단일 정수 n인 경우 모든 블록 행은 n개의 블록 열을 가진 것으로 간주됩니다.

예제

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 Matrix{Int64}:
 1  2  3
 4  5  6

julia> hvcat((3,3), a,b,c,d,e,f)
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> [a b; c d; e f]
3×2 Matrix{Int64}:
 1  2
 3  4
 5  6

julia> hvcat((2,2,2), a,b,c,d,e,f)
3×2 Matrix{Int64}:
 1  2
 3  4
 5  6
julia> hvcat((2,2,2), a,b,c,d,e,f) == hvcat(2, a,b,c,d,e,f)
true
source
Base.hvncat — Function
hvncat(dim::Int, row_first, values...)
hvncat(dims::Tuple{Vararg{Int}}, row_first, values...)
hvncat(shape::Tuple{Vararg{Tuple}}, row_first, values...)

여러 values를 한 번의 호출로 수평, 수직 및 n차원으로 연결합니다.

이 함수는 블록 행렬 구문에 대해 호출됩니다. 첫 번째 인수는 hvcat과 유사하게 연결의 모양을 지정하는 튜플의 튜플이거나 각 축을 따라 요소의 주요 수를 지정하는 차원으로, 출력 차원을 결정하는 데 사용됩니다. dims 형식은 성능이 더 좋으며, 연결 작업이 각 축을 따라 동일한 수의 요소를 가질 때 기본적으로 사용됩니다(예: [a b; c d;;; e f ; g h]). shape 형식은 각 축을 따라 요소의 수가 불균형할 때 사용됩니다(예: [a b ; c]). 불균형 구문은 추가 검증 오버헤드가 필요합니다. dim 형식은 단일 차원에 따라 연결하기 위한 최적화입니다. row_first는 values의 순서를 나타냅니다. shape의 첫 번째 및 두 번째 요소의 의미는 row_first에 따라 바뀝니다.

예제

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]
1×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  2  3

[:, :, 2] =
 4  5  6

julia> hvncat((2,1,3), false, a,b,c,d,e,f)
2×1×3 Array{Int64, 3}:
[:, :, 1] =
 1
 2

[:, :, 2] =
 3
 4

[:, :, 3] =
 5
 6

julia> [a b;;; c d;;; e f]
1×2×3 Array{Int64, 3}:
[:, :, 1] =
 1  2

[:, :, 2] =
 3  4

[:, :, 3] =
 5  6

julia> hvncat(((3, 3), (3, 3), (6,)), true, a, b, c, d, e, f)
1×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  2  3

[:, :, 2] =
 4  5  6

인수 구성 예제

[a b c ; d e f ;;;
 g h i ; j k l ;;;
 m n o ; p q r ;;;
 s t u ; v w x]
⇒ dims = (2, 3, 4)

[a b ; c ;;; d ;;;;]
 ___   _     _
 2     1     1 = 각 행의 요소 (2, 1, 1)
 _______     _
 3           1 = 각 열의 요소 (3, 1)
 _____________
 4             = 각 3d 슬라이스의 요소 (4,)
 _____________
 4             = 각 4d 슬라이스의 요소 (4,)
⇒ shape = ((2, 1, 1), (3, 1), (4,), (4,)) with `row_first` = true
source
Base.stack — Function
stack(iter; [dims])

동일한 크기의 배열(또는 기타 반복 가능한 객체) 모음을 하나의 더 큰 배열로 결합하여 하나 이상의 새로운 차원에 따라 배열합니다.

기본적으로 요소의 축이 먼저 배치되어 size(result) = (size(first(iter))..., size(iter)...)가 됩니다. 이는 Iterators.flatten(iter)와 동일한 요소 순서를 가집니다.

키워드 dims::Integer를 사용하면, 대신 iter의 i번째 요소가 슬라이스 selectdim(result, dims, i)가 되어 size(result, dims) == length(iter)가 됩니다. 이 경우 stack은 동일한 dims로 eachslice의 동작을 반전시킵니다.

여러 가지 cat 함수도 배열을 결합합니다. 그러나 이들은 모두 배열의 기존(아마도 사소한) 차원을 확장하는 반면, 배열을 새로운 차원에 배치합니다. 또한 배열을 단일 컬렉션이 아닌 개별 인수로 허용합니다.

Julia 1.9

이 함수는 최소한 Julia 1.9가 필요합니다.

예제

julia> vecs = (1:2, [30, 40], Float32[500, 600]);

julia> mat = stack(vecs)
2×3 Matrix{Float32}:
 1.0  30.0  500.0
 2.0  40.0  600.0

julia> mat == hcat(vecs...) == reduce(hcat, collect(vecs))
true

julia> vec(mat) == vcat(vecs...) == reduce(vcat, collect(vecs))
true

julia> stack(zip(1:4, 10:99))  # 반복 가능한 반복자의 모든 인스턴스를 허용
2×4 Matrix{Int64}:
  1   2   3   4
 10  11  12  13

julia> vec(ans) == collect(Iterators.flatten(zip(1:4, 10:99)))
true

julia> stack(vecs; dims=1)  # 모든 cat 함수와 달리, vecs[1]의 1차 축은 결과의 2차 축
3×2 Matrix{Float32}:
   1.0    2.0
  30.0   40.0
 500.0  600.0

julia> x = rand(3,4);

julia> x == stack(eachcol(x)) == stack(eachrow(x), dims=1)  # eachslice의 역
true

고차원 예제:

julia> A = rand(5, 7, 11);

julia> E = eachslice(A, dims=2);  # 행렬의 벡터

julia> (element = size(first(E)), container = size(E))
(element = (5, 11), container = (7,))

julia> stack(E) |> size
(5, 11, 7)

julia> stack(E) == stack(E; dims=3) == cat(E...; dims=3)
true

julia> A == stack(E; dims=2)
true

julia> M = (fill(10i+j, 2, 3) for i in 1:5, j in 1:7);

julia> (element = size(first(M)), container = size(M))
(element = (2, 3), container = (5, 7))

julia> stack(M) |> size  # 모든 차원을 유지
(2, 3, 5, 7)

julia> stack(M; dims=1) |> size  # dims=1에 따라 vec(container)
(35, 2, 3)

julia> hvcat(5, M...) |> size  # hvcat은 행렬을 나란히 배치
(14, 15)
source
stack(f, args...; [dims])

컬렉션의 각 요소에 함수를 적용하고 결과를 stack합니다. 또는 여러 컬렉션을 zip하여 함께 사용할 수 있습니다.

함수는 모두 같은 크기의 배열(또는 튜플, 또는 다른 반복자)을 반환해야 합니다. 이들은 결과의 슬라이스가 되며, 주어진 경우 dims를 따라 또는 기본적으로 마지막 차원을 따라 구분됩니다.

또한 mapslices, eachcol를 참조하세요.

예제

julia> stack(c -> (c, c-32), "julia")
2×5 Matrix{Char}:
 'j'  'u'  'l'  'i'  'a'
 'J'  'U'  'L'  'I'  'A'

julia> stack(eachrow([1 2 3; 4 5 6]), (10, 100); dims=1) do row, n
         vcat(row, row .* n, row ./ n)
       end
2×9 Matrix{Float64}:
 1.0  2.0  3.0   10.0   20.0   30.0  0.1   0.2   0.3
 4.0  5.0  6.0  400.0  500.0  600.0  0.04  0.05  0.06
source
Base.vect — Function
vect(X...)

주어진 인수 목록을 포함하는 promote_typeof에서 계산된 요소 유형으로 Vector를 생성합니다.

예제

julia> a = Base.vect(UInt8(1), 2.5, 1//2)
3-element Vector{Float64}:
 1.0
 2.5
 0.5
source
Base.circshift — Function
circshift(A, shifts)

배열의 데이터를 순환적으로 이동, 즉 회전합니다. 두 번째 인자는 각 차원에서 이동할 양을 제공하는 튜플 또는 벡터이거나, 첫 번째 차원에서만 이동할 정수입니다.

또한 참조: circshift!, circcopy!, bitrotate, <<.

예제

julia> b = reshape(Vector(1:16), (4,4))
4×4 Matrix{Int64}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> circshift(b, (0,2))
4×4 Matrix{Int64}:
  9  13  1  5
 10  14  2  6
 11  15  3  7
 12  16  4  8

julia> circshift(b, (-1,0))
4×4 Matrix{Int64}:
 2  6  10  14
 3  7  11  15
 4  8  12  16
 1  5   9  13

julia> a = BitArray([true, true, false, false, true])
5-element BitVector:
 1
 1
 0
 0
 1

julia> circshift(a, 1)
5-element BitVector:
 1
 1
 1
 0
 0

julia> circshift(a, -1)
5-element BitVector:
 1
 0
 0
 1
 1
source
Base.circshift! — Function
circshift!(dest, src, shifts)

src의 데이터를 원형으로 이동(회전)하여 결과를 dest에 저장합니다. shifts는 각 차원에서 이동할 양을 지정합니다.

Warning

변경된 인수가 다른 인수와 메모리를 공유할 때 동작이 예기치 않게 나타날 수 있습니다.

자세한 내용은 circshift를 참조하세요.

source
Base.circcopy! — Function
circcopy!(dest, src)

src를 dest로 복사하며, 각 차원을 그 길이에 따라 모듈로 인덱싱합니다. src와 dest는 같은 크기를 가져야 하지만, 인덱스에서 오프셋을 가질 수 있습니다; 어떤 오프셋도 (원형) 래핑을 초래합니다. 배열이 겹치는 인덱스를 가지면, 겹치는 영역에서 dest는 src와 일치합니다.

Warning

어떤 변형된 인자가 다른 인자와 메모리를 공유할 때 동작이 예기치 않게 나타날 수 있습니다.

참고: circshift.

예제

julia> src = reshape(Vector(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}(undef, (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
source
Base.findall — Method
findall(A)

벡터 I를 반환하여 A의 true 인덱스 또는 키를 제공합니다. A의 그러한 요소가 없으면 빈 배열을 반환합니다. 다른 종류의 값을 검색하려면 첫 번째 인수로 프레디케이트를 전달하십시오.

인덱스 또는 키는 keys(A) 및 pairs(A)에서 반환된 것과 동일한 유형입니다.

또한 참조: findfirst, searchsorted.

예제

julia> A = [true, false, false, true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> findall(A)
2-element Vector{Int64}:
 1
 4

julia> A = [true false; false true]
2×2 Matrix{Bool}:
 1  0
 0  1

julia> findall(A)
2-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 2)

julia> findall(falses(3))
Int64[]
source
Base.findall — Method
findall(f::Function, A)

함수 f(A[I])가 true를 반환하는 A의 인덱스 또는 키의 벡터 I를 반환합니다. A의 그러한 요소가 없으면 빈 배열을 반환합니다.

인덱스 또는 키는 keys(A) 및 pairs(A)에서 반환된 것과 동일한 유형입니다.

예제

julia> x = [1, 3, 4]
3-element Vector{Int64}:
 1
 3
 4

julia> findall(isodd, x)
2-element Vector{Int64}:
 1
 2

julia> A = [1 2 0; 3 4 0]
2×3 Matrix{Int64}:
 1  2  0
 3  4  0
julia> findall(isodd, A)
2-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)

julia> findall(!iszero, A)
4-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)
 CartesianIndex(1, 2)
 CartesianIndex(2, 2)

julia> d = Dict(:A => 10, :B => -1, :C => 0)
Dict{Symbol, Int64} with 3 entries:
  :A => 10
  :B => -1
  :C => 0

julia> findall(x -> x >= 0, d)
2-element Vector{Symbol}:
 :A
 :C
source
Base.findfirst — Method
findfirst(A)

A에서 첫 번째 true 값의 인덱스 또는 키를 반환합니다. 그러한 값이 발견되지 않으면 nothing을 반환합니다. 다른 종류의 값을 검색하려면 첫 번째 인수로 술어를 전달하십시오.

인덱스 또는 키는 keys(A) 및 pairs(A)에서 반환되는 것과 동일한 유형입니다.

참고: findall, findnext, findlast, searchsortedfirst.

예제

julia> A = [false, false, true, false]
4-element Vector{Bool}:
 0
 0
 1
 0

julia> findfirst(A)
3

julia> findfirst(falses(3)) # 아무것도 반환하지 않지만 REPL에 출력되지 않음

julia> A = [false false; true false]
2×2 Matrix{Bool}:
 0  0
 1  0

julia> findfirst(A)
CartesianIndex(2, 1)
source
Base.findfirst — Method
findfirst(predicate::Function, A)

predicate가 true를 반환하는 A의 첫 번째 요소의 인덱스 또는 키를 반환합니다. 그러한 요소가 없으면 nothing을 반환합니다.

인덱스 또는 키는 keys(A) 및 pairs(A)에서 반환되는 것과 동일한 유형입니다.

예제

julia> A = [1, 4, 2, 2]
4-element Vector{Int64}:
 1
 4
 2
 2

julia> findfirst(iseven, A)
2

julia> findfirst(x -> x>10, A) # 아무것도 반환하지 않지만 REPL에 출력되지 않음

julia> findfirst(isequal(4), A)
2

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

julia> findfirst(iseven, A)
CartesianIndex(2, 1)
source
Base.findlast — Method
findlast(A)

A에서 마지막 true 값의 인덱스 또는 키를 반환합니다. A에 true 값이 없으면 nothing을 반환합니다.

인덱스 또는 키는 keys(A) 및 pairs(A)에서 반환되는 것과 동일한 유형입니다.

참고: findfirst, findprev, findall.

예제

julia> A = [true, false, true, false]
4-element Vector{Bool}:
 1
 0
 1
 0

julia> findlast(A)
3

julia> A = falses(2,2);

julia> findlast(A) # 아무것도 반환하지 않지만 REPL에 출력되지 않음

julia> A = [true false; true false]
2×2 Matrix{Bool}:
 1  0
 1  0

julia> findlast(A)
CartesianIndex(2, 1)
source
Base.findlast — Method
findlast(predicate::Function, A)

predicate가 true를 반환하는 A의 마지막 요소의 인덱스 또는 키를 반환합니다. 그러한 요소가 없으면 nothing을 반환합니다.

인덱스 또는 키는 keys(A) 및 pairs(A)에서 반환되는 것과 동일한 유형입니다.

예제

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

julia> findlast(isodd, A)
3

julia> findlast(x -> x > 5, A) # 아무것도 반환하지 않지만 REPL에 출력되지 않음

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

julia> findlast(isodd, A)
CartesianIndex(2, 1)
source
Base.findnext — Method
findnext(A, i)

A에서 i 이후 또는 i를 포함한 true 요소의 다음 인덱스를 찾거나, 없으면 nothing을 반환합니다.

인덱스는 keys(A) 및 pairs(A)에서 반환되는 것과 동일한 유형입니다.

예제

julia> A = [false, false, true, false]
4-element Vector{Bool}:
 0
 0
 1
 0

julia> findnext(A, 1)
3

julia> findnext(A, 4) # 반환은 nothing이지만 REPL에 출력되지 않음

julia> A = [false false; true false]
2×2 Matrix{Bool}:
 0  0
 1  0

julia> findnext(A, CartesianIndex(1, 1))
CartesianIndex(2, 1)
source
Base.findnext — Method
findnext(predicate::Function, A, i)

predicate가 true를 반환하는 A의 요소의 다음 인덱스를 i 이후 또는 포함하여 찾습니다. 찾지 못한 경우 nothing을 반환합니다. 이는 getindex, keys(A), 및 nextind를 지원하는 배열, 문자열 및 대부분의 다른 컬렉션에서 작동합니다.

인덱스는 keys(A) 및 pairs(A)에서 반환된 것과 동일한 유형입니다.

예제

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

julia> findnext(isodd, A, 1)
1

julia> findnext(isodd, A, 2) # nothing을 반환하지만 REPL에 출력되지 않음

julia> A = [1 4; 2 2];

julia> findnext(isodd, A, CartesianIndex(1, 1))
CartesianIndex(1, 1)

julia> findnext(isspace, "a b c", 3)
4
source
Base.findprev — Method
findprev(A, i)

A의 true 요소의 i 이전 또는 i를 포함한 이전 인덱스를 찾거나, 찾지 못한 경우 nothing을 반환합니다.

인덱스는 keys(A) 및 pairs(A)에서 반환되는 것과 동일한 유형입니다.

참고: findnext, findfirst, findall.

예제

julia> A = [false, false, true, true]
4-element Vector{Bool}:
 0
 0
 1
 1

julia> findprev(A, 3)
3

julia> findprev(A, 1) # nothing을 반환하지만 REPL에 출력되지 않음

julia> A = [false false; true true]
2×2 Matrix{Bool}:
 0  0
 1  1

julia> findprev(A, CartesianIndex(2, 1))
CartesianIndex(2, 1)
source
Base.findprev — Method
findprev(predicate::Function, A, i)

predicate가 true를 반환하는 A의 요소에 대해 i 이전 또는 i를 포함한 이전 인덱스를 찾거나, 찾지 못한 경우 nothing을 반환합니다. 이는 getindex, keys(A), 및 nextind를 지원하는 배열, 문자열 및 대부분의 다른 컬렉션에서 작동합니다.

인덱스는 keys(A) 및 pairs(A)에서 반환된 것과 동일한 유형입니다.

예제

julia> A = [4, 6, 1, 2]
4-element Vector{Int64}:
 4
 6
 1
 2

julia> findprev(isodd, A, 1) # 아무것도 반환하지 않지만 REPL에 출력되지 않음

julia> findprev(isodd, A, 3)
3

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

julia> findprev(isodd, A, CartesianIndex(1, 2))
CartesianIndex(2, 1)

julia> findprev(isspace, "a b c", 3)
2
source
Base.permutedims — Function
permutedims(A::AbstractArray, perm)
permutedims(A::AbstractMatrix)

배열 A의 차원(축)을 변경합니다. perm은 변경을 지정하는 ndims(A) 정수의 튜플 또는 벡터입니다.

A가 2차원 배열(AbstractMatrix)인 경우, perm은 기본적으로 (2,1)으로 설정되어 A의 두 축(행과 열)을 교환합니다. 이는 transpose와 다르며, 이 연산은 재귀적이지 않기 때문에 비수치 값(재귀적 transpose가 오류를 발생시키는 경우) 및 선형 연산자를 나타내지 않는 2차원 배열에 특히 유용합니다.

1차원 배열의 경우 permutedims(v::AbstractVector)를 참조하십시오. 이는 1행 “행렬”을 반환합니다.

또한 permutedims!, PermutedDimsArray, transpose, invperm를 참조하십시오.

예제

2차원 배열:

transpose와 달리 permutedims는 문자열과 같은 임의의 비수치 요소로 구성된 2차원 배열의 행과 열을 교환하는 데 사용할 수 있습니다:

julia> A = ["a" "b" "c"
            "d" "e" "f"]
2×3 Matrix{String}:
 "a"  "b"  "c"
 "d"  "e"  "f"

julia> permutedims(A)
3×2 Matrix{String}:
 "a"  "d"
 "b"  "e"
 "c"  "f"

그리고 permutedims는 요소가 자체적으로 수치 행렬인 행렬에 대해 transpose와 다른 결과를 생성합니다:

julia> a = [1 2; 3 4];

julia> b = [5 6; 7 8];

julia> c = [9 10; 11 12];

julia> d = [13 14; 15 16];

julia> X = [[a] [b]; [c] [d]]
2×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]     [5 6; 7 8]
 [9 10; 11 12]  [13 14; 15 16]

julia> permutedims(X)
2×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]  [9 10; 11 12]
 [5 6; 7 8]  [13 14; 15 16]

julia> transpose(X)
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 3; 2 4]  [9 11; 10 12]
 [5 7; 6 8]  [13 15; 14 16]

다차원 배열

julia> A = reshape(Vector(1:8), (2,2,2))
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  3
 2  4

[:, :, 2] =
 5  7
 6  8

julia> perm = (3, 1, 2); # 마지막 차원을 첫 번째로 이동

julia> B = permutedims(A, perm)
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  2
 5  6

[:, :, 2] =
 3  4
 7  8

julia> A == permutedims(B, invperm(perm)) # 역변환
true

B = permutedims(A, perm)의 각 차원 i에 대해, A의 해당 차원은 perm[i]가 됩니다. 이는 size(B, i) == size(A, perm[i])가 성립함을 의미합니다.

julia> A = randn(5, 7, 11, 13);

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

julia> B = permutedims(A, perm);

julia> size(B)
(13, 5, 11, 7)

julia> size(A)[perm] == ans
true
source
permutedims(v::AbstractVector)

벡터 v를 1 × length(v) 행렬로 변형합니다. 이 작업은 transpose와 다르게 재귀적이지 않으며, 이는 비수치 값의 배열에 특히 유용합니다(재귀적 transpose는 오류를 발생시킬 수 있습니다).

예제

transpose와 달리, permutedims는 문자열과 같은 임의의 비수치 요소로 구성된 벡터에서 사용할 수 있습니다:

julia> permutedims(["a", "b", "c"])
1×3 Matrix{String}:
 "a"  "b"  "c"

숫자로 구성된 벡터의 경우, permutedims(v)는 transpose(v)와 유사하게 작동하지만 반환 유형이 다릅니다(원래 배열 v와 메모리를 공유하지만, LinearAlgebra.Transpose 뷰 대신 reshape를 사용합니다):

julia> v = [1, 2, 3, 4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> p = permutedims(v)
1×4 Matrix{Int64}:
 1  2  3  4

julia> r = transpose(v)
1×4 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3  4

julia> p == r
true

julia> typeof(r)
Transpose{Int64, Vector{Int64}}

julia> p[1] = 5; r[2] = 6; # p 또는 r을 변형하면 v도 변경됩니다.

julia> v # p와 r 모두와 메모리를 공유합니다.
4-element Vector{Int64}:
 5
 6
 3
 4

그러나 permutedims는 요소가 숫자 행렬인 벡터에 대해 transpose와 다른 결과를 생성합니다:

julia> V = [[[1 2; 3 4]]; [[5 6; 7 8]]]
2-element Vector{Matrix{Int64}}:
 [1 2; 3 4]
 [5 6; 7 8]

julia> permutedims(V)
1×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]  [5 6; 7 8]

julia> transpose(V)
1×2 transpose(::Vector{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 3; 2 4]  [5 7; 6 8]
source
Base.permutedims! — Function
permutedims!(dest, src, perm)

배열 src의 차원을 변경하고 결과를 배열 dest에 저장합니다. perm은 길이가 ndims(src)인 순열을 지정하는 벡터입니다. 미리 할당된 배열 dest는 size(dest) == size(src)[perm]이어야 하며 완전히 덮어씌워집니다. 제자리에서의 순열은 지원되지 않으며 src와 dest가 겹치는 메모리 영역을 가지면 예기치 않은 결과가 발생합니다.

자세한 내용은 permutedims를 참조하세요.

source
Base.PermutedDimsArrays.PermutedDimsArray — Type
PermutedDimsArray(A, perm) -> B

주어진 AbstractArray A에 대해, 차원이 순서가 바뀐 것처럼 보이는 뷰 B를 생성합니다. permutedims와 유사하지만, 복사가 발생하지 않으며 (B는 A와 저장소를 공유합니다).

자세한 내용은 permutedims, invperm를 참조하세요.

예제

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
source
Base.promote_shape — Function
promote_shape(s1, s2)

두 배열의 형태가 호환되는지 확인하고, 후행 단일 차원을 허용하며, 더 많은 차원을 가진 형태를 반환합니다.

예제

julia> a = fill(1, (3,4,1,1,1));

julia> b = fill(1, (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)
source

Array functions

Base.accumulate — Function
accumulate(op, A; dims::Integer, [init])

누적 연산 op를 A의 차원 dims를 따라 수행합니다 (벡터의 경우 dims는 선택적입니다). 초기값 init은 키워드 인수로 선택적으로 제공될 수 있습니다. 성능을 위해 미리 할당된 출력 배열을 사용하고 출력의 정밀도를 제어하기 위해 accumulate!도 참조하십시오 (예: 오버플로우를 피하기 위해).

일반적인 연산에 대해서는 accumulate의 특수화된 변형이 있습니다. cumsum, cumprod를 참조하십시오. 지연 버전은 Iterators.accumulate를 참조하십시오.

Julia 1.5

비배열 반복자에서의 accumulate는 최소한 Julia 1.5가 필요합니다.

예제

julia> accumulate(+, [1,2,3])
3-element Vector{Int64}:
 1
 3
 6

julia> accumulate(min, (1, -2, 3, -4, 5), init=0)
(0, -2, -2, -4, -4)

julia> accumulate(/, (2, 4, Inf), init=100)
(50.0, 12.5, 0.0)

julia> accumulate(=>, i^2 for i in 1:3)
3-element Vector{Any}:
          1
        1 => 4
 (1 => 4) => 9

julia> accumulate(+, fill(1, 3, 4))
3×4 Matrix{Int64}:
 1  4  7  10
 2  5  8  11
 3  6  9  12

julia> accumulate(+, fill(1, 2, 5), dims=2, init=100.0)
2×5 Matrix{Float64}:
 101.0  102.0  103.0  104.0  105.0
 101.0  102.0  103.0  104.0  105.0
source
Base.accumulate! — Function
accumulate!(op, B, A; [dims], [init])

누적 연산 op를 A의 차원 dims를 따라 수행하고 결과를 B에 저장합니다. 벡터의 경우 dims를 제공하는 것은 선택 사항입니다. 키워드 인수 init이 주어지면, 그 값이 누적을 초기화하는 데 사용됩니다.

!!! 경고 변형된 인수가 다른 인수와 메모리를 공유할 경우 동작이 예기치 않게 될 수 있습니다.

자세한 내용은 accumulate, cumsum!, cumprod!를 참조하세요.

예제

julia> x = [1, 0, 2, 0, 3];

julia> y = rand(5);

julia> accumulate!(+, y, x);

julia> y
5-element Vector{Float64}:
 1.0
 1.0
 3.0
 3.0
 6.0

julia> A = [1 2 3; 4 5 6];

julia> B = similar(A);

julia> accumulate!(-, B, A, dims=1)
2×3 Matrix{Int64}:
  1   2   3
 -3  -3  -3

julia> accumulate!(*, B, A, dims=2, init=10)
2×3 Matrix{Int64}:
 10   20    60
 40  200  1200
source
Base.cumprod — Function
cumprod(A; dims::Integer)

주어진 차원 dim에 따라 누적 곱을 계산합니다. 성능을 위해 미리 할당된 출력 배열을 사용하고 출력의 정밀도를 제어하기 위해 cumprod!도 참조하십시오 (예: 오버플로우를 피하기 위해).

예제

julia> a = Int8[1 2 3; 4 5 6];

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

julia> cumprod(a, dims=2)
2×3 Matrix{Int64}:
 1   2    6
 4  20  120
source
cumprod(itr)

이터레이터의 누적 곱.

또한 cumprod!, accumulate, cumsum를 참조하세요.

Julia 1.5

비배열 이터레이터에서 cumprod는 최소한 Julia 1.5가 필요합니다.

예제

julia> cumprod(fill(1//2, 3))
3-element Vector{Rational{Int64}}:
 1//2
 1//4
 1//8

julia> cumprod((1, 2, 1, 3, 1))
(1, 2, 2, 6, 6)

julia> cumprod("julia")
5-element Vector{String}:
 "j"
 "ju"
 "jul"
 "juli"
 "julia"
source
Base.cumprod! — Function
cumprod!(B, A; dims::Integer)

A의 누적 곱을 dims 차원에 따라 계산하여 결과를 B에 저장합니다. cumprod도 참조하세요.

!!! 경고 변형된 인수가 다른 인수와 메모리를 공유할 때 동작이 예기치 않게 나타날 수 있습니다.

source
cumprod!(y::AbstractVector, x::AbstractVector)

벡터 x의 누적 곱을 계산하여 결과를 y에 저장합니다. cumprod도 참조하세요.

!!! 경고 변형된 인수가 다른 인수와 메모리를 공유할 때 동작이 예기치 않게 될 수 있습니다.

source
Base.cumsum — Function
cumsum(A; dims::Integer)

차원 dims에 따라 누적 합을 계산합니다. 성능을 위해 미리 할당된 출력 배열을 사용하고 출력의 정밀도를 제어하기 위해 cumsum!도 참조하십시오 (예: 오버플로우를 피하기 위해).

예제

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

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

julia> cumsum(a, dims=2)
2×3 Matrix{Int64}:
 1  3   6
 4  9  15
Note

반환 배열의 eltype은 시스템 단어 크기보다 작은 부호 있는 정수의 경우 Int이고, 시스템 단어 크기보다 작은 부호 없는 정수의 경우 UInt입니다. 작은 부호 있는 또는 부호 없는 정수 배열의 eltype을 유지하려면 accumulate(+, A)를 사용해야 합니다.

julia> cumsum(Int8[100, 28])
2-element Vector{Int64}:
 100
 128

julia> accumulate(+,Int8[100, 28])
2-element Vector{Int8}:
  100
 -128

첫 번째 경우에서 정수는 시스템 단어 크기로 확장되므로 결과는 Int64[100, 128]입니다. 두 번째 경우에서는 그러한 확장이 발생하지 않으며 정수 오버플로우로 인해 Int8[100, -128]가 됩니다.

source
cumsum(itr)

이터레이터의 누적 합.

+ 이외의 함수를 적용하려면 accumulate를 참조하세요.

Julia 1.5

비배열 이터레이터에서 cumsum을 사용하려면 최소한 Julia 1.5가 필요합니다.

예제

julia> cumsum(1:3)
3-element Vector{Int64}:
 1
 3
 6

julia> cumsum((true, false, true, false, true))
(1, 1, 2, 2, 3)

julia> cumsum(fill(1, 2) for i in 1:3)
3-element Vector{Vector{Int64}}:
 [1, 1]
 [2, 2]
 [3, 3]
source
Base.cumsum! — Function
cumsum!(B, A; dims::Integer)

A의 dims 차원에 따라 누적 합계를 계산하여 결과를 B에 저장합니다. cumsum도 참조하세요.

!!! 경고 변형된 인수가 다른 인수와 메모리를 공유할 때 동작이 예기치 않게 될 수 있습니다.

source
Base.diff — Function
diff(A::AbstractVector)
diff(A::AbstractArray; dims::Integer)

벡터 또는 다차원 배열 A에 대한 유한 차분 연산자입니다. 후자의 경우, 작동할 차원을 dims 키워드 인수로 지정해야 합니다.

Julia 1.1

차원이 2보다 큰 배열에 대한 diff는 최소한 Julia 1.1이 필요합니다.

예제

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

julia> diff(a, dims=2)
2×1 Matrix{Int64}:
  2
 10

julia> diff(vec(a))
3-element Vector{Int64}:
  4
 -2
 12
source
Base.repeat — Function
repeat(A::AbstractArray, counts::Integer...)

주어진 차원에서 배열 A를 지정된 수만큼 반복하여 배열을 생성합니다. 반복 횟수는 counts로 지정됩니다.

참고: fill, Iterators.repeated, Iterators.cycle.

예제

julia> repeat([1, 2, 3], 2)
6-element Vector{Int64}:
 1
 2
 3
 1
 2
 3

julia> repeat([1, 2, 3], 2, 3)
6×3 Matrix{Int64}:
 1  1  1
 2  2  2
 3  3  3
 1  1  1
 2  2  2
 3  3  3
source
repeat(A::AbstractArray; inner=ntuple(Returns(1), ndims(A)), outer=ntuple(Returns(1), ndims(A)))

A의 항목을 반복하여 배열을 구성합니다. inner의 i번째 요소는 A의 i번째 차원의 개별 항목이 반복되어야 하는 횟수를 지정합니다. outer의 i번째 요소는 A의 i번째 차원을 따라 슬라이스가 반복되어야 하는 횟수를 지정합니다. inner 또는 outer가 생략되면 반복이 수행되지 않습니다.

예제

julia> repeat(1:2, inner=2)
4-element Vector{Int64}:
 1
 1
 2
 2

julia> repeat(1:2, outer=2)
4-element Vector{Int64}:
 1
 2
 1
 2

julia> repeat([1 2; 3 4], inner=(2, 1), outer=(1, 3))
4×6 Matrix{Int64}:
 1  2  1  2  1  2
 1  2  1  2  1  2
 3  4  3  4  3  4
 3  4  3  4  3  4
source
repeat(s::AbstractString, r::Integer)

문자열을 r 번 반복합니다. 이는 s^r로 작성할 수 있습니다.

자세한 내용은 ^를 참조하세요.

예제

julia> repeat("ha", 3)
"hahaha"
source
repeat(c::AbstractChar, r::Integer) -> String

문자를 r 번 반복합니다. 이는 c^r를 호출하여 동일하게 수행할 수 있습니다.

예제

julia> repeat('A', 3)
"AAA"
source
Base.rot180 — Function
rot180(A)

행렬 A를 180도 회전시킵니다.

예제

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rot180(a)
2×2 Matrix{Int64}:
 4  3
 2  1
source
rot180(A, k)

행렬 A를 180도 정수 k번 회전합니다. k가 짝수인 경우, 이는 copy와 동일합니다.

예제

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rot180(a,1)
2×2 Matrix{Int64}:
 4  3
 2  1

julia> rot180(a,2)
2×2 Matrix{Int64}:
 1  2
 3  4
source
Base.rotl90 — Function
rotl90(A)

행렬 A를 왼쪽으로 90도 회전시킵니다.

예제

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rotl90(a)
2×2 Matrix{Int64}:
 2  4
 1  3
source
rotl90(A, k)

행렬 A를 90도 반시계 방향으로 정수 k만큼 왼쪽으로 회전합니다. k가 4의 배수(0 포함)인 경우, 이는 copy와 동일합니다.

예제

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rotl90(a,1)
2×2 Matrix{Int64}:
 2  4
 1  3

julia> rotl90(a,2)
2×2 Matrix{Int64}:
 4  3
 2  1

julia> rotl90(a,3)
2×2 Matrix{Int64}:
 3  1
 4  2

julia> rotl90(a,4)
2×2 Matrix{Int64}:
 1  2
 3  4
source
Base.rotr90 — Function
rotr90(A)

행렬 A를 오른쪽으로 90도 회전시킵니다.

예시

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rotr90(a)
2×2 Matrix{Int64}:
 3  1
 4  2
source
rotr90(A, k)

행렬 A를 시계 방향으로 90도 정수 k번 회전합니다. k가 4의 배수(0 포함)인 경우, 이는 copy와 동일합니다.

예제

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rotr90(a,1)
2×2 Matrix{Int64}:
 3  1
 4  2

julia> rotr90(a,2)
2×2 Matrix{Int64}:
 4  3
 2  1

julia> rotr90(a,3)
2×2 Matrix{Int64}:
 2  4
 1  3

julia> rotr90(a,4)
2×2 Matrix{Int64}:
 1  2
 3  4
source
Base.mapslices — Function
mapslices(f, A; dims)

주어진 배열 A의 차원을 변환하여 각 슬라이스 A[..., :, ..., :, ...]에 함수 f를 적용합니다. 여기서 dims의 각 d에 콜론이 있습니다. 결과는 나머지 차원을 따라 연결됩니다.

예를 들어, dims = [1,2]이고 A가 4차원인 경우, f는 모든 i와 j에 대해 x = A[:,:,i,j]에서 호출되며, f(x)는 결과 R에서 R[:,:,i,j]가 됩니다.

또한 eachcol 또는 eachslice를 참조하십시오. 이는 map 또는 stack와 함께 사용됩니다.

예제

julia> A = reshape(1:30,(2,5,3))
2×5×3 reshape(::UnitRange{Int64}, 2, 5, 3) with eltype Int64:
[:, :, 1] =
 1  3  5  7   9
 2  4  6  8  10

[:, :, 2] =
 11  13  15  17  19
 12  14  16  18  20

[:, :, 3] =
 21  23  25  27  29
 22  24  26  28  30

julia> f(x::Matrix) = fill(x[1,1], 1,4);  # 1×4 행렬을 반환합니다.

julia> B = mapslices(f, A, dims=(1,2))
1×4×3 Array{Int64, 3}:
[:, :, 1] =
 1  1  1  1

[:, :, 2] =
 11  11  11  11

[:, :, 3] =
 21  21  21  21

julia> f2(x::AbstractMatrix) = fill(x[1,1], 1,4);

julia> B == stack(f2, eachslice(A, dims=3))
true

julia> g(x) = x[begin] // x[end-1];  # 숫자를 반환합니다.

julia> mapslices(g, A, dims=[1,3])
1×5×1 Array{Rational{Int64}, 3}:
[:, :, 1] =
 1//21  3//23  1//5  7//27  9//29

julia> map(g, eachslice(A, dims=2))
5-element Vector{Rational{Int64}}:
 1//21
 3//23
 1//5
 7//27
 9//29

julia> mapslices(sum, A; dims=(1,3)) == sum(A; dims=(1,3))
true

eachslice(A; dims=2)에서 지정된 차원은 슬라이스에서 콜론이 없는 차원입니다. 이는 view(A,:,i,:)인 반면, mapslices(f, A; dims=(1,3))는 A[:,i,:]를 사용합니다. 함수 f는 A에 영향을 주지 않고 슬라이스의 값을 변경할 수 있습니다.

source
Base.eachrow — Function
eachrow(A::AbstractVecOrMat) <: AbstractVector

행렬 또는 벡터 A의 행 벡터를 포함하는 RowSlices 객체를 생성합니다. 행 슬라이스는 A의 AbstractVector 뷰로 반환됩니다.

반대의 경우는 stack(rows; dims=1)을 참조하세요.

또한 eachcol, eachslice 및 mapslices도 참조하세요.

Julia 1.1

이 함수는 최소한 Julia 1.1이 필요합니다.

Julia 1.9

Julia 1.9 이전에는 이 함수가 이터레이터를 반환했습니다.

예제

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> s = eachrow(a)
2-element RowSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}}:
 [1, 2]
 [3, 4]

julia> s[1]
2-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2
source
Base.eachcol — Function
eachcol(A::AbstractVecOrMat) <: AbstractVector

ColumnSlices 객체를 생성하여 행렬 또는 벡터 A의 열 벡터를 만듭니다. 열 슬라이스는 A의 AbstractVector 뷰로 반환됩니다.

반대의 경우는 stack(cols) 또는 reduce(hcat, cols)를 참조하세요.

또한 eachrow, eachslice 및 mapslices도 참조하세요.

Julia 1.1

이 함수는 최소한 Julia 1.1이 필요합니다.

Julia 1.9

Julia 1.9 이전에는 이 함수가 이터레이터를 반환했습니다.

예제

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> s = eachcol(a)
2-element ColumnSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}}:
 [1, 3]
 [2, 4]

julia> s[1]
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3
source
Base.eachslice — Function
eachslice(A::AbstractArray; dims, drop=true)

Slices 객체를 생성하여 A의 dims 차원에 대한 슬라이스 배열을 만들고, A의 다른 차원에서 모든 데이터를 선택하는 뷰를 반환합니다. dims는 정수 또는 정수의 튜플일 수 있습니다.

drop = true(기본값)인 경우, 외부 Slices는 내부 차원을 제거하고, 차원의 순서는 dims에 있는 순서와 일치합니다. drop = false인 경우, Slices는 기본 배열과 동일한 차원 수를 가지며, 내부 차원의 크기는 1입니다.

eachslice(A; dims::Integer)의 역인 stack(slices; dims)를 참조하세요.

또한 eachrow, eachcol, mapslices 및 selectdim도 참조하세요.

Julia 1.1

이 함수는 최소한 Julia 1.1이 필요합니다.

Julia 1.9

Julia 1.9 이전에는 이 함수가 이터레이터를 반환했으며, 단일 차원 dims만 지원되었습니다.

예제

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

julia> s = eachslice(m, dims=1)
3-element RowSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}}:
 [1, 2, 3]
 [4, 5, 6]
 [7, 8, 9]

julia> s[1]
3-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2
 3

julia> eachslice(m, dims=1, drop=false)
3×1 Slices{Matrix{Int64}, Tuple{Int64, Colon}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}, 2}:
 [1, 2, 3]
 [4, 5, 6]
 [7, 8, 9]
source

Combinatorics

Base.invperm — Function
invperm(v)

v의 역순열을 반환합니다. 만약 B = A[v]라면, A == B[invperm(v)]입니다.

또한 sortperm, invpermute!, isperm, permutedims도 참조하세요.

예제

julia> p = (2, 3, 1);

julia> invperm(p)
(3, 1, 2)

julia> v = [2; 4; 3; 1];

julia> invperm(v)
4-element Vector{Int64}:
 4
 1
 3
 2

julia> A = ['a','b','c','d'];

julia> B = A[v]
4-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> B[invperm(v)]
4-element Vector{Char}:
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)
source
Base.isperm — Function
isperm(v) -> Bool

v가 유효한 순열이면 true를 반환합니다.

예시

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false
source
Base.permute! — Method
permute!(v, p)

벡터 v를 순열 p에 따라 제자리에서 변환합니다. p가 순열인지 확인하는 검사는 수행되지 않습니다.

새로운 순열을 반환하려면 v[p]를 사용하세요. 이는 일반적으로 permute!(v, p)보다 빠릅니다; u .= @view v[p]를 사용하여 미리 할당된 출력 배열에 쓰는 것이 더 빠릅니다. (permute!가 제자리에서 v를 덮어쓰더라도, 내부적으로 어떤 요소가 이동되었는지를 추적하기 위해 일부 할당이 필요합니다.)

!!! 경고 변형된 인수가 다른 인수와 메모리를 공유할 때 동작이 예기치 않게 될 수 있습니다.

자세한 내용은 invpermute!를 참조하세요.

예제

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

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

julia> permute!(A, perm);

julia> A
4-element Vector{Int64}:
 1
 4
 3
 1
source
Base.invpermute! — Function
invpermute!(v, p)

permute!와 유사하지만, 주어진 순열의 역이 적용됩니다.

미리 할당된 출력 배열이 있는 경우(예: u = similar(v)), 대신 u[p] = v를 사용하는 것이 더 빠릅니다. (invpermute!는 내부적으로 데이터의 복사본을 할당합니다.)

!!! 경고 변형된 인수가 다른 인수와 메모리를 공유할 경우 예상치 못한 동작이 발생할 수 있습니다.

예제

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

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

julia> invpermute!(A, perm);

julia> A
4-element Vector{Int64}:
 4
 1
 3
 1
source
Base.reverse — Method
reverse(A; dims=:)

dims에 따라 A를 반전시킵니다. dims는 정수(단일 차원), 정수의 튜플(차원의 튜플) 또는 :(모든 차원에서 반전, 기본값)일 수 있습니다. 제자리 반전을 위해 reverse!도 참조하십시오.

예제

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

julia> reverse(b, dims=2)
2×2 Matrix{Int64}:
 2  1
 4  3

julia> reverse(b)
2×2 Matrix{Int64}:
 4  3
 2  1
Julia 1.6

Julia 1.6 이전에는 reverse에서 단일 정수 dims만 지원됩니다.

source
Base.reverseind — Function
reverseind(v, i)

주어진 인덱스 i에 대해 reverse(v)에서 v의 해당 인덱스를 반환하여 v[reverseind(v,i)] == reverse(v)[i]가 성립하도록 합니다. (이는 v에 비ASCII 문자가 포함된 경우 비트리비얼할 수 있습니다.)

예제

julia> s = "Julia🚀"
"Julia🚀"

julia> r = reverse(s)
"🚀ailuJ"

julia> for i in eachindex(s)
           print(r[reverseind(r, i)])
       end
Julia🚀
source
Base.reverse! — Function
reverse!(v [, start=firstindex(v) [, stop=lastindex(v) ]]) -> v

reverse의 제자리 버전입니다.

예제

julia> A = Vector(1:5)
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> reverse!(A);

julia> A
5-element Vector{Int64}:
 5
 4
 3
 2
 1
source
reverse!(A; dims=:)

reverse와 유사하지만 A에서 제자리에서 작동합니다.

Julia 1.6

다차원 reverse!는 Julia 1.6이 필요합니다.

source