Linear Algebra

NoPivot

피벗이 수행되지 않습니다. LU 분해와 같은 행렬 분해는 피벗 없이 실패할 수 있으며, 반올림 오류에 직면한 부동 소수점 행렬에 대해 수치적으로 불안정할 수도 있습니다. 이 피벗 전략은 주로 교육적 목적에 유용합니다.

RowNonZero

남은 행에서 첫 번째 비영(非零) 요소가 피벗 요소로 선택됩니다.

부동 소수점 행렬의 경우, 결과 LU 알고리즘은 수치적으로 불안정하므로 주의해야 합니다. 이 전략은 주로 수작업 계산(일반적으로 이 전략을 사용함)이나 반올림 오류에 영향을 받지 않는 다른 대수적 유형(예: 유리수)과 비교하는 데 유용합니다. 그렇지 않으면, 가우스 소거법에서는 기본 RowMaximum 피벗 전략이 일반적으로 선호되어야 합니다.

행렬의 요소 유형은 iszero 메서드를 허용해야 합니다.

RowMaximum

남은 행에서 최대 크기의 요소가 피벗 요소로 선택됩니다. 이것은 부동 소수점 행렬의 LU 분해에 대한 기본 전략이며, 때때로 "부분 피벗팅" 알고리즘이라고도 합니다.

행렬의 요소 유형은 abs 메서드를 허용해야 하며, 그 결과 유형은 < 메서드를 허용해야 합니다.

ColumnNorm

최대 노름을 가진 열이 이후 계산에 사용됩니다. 이는 피벗 QR 분해에 사용됩니다.

행렬의 요소 유형은 norm 및 abs 메서드를 허용해야 하며, 각 결과 유형은 < 메서드를 허용해야 합니다.

*(A::AbstractMatrix, B::AbstractMatrix)

행렬 곱셈.

예제

julia> [1 1; 0 1] * [1 0; 1 1]
2×2 Matrix{Int64}:
 2  1
 1  1

*(A, B::AbstractMatrix, C)
A * B * C * D

3개 또는 4개의 행렬의 연쇄 곱셈은 배열의 크기를 기반으로 가장 효율적인 순서로 수행됩니다. 즉, (A * B) * C (3개의 밀집 행렬을 사용)에서 필요한 스칼라 곱셈의 수는 A * (B * C)와 비교되어 이 중 어떤 것을 실행할지 선택합니다.

마지막 인자가 벡터이거나 첫 번째 인자가 전치된 벡터인 경우, 이러한 요소를 먼저 처리하는 것이 효율적입니다. 특히 x' * B * y는 일반적인 열 우선 B::Matrix에 대해 (x' * B) * y를 의미합니다. dot(x, B, y)와는 달리, 이는 중간 배열을 할당합니다.

첫 번째 또는 마지막 인자가 숫자인 경우, 이는 행렬 곱셈과 융합되어 5-인자 mul!를 사용합니다.

또한 muladd, dot를 참조하십시오.

\(A, B)

다항 알고리즘을 사용한 행렬 나누기. 입력 행렬 A와 B에 대해 결과 X는 A*X == B가 성립하도록 하며, A가 정사각형일 때 적용됩니다. 사용되는 솔버는 A의 구조에 따라 다릅니다. A가 상삼각형 또는 하삼각형(또는 대각선)인 경우, A의 인수분해가 필요 없으며 시스템은 전방 또는 후방 대체를 통해 해결됩니다. 비삼각형 정사각형 행렬의 경우, LU 인수분해가 사용됩니다.

직사각형 A의 경우 결과는 A의 피벗 QR 인수분해와 R 인수를 기반으로 한 A의 랭크 추정에 의해 계산된 최소-노름 최소 제곱 솔루션입니다.

A가 희소한 경우 유사한 다항 알고리즘이 사용됩니다. 비정방 행렬의 경우, LDLt 인수분해는 수치 인수분해 중 피벗팅을 사용하지 않으므로 절대 가역 행렬에 대해서도 절차가 실패할 수 있습니다.

참고: factorize, pinv.

예제

julia> A = [1 0; 1 -2]; B = [32; -4];

julia> X = A \ B
2-element Vector{Float64}:
 32.0
 18.0

julia> A * X == B
true

A / B

행렬 오른쪽 나누기: A / B는 (B' \ A')'와 동등하며, 여기서 \는 왼쪽 나누기 연산자입니다. 정방 행렬의 경우, 결과 X는 A == X*B를 만족합니다.

또한: rdiv!.

예제

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

SingularException

입력 행렬에 하나 이상의 0 값 고유값이 있을 때 발생하는 예외로, 비가역적입니다. 이러한 행렬을 포함하는 선형 방정식은 계산할 수 없습니다. info 필드는 (하나의) 특이 값의 위치를 나타냅니다.

PosDefException

입력 행렬이 양의 정부호이지 않을 때 발생하는 예외입니다. 일부 선형 대수 함수 및 분해는 양의 정부호 행렬에만 적용 가능합니다. info 필드는 0보다 작거나 같은 고유값 중 하나의 위치를 나타냅니다.

ZeroPivotException <: Exception

행렬 분해/해결 과정에서 피벗(대각선) 위치에 0이 발생하여 진행할 수 없을 때 발생하는 예외입니다. 이는 행렬이 특이하다는 것을 의미하지 않을 수 있습니다: 변수를 재배치하여 잘못된 0 피벗을 제거할 수 있는 피벗 LU와 같은 다른 분해로 전환하는 것이 유익할 수 있습니다. info 필드는 0 피벗 중 하나의 위치를 나타냅니다.

RankDeficientException

입력 행렬이 랭크 결핍일 때 발생하는 예외입니다. Cholesky 분해와 같은 일부 선형 대수 함수는 랭크 결핍이 아닌 행렬에만 적용됩니다. info 필드는 행렬의 계산된 랭크를 나타냅니다.

LAPACKException

일반 LAPACK 예외는 LAPACK 함수에 대한 직접 호출 중 또는 LAPACK 함수를 내부적으로 사용하는 다른 함수에 대한 호출 중에 발생하며, 이러한 함수는 전문화된 오류 처리가 부족합니다. info 필드는 기본 오류에 대한 추가 정보를 포함하며 호출된 LAPACK 함수에 따라 다릅니다.

dot(x, y)
x ⋅ y

두 벡터 간의 내적을 계산합니다. 복소 벡터의 경우, 첫 번째 벡터는 켤레화됩니다.

dot은 요소에 대해 dot이 정의되어 있는 한, 모든 차원의 배열을 포함한 임의의 반복 가능한 객체에서도 작동합니다.

dot은 의미적으로 sum(dot(vx,vy) for (vx,vy) in zip(x, y))와 동등하지만, 인수는 동일한 길이를 가져야 한다는 추가 제한이 있습니다.

x ⋅ y (여기서 ⋅는 REPL에서 \cdot를 탭 완성하여 입력할 수 있습니다)는 dot(x, y)의 동의어입니다.

예제

julia> dot([1; 1], [2; 3])
5

julia> dot([im; im], [1; 1])
0 - 2im

julia> dot(1:5, 2:6)
70

julia> x = fill(2., (5,5));

julia> y = fill(3., (5,5));

julia> dot(x, y)
150.0

dot(x, A, y)

두 벡터 x와 y 사이의 일반화된 내적 dot(x, A*y)를 계산하되, A*y의 중간 결과를 저장하지 않습니다. 두 인수 dot(_,_)와 마찬가지로, 이 함수는 재귀적으로 작동합니다. 또한, 복소 벡터의 경우 첫 번째 벡터는 켤레화됩니다.

예제

julia> dot([1; 1], [1 2; 3 4], [2; 3])
26

julia> dot(1:5, reshape(1:25, 5, 5), 2:6)
4850

julia> ⋅(1:5, reshape(1:25, 5, 5), 2:6) == dot(1:5, reshape(1:25, 5, 5), 2:6)
true

cross(x, y)
×(x,y)

두 3-벡터의 외적을 계산합니다.

예제

julia> a = [0;1;0]
3-element Vector{Int64}:
 0
 1
 0

julia> b = [0;0;1]
3-element Vector{Int64}:
 0
 0
 1

julia> cross(a,b)
3-element Vector{Int64}:
 1
 0
 0

axpy!(α, x::AbstractArray, y::AbstractArray)

y를 x * α + y로 덮어쓰고 y를 반환합니다. x와 y가 동일한 축을 가지면, 이는 y .+= x .* a와 동등합니다.

예제

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

julia> y = [4; 5; 6];

julia> axpy!(2, x, y)
3-element Vector{Int64}:
  6
  9
 12

axpby!(α, x::AbstractArray, β, y::AbstractArray)

y를 x * α + y * β로 덮어쓰고 y를 반환합니다. x와 y가 동일한 축을 가지면, y .= x .* a .+ y .* β와 동일합니다.

예제

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

julia> y = [4; 5; 6];

julia> axpby!(2, x, 2, y)
3-element Vector{Int64}:
 10
 14
 18

rotate!(x, y, c, s)

x를 c*x + s*y로, y를 -conj(s)*x + c*y로 덮어씁니다. x와 y를 반환합니다.

reflect!(x, y, c, s)

x를 c*x + s*y로, y를 conj(s)*x - c*y로 덮어씁니다. x와 y를 반환합니다.

factorize(A)

입력 행렬의 유형에 따라 A의 편리한 인수 분해를 계산합니다. factorize는 A가 일반 행렬로 전달되면 대칭/삼각형/etc.인지 확인합니다. factorize는 A의 각 요소를 확인하여 각 속성을 검증/배제합니다. 대칭/삼각형 구조를 배제할 수 있는 즉시 단축 회로를 사용합니다. 반환 값은 여러 시스템을 효율적으로 해결하는 데 재사용할 수 있습니다. 예를 들어: A=factorize(A); x=A\b; y=A\C.

예를 들어 factorize가 에르미트 양의 정부호 행렬에 호출되면, factorize는 Cholesky 인수 분해를 반환합니다.

예제

julia> A = Array(Bidiagonal(fill(1.0, (5, 5)), :U))
5×5 Matrix{Float64}:
 1.0  1.0  0.0  0.0  0.0
 0.0  1.0  1.0  0.0  0.0
 0.0  0.0  1.0  1.0  0.0
 0.0  0.0  0.0  1.0  1.0
 0.0  0.0  0.0  0.0  1.0

julia> factorize(A) # factorize는 A가 이미 인수 분해되었는지 확인합니다
5×5 Bidiagonal{Float64, Vector{Float64}}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

이것은 이제 다른 선형 대수 함수(예: 고유값 해결기)에 전달될 수 있는 5×5 Bidiagonal{Float64}를 반환하며, 이 함수는 Bidiagonal 유형에 대한 특수화된 방법을 사용할 것입니다.

Diagonal(V::AbstractVector)

V를 대각선으로 하는 지연 행렬을 생성합니다.

지연 단위 행렬 I에 대한 UniformScaling, 조밀한 행렬을 만들기 위한 diagm, 대각선 요소를 추출하기 위한 diag도 참조하세요.

예제

julia> d = Diagonal([1, 10, 100])
3×3 Diagonal{Int64, Vector{Int64}}:
 1   ⋅    ⋅
 ⋅  10    ⋅
 ⋅   ⋅  100

julia> diagm([7, 13])
2×2 Matrix{Int64}:
 7   0
 0  13

julia> ans + I
2×2 Matrix{Int64}:
 8   0
 0  14

julia> I(2)
2×2 Diagonal{Bool, Vector{Bool}}:
 1  ⋅
 ⋅  1

julia> A = transpose([7.0 13.0])
2×1 transpose(::Matrix{Float64}) with eltype Float64:
  7.0
 13.0

julia> Diagonal(A)
1×1 Diagonal{Float64, Vector{Float64}}:
 7.0

Diagonal(A::AbstractMatrix)

행렬 A의 주 대각선으로부터 행렬을 구성합니다. 입력 행렬 A는 직사각형일 수 있지만, 출력은 정사각형이 됩니다.

예제

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

julia> D = Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  4

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

julia> Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  5

Diagonal{T}(undef, n)

길이 n의 초기화되지 않은 Diagonal{T}를 생성합니다. undef를 참조하세요.

Bidiagonal(dv::V, ev::V, uplo::Symbol) where V <: AbstractVector

주어진 대각선(dv) 및 비대각선(ev) 벡터를 사용하여 상부(uplo=:U) 또는 하부(uplo=:L) 이중 대각 행렬을 구성합니다. 결과는 Bidiagonal 유형이며 효율적인 특수 선형 솔버를 제공하지만, convert(Array, _) (또는 짧게 Array(_))를 사용하여 일반 행렬로 변환할 수 있습니다. ev의 길이는 dv의 길이보다 하나 적어야 합니다.

예제

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

julia> ev = [7, 8, 9]
3-element Vector{Int64}:
 7
 8
 9

julia> Bu = Bidiagonal(dv, ev, :U) # ev는 첫 번째 초대각선에 있습니다.
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 ⋅  2  8  ⋅
 ⋅  ⋅  3  9
 ⋅  ⋅  ⋅  4

julia> Bl = Bidiagonal(dv, ev, :L) # ev는 첫 번째 아대각선에 있습니다.
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 7  2  ⋅  ⋅
 ⋅  8  3  ⋅
 ⋅  ⋅  9  4

Bidiagonal(A, uplo::Symbol)

주어진 행렬 A의 주 대각선과 첫 번째 초대각선(만약 uplo=:U인 경우) 또는 첫 번째 아랫대각선(만약 uplo=:L인 경우)으로부터 Bidiagonal 행렬을 생성합니다.

예제

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

julia> Bidiagonal(A, :U) # A의 주 대각선과 첫 번째 초대각선을 포함
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  1  ⋅  ⋅
 ⋅  2  2  ⋅
 ⋅  ⋅  3  3
 ⋅  ⋅  ⋅  4

julia> Bidiagonal(A, :L) # A의 주 대각선과 첫 번째 아랫대각선을 포함
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 2  2  ⋅  ⋅
 ⋅  3  3  ⋅
 ⋅  ⋅  4  4

SymTridiagonal(dv::V, ev::V) where V <: AbstractVector

대각선(dv)과 첫 번째 하위/상위 대각선(ev)으로부터 대칭 삼대각 행렬을 구성합니다. 결과는 SymTridiagonal 유형이며, 효율적인 특수 고유값 솔버를 제공하지만 convert(Array, _) (또는 짧게 Array(_))를 사용하여 일반 행렬로 변환할 수 있습니다.

SymTridiagonal 블록 행렬의 경우, dv의 요소는 대칭화됩니다. 인수 ev는 상위 대각선으로 해석됩니다. 하위 대각선의 블록은 해당 상위 대각선 블록의 (구현된) 전치입니다.

예제

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

julia> ev = [7, 8, 9]
3-element Vector{Int64}:
 7
 8
 9

julia> SymTridiagonal(dv, ev)
4×4 SymTridiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 7  2  8  ⋅
 ⋅  8  3  9
 ⋅  ⋅  9  4

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

julia> A[1,1]
2×2 Symmetric{Int64, Matrix{Int64}}:
 1  2
 2  4

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

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

SymTridiagonal(A::AbstractMatrix)

대칭 행렬 A의 대각선과 첫 번째 초대각선으로부터 대칭 삼대각 행렬을 구성합니다.

예제

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

julia> SymTridiagonal(A)
3×3 SymTridiagonal{Int64, Vector{Int64}}:
 1  2  ⋅
 2  4  5
 ⋅  5  6

julia> B = reshape([[1 2; 2 3], [1 2; 3 4], [1 3; 2 4], [1 2; 2 3]], 2, 2);

julia> SymTridiagonal(B)
2×2 SymTridiagonal{Matrix{Int64}, Vector{Matrix{Int64}}}:
 [1 2; 2 3]  [1 3; 2 4]
 [1 2; 3 4]  [1 2; 2 3]

Tridiagonal(dl::V, d::V, du::V) where V <: AbstractVector

첫 번째 하위 대각선, 대각선 및 첫 번째 상위 대각선으로부터 삼중 대각 행렬을 구성합니다. 결과는 Tridiagonal 유형이며 효율적인 특수 선형 솔버를 제공하지만 convert(Array, _) (또는 짧게 Array(_))를 사용하여 일반 행렬로 변환할 수 있습니다. dl 및 du의 길이는 d의 길이보다 하나 짧아야 합니다.

예제

julia> dl = [1, 2, 3];

julia> du = [4, 5, 6];

julia> d = [7, 8, 9, 0];

julia> Tridiagonal(dl, d, du)
4×4 Tridiagonal{Int64, Vector{Int64}}:
 7  4  ⋅  ⋅
 1  8  5  ⋅
 ⋅  2  9  6
 ⋅  ⋅  3  0

Tridiagonal(A)

행렬 A의 첫 번째 하삼각 대각선, 대각선 및 첫 번째 상삼각 대각선으로부터 삼대각 행렬을 구성합니다.

예제

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

julia> Tridiagonal(A)
4×4 Tridiagonal{Int64, Vector{Int64}}:
 1  2  ⋅  ⋅
 1  2  3  ⋅
 ⋅  2  3  4
 ⋅  ⋅  3  4

Symmetric(A::AbstractMatrix, uplo::Symbol=:U)

행렬 A의 상삼각형(만약 uplo = :U인 경우) 또는 하삼각형(만약 uplo = :L인 경우)의 Symmetric 뷰를 생성합니다.

Symmetric 뷰는 주로 실수 대칭 행렬에 유용하며, 이 행렬에 대해 특화된 알고리즘(예: 고유 문제 해결을 위한)이 Symmetric 타입에 대해 활성화됩니다. 더 일반적으로, 실수 행렬에 대해 Symmetric과 사실상 동등하지만 복소수 행렬에도 유용한 에르미트 행렬 A == A'에 대해서는 Hermitian(A)도 참조하십시오. (복소수 Symmetric 행렬은 지원되지만 특화된 알고리즘이 거의 없습니다.)

실수 행렬의 대칭 부분을 계산하거나, 더 일반적으로 실수 또는 복소수 행렬 A의 에르미트 부분 (A + A') / 2를 계산하려면 hermitianpart를 사용하십시오.

예제

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

julia> Supper = Symmetric(A)
3×3 Symmetric{Int64, Matrix{Int64}}:
 1  2  3
 2  5  6
 3  6  9

julia> Slower = Symmetric(A, :L)
3×3 Symmetric{Int64, Matrix{Int64}}:
 1  4  7
 4  5  8
 7  8  9

julia> hermitianpart(A)
3×3 Hermitian{Float64, Matrix{Float64}}:
 1.0  3.0  5.0
 3.0  5.0  7.0
 5.0  7.0  9.0

Supper는 A가 대칭 행렬(예: A == transpose(A))이 아닌 한 Slower와 같지 않음을 유의하십시오.

Hermitian(A::AbstractMatrix, uplo::Symbol=:U)

행렬 A의 상삼각형(만약 uplo = :U인 경우) 또는 하삼각형(만약 uplo = :L인 경우)의 Hermitian 뷰를 생성합니다.

A의 Hermitian 부분을 계산하려면 hermitianpart를 사용하세요.

예제

julia> A = [1 2+2im 3-3im; 4 5 6-6im; 7 8+8im 9]
3×3 Matrix{Complex{Int64}}:
 1+0im  2+2im  3-3im
 4+0im  5+0im  6-6im
 7+0im  8+8im  9+0im

julia> Hupper = Hermitian(A)
3×3 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
 1+0im  2+2im  3-3im
 2-2im  5+0im  6-6im
 3+3im  6+6im  9+0im

julia> Hlower = Hermitian(A, :L)
3×3 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
 1+0im  4+0im  7+0im
 4+0im  5+0im  8-8im
 7+0im  8+8im  9+0im

julia> hermitianpart(A)
3×3 Hermitian{ComplexF64, Matrix{ComplexF64}}:
 1.0+0.0im  3.0+1.0im  5.0-1.5im
 3.0-1.0im  5.0+0.0im  7.0-7.0im
 5.0+1.5im  7.0+7.0im  9.0+0.0im

Hupper는 A가 자체적으로 Hermitian이 아닌 한 Hlower와 같지 않습니다(예: A == adjoint(A)인 경우).

대각선의 모든 비실수 부분은 무시됩니다.

Hermitian(fill(complex(1,1), 1, 1)) == fill(1, 1, 1)

LowerTriangular(A::AbstractMatrix)

행렬 A의 LowerTriangular 뷰를 생성합니다.

예제

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> LowerTriangular(A)
3×3 LowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅    ⋅
 4.0  5.0   ⋅
 7.0  8.0  9.0

UpperTriangular(A::AbstractMatrix)

행렬 A의 UpperTriangular 뷰를 생성합니다.

예제

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> UpperTriangular(A)
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 1.0  2.0  3.0
  ⋅   5.0  6.0
  ⋅    ⋅   9.0

UnitLowerTriangular(A::AbstractMatrix)

행렬 A의 UnitLowerTriangular 뷰를 생성합니다. 이러한 뷰는 A의 eltype의 oneunit을 대각선에 가집니다.

예제

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> UnitLowerTriangular(A)
3×3 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅    ⋅
 4.0  1.0   ⋅
 7.0  8.0  1.0

UnitUpperTriangular(A::AbstractMatrix)

행렬 A의 UnitUpperTriangular 뷰를 생성합니다. 이러한 뷰는 A의 eltype의 oneunit을 대각선에 가집니다.

예제

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> UnitUpperTriangular(A)
3×3 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  2.0  3.0
  ⋅   1.0  6.0
  ⋅    ⋅   1.0

UpperHessenberg(A::AbstractMatrix)

행렬 A의 UpperHessenberg 뷰를 생성합니다. 첫 번째 부대각선 아래의 A의 항목은 무시됩니다.

H \ b, det(H) 및 유사한 것들에 대해 효율적인 알고리즘이 구현되어 있습니다.

유사한 상부 헤센베르크 행렬로 모든 행렬을 인수분해하는 hessenberg 함수도 참조하십시오.

F::Hessenberg가 인수분해 객체인 경우, 유니타리 행렬은 F.Q로 접근할 수 있으며, 헤센베르크 행렬은 F.H로 접근할 수 있습니다. Q가 추출되면 결과 유형은 HessenbergQ 객체가 되며, convert(Array, _) (또는 짧게 Array(_))를 사용하여 일반 행렬로 변환할 수 있습니다.

분해를 반복하면 인수 F.Q와 F.H가 생성됩니다.

예제

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

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

UniformScaling{T<:Number}

스칼라와 항등 연산자 λ*I의 곱으로 정의된 일반 크기의 균일 스케일링 연산자입니다. 명시적인 size가 없지만, 많은 경우에 행렬처럼 작동하며 일부 인덱싱을 지원합니다. I도 참조하십시오.

예제

julia> J = UniformScaling(2.)
UniformScaling{Float64}
2.0*I

julia> A = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> J*A
2×2 Matrix{Float64}:
 2.0  4.0
 6.0  8.0

julia> J[1:2, 1:2]
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0

I

UniformScaling 유형의 객체로, 임의의 크기의 단위 행렬을 나타냅니다.

예제

julia> fill(1, (5,6)) * I == fill(1, (5,6))
true

julia> [1 2im 3; 1im 2 3] * I
2×3 Matrix{Complex{Int64}}:
 1+0im  0+2im  3+0im
 0+1im  2+0im  3+0im

(I::UniformScaling)(n::Integer)

UniformScaling에서 Diagonal 행렬을 생성합니다.

예제

julia> I(3)
3×3 Diagonal{Bool, Vector{Bool}}:
 1  ⋅  ⋅
 ⋅  1  ⋅
 ⋅  ⋅  1

julia> (0.7*I)(3)
3×3 Diagonal{Float64, Vector{Float64}}:
 0.7   ⋅    ⋅
  ⋅   0.7   ⋅
  ⋅    ⋅   0.7

LinearAlgebra.Factorization

행렬 분해(matrix factorizations를 위한 추상 타입입니다. 사용 가능한 행렬 분해 목록은 온라인 문서를 참조하세요.

LU <: Factorization

정방 행렬 A의 LU 분해의 행렬 분해 유형입니다. 이는 해당 행렬 분해 함수인 lu의 반환 유형입니다.

분해 F::LU의 개별 구성 요소는 getproperty를 통해 접근할 수 있습니다:

분해를 반복하면 구성 요소 F.L, F.U, 및 F.p가 생성됩니다.

예제

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

julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

julia> F.L * F.U == A[F.p, :]
true

julia> l, u, p = lu(A); # 반복을 통한 구조 분해

julia> l == F.L && u == F.U && p == F.p
true

lu(A::AbstractSparseMatrixCSC; check = true, q = nothing, control = get_umfpack_control()) -> F::UmfpackLU

희소 행렬 A의 LU 분해를 계산합니다.

실수 또는 복소수 요소 유형을 가진 희소 A의 경우, F의 반환 유형은 UmfpackLU{Tv, Ti}이며, 여기서 Tv는 Float64 또는 ComplexF64이고, Ti는 정수 유형 (Int32 또는 Int64)입니다.

check = true일 때, 분해가 실패하면 오류가 발생합니다. check = false일 때, 분해의 유효성을 확인하는 책임은 사용자에게 있습니다 (via issuccess).

치환 q는 치환 벡터이거나 nothing일 수 있습니다. 치환 벡터가 제공되지 않거나 q가 nothing인 경우, UMFPACK의 기본값이 사용됩니다. 치환이 0 기반이 아닐 경우, 0 기반 복사가 이루어집니다.

control 벡터는 UMFPACK에 대한 Julia SparseArrays 패키지의 기본 구성으로 기본값이 설정됩니다 (참고: 이는 반복 정제를 비활성화하기 위해 UMFPACK 기본값에서 수정됨), 그러나 UMFPACK_CONTROL 길이의 벡터를 전달하여 변경할 수 있습니다. 가능한 구성에 대해서는 UMFPACK 매뉴얼을 참조하십시오. 예를 들어 반복 정제를 다시 활성화하려면:

umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # Float64 희소 행렬에 대한 Julia 기본 구성 읽기
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # 선택 사항 - 값 표시
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # 반복 정제 다시 활성화 (2는 UMFPACK 기본 최대 반복 정제 단계)

Alu = lu(A; control = umfpack_control)
x = Alu \ b   # Ax = b를 해결하며, UMFPACK 반복 정제를 포함

분해 F의 개별 구성 요소는 인덱싱하여 접근할 수 있습니다:

F와 A 간의 관계는 다음과 같습니다.

F.L*F.U == (F.Rs .* A)[F.p, F.q]

F는 다음 함수를 추가로 지원합니다:

• \
• det

또한 lu!를 참조하십시오.

lu(A, pivot = RowMaximum(); check = true, allowsingular = false) -> F::LU

행렬 A의 LU 분해를 계산합니다.

check = true일 때, 분해가 실패하면 오류가 발생합니다. check = false일 때, 분해의 유효성을 확인하는 책임은 사용자에게 있습니다 (via issuccess).

기본적으로, check = true일 때, 분해가 유효한 요소를 생성하더라도 상삼각 행렬 U가 랭크 결핍인 경우에도 오류가 발생합니다. 이는 allowsingular = true를 전달하여 변경할 수 있습니다.

대부분의 경우, A가 AbstractMatrix{T}의 하위 유형 S이고 요소 유형 T가 +, -, * 및 /를 지원하는 경우, 반환 유형은 LU{T,S{T}}입니다.

일반적으로 LU 분해는 행렬의 행을 순열하는 것을 포함하며 (아래에 설명된 F.p 출력에 해당), 이를 "피벗팅"이라고 합니다 (이는 "피벗"이 포함된 행, 즉 F.U의 대각선 항목을 선택하는 것과 관련이 있습니다). 다음의 피벗팅 전략 중 하나를 선택할 수 있습니다:

• RowMaximum() (기본값): 표준 피벗팅 전략; 피벗은 남아 있는, 분해될 행 중 최대 절대값을 가지는 요소에 해당합니다. 이 피벗팅 전략은 요소 유형이 abs 및 <도 지원해야 합니다. (이는 일반적으로 부동 소수점 행렬에 대해 유일하게 수치적으로 안정적인 옵션입니다.)
• RowNonZero(): 피벗은 남아 있는, 분해될 행 중 첫 번째 비영(非零) 요소에 해당합니다. (이는 수작업 계산에서 일반적인 선택에 해당하며, iszero를 지원하지만 abs 또는 <를 지원하지 않는 보다 일반적인 대수적 수 유형에도 유용합니다.)
• NoPivot(): 피벗팅이 꺼집니다 (피벗 위치에서 0 항목이 발견되면 실패하며, allowsingular = true일 때도 마찬가지입니다).

분해 F의 개별 구성 요소는 getproperty를 통해 접근할 수 있습니다:

분해를 반복하면 구성 요소 F.L, F.U, 및 F.p가 생성됩니다.

F와 A의 관계는 다음과 같습니다.

F.L*F.U == A[F.p, :]

F는 다음 함수를 추가로 지원합니다:

예제

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

julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

julia> F.L * F.U == A[F.p, :]
true

julia> l, u, p = lu(A); # 반복을 통한 구조 분해

julia> l == F.L && u == F.U && p == F.p
true

julia> lu([1 2; 1 2], allowsingular = true)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0  0.0
 1.0  1.0
U factor (rank-deficient):
2×2 Matrix{Float64}:
 1.0  2.0
 0.0  0.0

lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC; check=true, reuse_symbolic=true, q=nothing) -> F::UmfpackLU

희소 행렬 A의 LU 분해를 계산하며, 이미 존재하는 LU 분해가 저장된 F의 기호 분해를 재사용합니다. reuse_symbolic이 false로 설정되지 않는 한, 희소 행렬 A는 LU 분해 F를 생성하는 데 사용된 행렬과 동일한 비영(非零) 패턴을 가져야 하며, 그렇지 않으면 오류가 발생합니다. A와 F의 크기가 다르면 모든 벡터가 그에 맞게 크기가 조정됩니다.

check = true일 때, 분해가 실패하면 오류가 발생합니다. check = false일 때, 분해의 유효성을 확인하는 책임은 사용자에게 있습니다 (via issuccess).

순열 q는 순열 벡터이거나 nothing일 수 있습니다. 순열 벡터가 제공되지 않거나 q가 nothing인 경우, UMFPACK의 기본값이 사용됩니다. 순열이 0 기반이 아닐 경우, 0 기반 복사가 이루어집니다.

자세한 내용은 lu를 참조하십시오.

예제

julia> A = sparse(Float64[1.0 2.0; 0.0 3.0]);

julia> F = lu(A);

julia> B = sparse(Float64[1.0 1.0; 0.0 1.0]);

julia> lu!(F, B);

julia> F \ ones(2)
2-element Vector{Float64}:
 0.0
 1.0

lu!(A, pivot = RowMaximum(); check = true, allowsingular = false) -> LU

lu!는 lu와 동일하지만 입력 A를 덮어써서 공간을 절약합니다. 인수 분해가 A의 요소 유형으로 표현할 수 없는 숫자를 생성하는 경우, 예를 들어 정수 유형의 경우, InexactError 예외가 발생합니다.

예제

julia> A = [4. 3.; 6. 3.]
2×2 Matrix{Float64}:
 4.0  3.0
 6.0  3.0

julia> F = lu!(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L 인자:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U 인자:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

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

julia> lu!(iA)
ERROR: InexactError: Int64(0.6666666666666666)
Stacktrace:
[...]

Cholesky <: Factorization

밀집 대칭/에르미트 양의 정부호 행렬 A의 Cholesky 분해의 행렬 분해 유형입니다. 이는 해당 행렬 분해 함수인 cholesky의 반환 유형입니다.

삼각형 Cholesky 인자는 분해 F::Cholesky에서 F.L 및 F.U를 통해 얻을 수 있으며, 여기서 A ≈ F.U' * F.U ≈ F.L * F.L'입니다.

Cholesky 객체에 대해 사용할 수 있는 함수는 size, \, inv, det, logdet 및 isposdef입니다.

분해를 반복하면 구성 요소 L과 U가 생성됩니다.

예제

julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
3×3 Matrix{Float64}:
   4.0   12.0  -16.0
  12.0   37.0  -43.0
 -16.0  -43.0   98.0

julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U factor:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.U
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.L
3×3 LowerTriangular{Float64, Matrix{Float64}}:
  2.0   ⋅    ⋅
  6.0  1.0   ⋅
 -8.0  5.0  3.0

julia> C.L * C.U == A
true

julia> l, u = C; # destructuring via iteration

julia> l == C.L && u == C.U
true

CholeskyPivoted

밀집 대칭/허미티안 양의 준정칙 행렬 A의 피벗된 콜레스키 분해의 행렬 분해 유형입니다. 이는 cholesky(_, ::RowMaximum)에서 반환되는 유형으로, 해당 행렬 분해 함수입니다.

삼각형 콜레스키 인자는 F::CholeskyPivoted 분해에서 F.L 및 F.U를 통해 얻을 수 있으며, 순열은 F.p를 통해 얻을 수 있습니다. 여기서 A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr'이며, Ur = F.U[1:F.rank, :] 및 Lr = F.L[:, 1:F.rank]로 정의됩니다. 또는 대안으로 A ≈ Up' * Up ≈ Lp * Lp'이며, 여기서 Up = F.U[1:F.rank, invperm(F.p)] 및 Lp = F.L[invperm(F.p), 1:F.rank]로 정의됩니다.

다음 함수들이 CholeskyPivoted 객체에 대해 사용 가능합니다: size, \, inv, det, 및 rank.

분해를 반복하면 구성 요소 L과 U가 생성됩니다.

예제

julia> X = [1.0, 2.0, 3.0, 4.0];

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
permutation:
4-element Vector{Int64}:
 4
 2
 3
 1

julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true

julia> l, u = C; # destructuring via iteration

julia> l == C.L && u == C.U
true

cholesky(A, NoPivot(); check = true) -> Cholesky

밀집 대칭 양의 정부호 행렬 A의 Cholesky 분해를 계산하고 Cholesky 분해를 반환합니다. 행렬 A는 Symmetric 또는 Hermitian AbstractMatrix일 수 있으며, 완벽하게 대칭 또는 에르미트 AbstractMatrix일 수 있습니다.

삼각형 Cholesky 인자는 분해 F에서 F.L 및 F.U를 통해 얻을 수 있으며, 여기서 A ≈ F.U' * F.U ≈ F.L * F.L'입니다.

Cholesky 객체에 대해 사용할 수 있는 함수는 size, \, inv, det, logdet 및 isposdef입니다.

구성 과정에서 반올림 오류로 인해 약간 비에르미트인 행렬 A가 있는 경우, cholesky에 전달하기 전에 Hermitian(A)로 감싸서 완벽한 에르미트로 처리하십시오.

check = true일 때 분해가 실패하면 오류가 발생합니다. check = false일 때 분해의 유효성을 확인하는 책임은 사용자에게 있습니다( issuccess 사용).

예제

julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
3×3 Matrix{Float64}:
   4.0   12.0  -16.0
  12.0   37.0  -43.0
 -16.0  -43.0   98.0

julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U 인자:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.U
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.L
3×3 LowerTriangular{Float64, Matrix{Float64}}:
  2.0   ⋅    ⋅
  6.0  1.0   ⋅
 -8.0  5.0  3.0

julia> C.L * C.U == A
true

cholesky(A, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

밀집 대칭 양의 준정칙 행렬 A의 피벗된 Cholesky 분해를 계산하고 CholeskyPivoted 분해를 반환합니다. 행렬 A는 Symmetric 또는 Hermitian AbstractMatrix일 수 있으며, 완벽하게 대칭 또는 허미티안 AbstractMatrix일 수 있습니다.

삼각형 Cholesky 인자는 분해 F에서 F.L 및 F.U를 통해 얻을 수 있으며, 순열은 F.p를 통해 얻을 수 있습니다. 여기서 A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr'이며, Ur = F.U[1:F.rank, :] 및 Lr = F.L[:, 1:F.rank]입니다. 또는 대안으로 A ≈ Up' * Up ≈ Lp * Lp'이며, Up = F.U[1:F.rank, invperm(F.p)] 및 Lp = F.L[invperm(F.p), 1:F.rank]입니다.

다음 함수는 CholeskyPivoted 객체에 대해 사용할 수 있습니다: size, \, inv, det, 및 rank.

인자 tol은 랭크를 결정하기 위한 허용 오차를 결정합니다. 음수 값의 경우, 허용 오차는 기계 정밀도입니다.

구성 과정에서 반올림 오류로 인해 약간 비허미티안인 행렬 A가 있는 경우, cholesky에 전달하기 전에 Hermitian(A)로 감싸서 완벽한 허미티안으로 처리하십시오.

check = true일 때, 분해가 실패하면 오류가 발생합니다. check = false일 때, 분해의 유효성을 확인하는 책임( issuccess 사용)은 사용자에게 있습니다.

예제

julia> X = [1.0, 2.0, 3.0, 4.0];

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U 인자는 랭크 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
순열:
4-element Vector{Int64}:
 4
 2
 3
 1

julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true

julia> l, u = C; # 반복을 통한 구조 분해

julia> l == C.L && u == C.U
true

cholesky(A::SparseMatrixCSC; shift = 0.0, check = true, perm = nothing) -> CHOLMOD.Factor

희소 양의 정부호 행렬 A의 Cholesky 분해를 계산합니다. A는 SparseMatrixCSC 또는 SparseMatrixCSC의 Symmetric/Hermitian 뷰여야 합니다. A가 타입 태그가 없더라도 여전히 대칭 또는 에르미트여야 합니다. perm이 주어지지 않으면, 채우기 감소 순열이 사용됩니다. F = cholesky(A)는 F\b로 방정식 시스템을 해결하는 데 가장 자주 사용되지만, diag, det, 및 logdet와 같은 메서드도 F에 대해 정의되어 있습니다. F에서 개별 요소를 추출할 수도 있으며, F.L을 사용할 수 있습니다. 그러나 피벗이 기본적으로 활성화되어 있기 때문에, 분해는 내부적으로 A == P'*L*L'*P로 표현되며, 여기서 P는 순열 행렬입니다. P를 고려하지 않고 단순히 L을 사용하면 잘못된 결과가 나옵니다. 순열의 효과를 포함하려면, 일반적으로 PtL = F.PtL(즉, P'*L) 및 LtP = F.UP(즉, L'*P)와 같은 "결합된" 요소를 추출하는 것이 바람직합니다.

check = true일 때, 분해가 실패하면 오류가 발생합니다. check = false일 때, 분해의 유효성을 확인하는 책임은 사용자에게 있습니다(즉, issuccess 사용).

선택적 shift 키워드 인수를 설정하면 A 대신 A+shift*I의 분해를 계산합니다. perm 인수가 제공되면, 이는 사용해야 할 순서를 제공하는 1:size(A,1)의 순열이어야 합니다(즉, CHOLMOD의 기본 AMD 순서 대신).

예제

다음 예제에서 사용된 채우기 감소 순열은 [3, 2, 1]입니다. perm이 1:3으로 설정되어 순열이 없도록 강제하면, 요소의 수는 6입니다.

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

julia> C = cholesky(sparse(A))
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  5
nnz:     5
success: true

julia> C.p
3-element Vector{Int64}:
 3
 2
 1

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421   0.0       0.0
 0.0       1.41421   0.0
 0.707107  0.707107  1.0

julia> L * L' ≈ A[C.p, C.p]
true

julia> P = sparse(1:3, C.p, ones(3))
3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
  ⋅    ⋅   1.0
  ⋅   1.0   ⋅
 1.0   ⋅    ⋅

julia> P' * L * L' * P ≈ A
true

julia> C = cholesky(sparse(A), perm=1:3)
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  6
nnz:     6
success: true

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421    0.0       0.0
 0.707107   1.22474   0.0
 0.707107  -0.408248  1.1547

julia> L * L' ≈ A
true

cholesky!(A::AbstractMatrix, NoPivot(); check = true) -> Cholesky

cholesky와 동일하지만, 입력 A를 복사하는 대신 덮어써서 공간을 절약합니다. 인수 분해가 A의 요소 유형으로 표현할 수 없는 숫자를 생성하는 경우, 예를 들어 정수 유형의 경우, InexactError 예외가 발생합니다.

예제

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

julia> cholesky!(A)
ERROR: InexactError: Int64(6.782329983125268)
Stacktrace:
[...]

cholesky!(A::AbstractMatrix, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

cholesky와 동일하지만, 복사본을 생성하는 대신 입력 A를 덮어써서 공간을 절약합니다. 인수 분해가 A의 요소 유형으로 표현할 수 없는 숫자를 생성하는 경우, 예를 들어 정수 유형의 경우 InexactError 예외가 발생합니다.

cholesky!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

A의 Cholesky ($LL'$) 분해를 계산하고, 기호 분해 F를 재사용합니다. A는 SparseMatrixCSC 또는 SparseMatrixCSC의 Symmetric/Hermitian 뷰여야 합니다. A가 타입 태그가 없더라도 여전히 대칭 또는 에르미트여야 합니다.

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

lowrankupdate(C::Cholesky, v::AbstractVector) -> CC::Cholesky

벡터 v로 Cholesky 분해 C를 업데이트합니다. 만약 A = C.U'C.U라면 CC = cholesky(C.U'C.U + v*v')이지만, CC의 계산은 O(n^2) 연산만 사용합니다.

lowrankupdate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

주어진 A의 LDLt 또는 LLt 분해 F에 대해 A + C*C'의 LDLt 분해를 가져옵니다.

반환된 인자는 항상 LDLt 분해입니다.

또한 lowrankupdate!, lowrankdowndate, lowrankdowndate!를 참조하십시오.

lowrankdowndate(C::Cholesky, v::AbstractVector) -> CC::Cholesky

Cholesky 분해 C를 벡터 v로 다운데이트합니다. 만약 A = C.U'C.U라면 CC = cholesky(C.U'C.U - v*v')이지만, CC의 계산은 O(n^2) 연산만 사용합니다.

lowrankdowndate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

주어진 A의 LDLt 또는 LLt 분해 F에 대해 A + C*C'의 LDLt 분해를 가져옵니다.

반환된 분해는 항상 LDLt 분해입니다.

또한 lowrankdowndate!, lowrankupdate, lowrankupdate!를 참조하십시오.

lowrankupdate!(C::Cholesky, v::AbstractVector) -> CC::Cholesky

벡터 v로 Cholesky 분해 C를 업데이트합니다. 만약 A = C.U'C.U라면 CC = cholesky(C.U'C.U + v*v')이지만, CC의 계산은 O(n^2) 연산만 사용합니다. 입력 분해 C는 제자리에서 업데이트되어 종료 시 C == CC가 됩니다. 벡터 v는 계산 중에 파괴됩니다.

lowrankupdate!(F::CHOLMOD.Factor, C::AbstractArray)

A의 LDLt 또는 LLt 분해 F를 A + C*C'의 분해로 업데이트합니다.

LLt 분해는 LDLt로 변환됩니다.

자세한 내용은 lowrankupdate, lowrankdowndate, lowrankdowndate!를 참조하세요.

lowrankdowndate!(C::Cholesky, v::AbstractVector) -> CC::Cholesky

Cholesky 분해 C를 벡터 v로 다운데이트합니다. 만약 A = C.U'C.U라면 CC = cholesky(C.U'C.U - v*v')이지만, CC의 계산은 O(n^2) 연산만 사용합니다. 입력 분해 C는 제자리에서 업데이트되어 종료 시 C == CC가 됩니다. 벡터 v는 계산 중에 파괴됩니다.

lowrankdowndate!(F::CHOLMOD.Factor, C::AbstractArray)

A의 LDLt 또는 LLt 분해 F를 A - C*C'의 분해로 업데이트합니다.

LLt 분해는 LDLt로 변환됩니다.

자세한 내용은 lowrankdowndate, lowrankupdate, lowrankupdate!를 참조하세요.

LDLt <: Factorization

실수 SymTridiagonal 행렬 S의 LDLt 분해의 행렬 분해 유형으로, S = L*Diagonal(d)*L' 형태입니다. 여기서 L은 UnitLowerTriangular 행렬이고, d는 벡터입니다. LDLt 분해 F = ldlt(S)의 주요 용도는 선형 방정식 시스템 Sx = b를 F\b로 푸는 것입니다. 이는 해당 행렬 분해 함수인 ldlt의 반환 유형입니다.

분해 F::LDLt의 개별 구성 요소는 getproperty를 통해 접근할 수 있습니다:

예제

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0  1.0   ⋅
 1.0  4.0  2.0
  ⋅   2.0  5.0

julia> F = ldlt(S)
LDLt{Float64, SymTridiagonal{Float64, Vector{Float64}}}
L factor:
3×3 UnitLowerTriangular{Float64, SymTridiagonal{Float64, Vector{Float64}}}:
 1.0        ⋅         ⋅
 0.333333  1.0        ⋅
 0.0       0.545455  1.0
D factor:
3×3 Diagonal{Float64, Vector{Float64}}:
 3.0   ⋅        ⋅
  ⋅   3.66667   ⋅
  ⋅    ⋅       3.90909

ldlt(S::SymTridiagonal) -> LDLt

실수 대칭 삼중 대각 행렬 S의 LDLt (즉, $LDL^T$) 분해를 계산합니다. 여기서 S = L*Diagonal(d)*L'이며, L은 단위 하삼각 행렬이고 d는 벡터입니다. LDLt 분해 F = ldlt(S)의 주요 용도는 선형 방정식 시스템 Sx = b를 F\b로 푸는 것입니다.

유사하지만 피벗된 임의의 대칭 또는 에르미트 행렬의 분해에 대한 bunchkaufman도 참조하십시오.

예제

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0  1.0   ⋅
 1.0  4.0  2.0
  ⋅   2.0  5.0

julia> ldltS = ldlt(S);

julia> b = [6., 7., 8.];

julia> ldltS \ b
3-element Vector{Float64}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

julia> S \ b
3-element Vector{Float64}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

ldlt(A::SparseMatrixCSC; shift = 0.0, check = true, perm=nothing) -> CHOLMOD.Factor

희소 행렬 A의 $LDL'$ 분해를 계산합니다. A는 SparseMatrixCSC 또는 SparseMatrixCSC의 Symmetric/Hermitian 뷰여야 합니다. A가 타입 태그가 없더라도 여전히 대칭 또는 에르미트여야 합니다. 채우기 감소 순열이 사용됩니다. F = ldlt(A)는 시스템의 방정식 A*x = b를 F\b로 해결하는 데 가장 자주 사용됩니다. 반환된 분해 객체 F는 또한 diag, det, logdet, 및 inv 메서드를 지원합니다. F에서 개별 요소를 추출하려면 F.L을 사용하면 됩니다. 그러나 피벗이 기본적으로 활성화되어 있기 때문에, 분해는 내부적으로 A == P'*L*D*L'*P로 표현되며, 여기서 P는 순열 행렬입니다; P를 고려하지 않고 단순히 L을 사용하면 잘못된 결과가 나옵니다. 순열의 효과를 포함하려면, 일반적으로 PtL = F.PtL (즉, P'*L에 해당) 및 LtP = F.UP (즉, L'*P에 해당)와 같은 "결합된" 요소를 추출하는 것이 바람직합니다. 지원되는 요소의 전체 목록은 :L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP입니다.

check = true일 때, 분해가 실패하면 오류가 발생합니다. check = false일 때, 분해의 유효성을 확인하는 책임은 사용자에게 있습니다 (via issuccess).

선택적 shift 키워드 인수를 설정하면 A 대신 A+shift*I의 분해를 계산합니다. perm 인수가 제공되면, 이는 사용해야 할 순서를 제공하는 1:size(A,1)의 순열이어야 합니다 (CHOLMOD의 기본 AMD 순서 대신).

ldlt!(S::SymTridiagonal) -> LDLt

ldlt와 동일하지만, 입력 S를 덮어써서 복사본을 생성하는 대신 공간을 절약합니다.

예제

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0  1.0   ⋅
 1.0  4.0  2.0
  ⋅   2.0  5.0

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

julia> S
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0       0.333333   ⋅
 0.333333  3.66667   0.545455
  ⋅        0.545455  3.90909

ldlt!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

A의 $LDL'$ 분해를 계산하며, 기호 분해 F를 재사용합니다. A는 SparseMatrixCSC 또는 SparseMatrixCSC의 Symmetric/Hermitian 뷰여야 합니다. A가 타입 태그가 없더라도 여전히 대칭 또는 에르미트여야 합니다.

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

QR <: Factorization

QR 행렬 분해는 일반적으로 qr에서 얻은 압축 형식으로 저장됩니다. 만약 $A$가 m×n 행렬이라면

\[A = Q R\]

여기서 $Q$는 직교/유니타리 행렬이고 $R$은 상삼각 행렬입니다. 행렬 $Q$는 Householder 반사기 $v_i$와 계수 $\tau_i$의 시퀀스로 저장됩니다:

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T).\]

분해를 반복하면 구성 요소 Q와 R이 생성됩니다.

객체에는 두 개의 필드가 있습니다:

• factors는 m×n 행렬입니다.

  • 상삼각 부분은 $R$의 요소를 포함하며, 즉 R = triu(F.factors)는 QR 객체 F에 대해 성립합니다.
  • 하대각선 부분은 압축 형식으로 저장된 반사기 $v_i$를 포함하며, 여기서 $v_i$는 행렬 V = I + tril(F.factors, -1)의 $i$번째 열입니다.

• τ는 길이가 min(m,n)인 벡터로, 계수 $au_i$를 포함합니다.

QRCompactWY <: Factorization

QR 행렬 분해는 일반적으로 qr에서 얻어진 압축 블록 형식으로 저장됩니다. 만약 $A$가 m×n 행렬이라면

\[A = Q R\]

여기서 $Q$는 직교/유니타리 행렬이고 $R$은 상삼각형입니다. 이는 QR 형식과 유사하지만, 직교/유니타리 행렬 $Q$가 Compact WY 형식으로 저장됩니다 ^{[Schreiber1989]}. 블록 크기 $n_b$에 대해, 이는 m×n 하사다리꼴 행렬 $V$와 $b = \lceil \min(m,n) / n_b \rceil$ 개의 크기 $n_b$×$n_b$ 상삼각형 행렬 $T_j$로 구성된 행렬 $T = (T_1 \; T_2 \; ... \; T_{b-1} \; T_b')$로 저장됩니다 ($j = 1, ..., b-1$) 및 상하사다리꼴 $n_b$×$\min(m,n) - (b-1) n_b$ 행렬 $T_b'$ ($j=b$)로, 그 상단 정사각형 부분은 $T_b$로 표시되며 다음을 만족합니다.

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T) = \prod_{j=1}^{b} (I - V_j T_j V_j^T)\]

여기서 $v_i$는 $V$의 $i$번째 열, $\tau_i$는 [diag(T_1); diag(T_2); …; diag(T_b)]의 $i$번째 요소이며, $(V_1 \; V_2 \; ... \; V_b)$는 $V$의 왼쪽 m×min(m, n) 블록입니다. qr로 구성할 때, 블록 크기는 $n_b = \min(m, n, 36)$로 주어집니다.

분해를 반복하면 구성 요소 Q와 R이 생성됩니다.

객체에는 두 개의 필드가 있습니다:

• factors, QR 유형과 같이, m×n 행렬입니다.

  • 상삼각형 부분에는 $R$의 요소가 포함되어 있으며, 즉 R = triu(F.factors)는 QR 객체 F에 대해 성립합니다.
  • 하대각선 부분에는 패킹 형식으로 저장된 반사기 $v_i$가 포함되어 있으며, V = I + tril(F.factors, -1)입니다.

• T는 위에서 설명한 대로 $n_b$-by-$\min(m,n)$ 행렬입니다. 각 삼각형 행렬 $T_j$의 하대각선 요소는 무시됩니다.

QRPivoted <: Factorization

열 피벗이 있는 QR 행렬 분해로, 일반적으로 qr에서 얻은 압축 형식입니다. 만약 $A$가 m×n 행렬이라면

\[A P = Q R\]

여기서 $P$는 순열 행렬, $Q$는 직교/유니타리 행렬이며 $R$은 상삼각 행렬입니다. 행렬 $Q$는 하우스홀더 반사기의 시퀀스로 저장됩니다:

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T).\]

분해를 반복하면 구성 요소 Q, R, 및 p가 생성됩니다.

객체는 세 개의 필드를 가집니다:

• factors는 m×n 행렬입니다.

  • 상삼각 부분은 $R$의 요소를 포함하며, 즉 R = triu(F.factors)는 QR 객체 F에 대해 성립합니다.
  • 하대각선 부분은 압축 형식으로 저장된 반사기 $v_i$를 포함하며, 여기서 $v_i$는 행렬 V = I + tril(F.factors, -1)의 $i$번째 열입니다.

• τ는 길이 min(m,n)의 벡터로, 계수 $au_i$를 포함합니다.

• jpvt는 순열 $P$에 해당하는 길이 n의 정수 벡터입니다.

qr(A::SparseMatrixCSC; tol=_default_tol(A), ordering=ORDERING_DEFAULT) -> QRSparse

희소 행렬 A의 QR 분해를 계산합니다. F.R = F.Q'*A[F.prow,F.pcol]가 되도록 행과 열의 채우기 감소 순열이 사용됩니다. 이 유형의 주요 응용 프로그램은 \를 사용하여 최소 제곱 또는 미결정 문제를 해결하는 것입니다. 이 함수는 C 라이브러리 SPQR^[ACM933]를 호출합니다.

예제

julia> A = sparse([1,2,3,4], [1,1,2,2], [1.0,1.0,1.0,1.0])
4×2 SparseMatrixCSC{Float64, Int64} with 4 stored entries:
 1.0   ⋅
 1.0   ⋅
  ⋅   1.0
  ⋅   1.0

julia> qr(A)
SparseArrays.SPQR.QRSparse{Float64, Int64}
Q factor:
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
R factor:
2×2 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
 -1.41421    ⋅
   ⋅       -1.41421
Row permutation:
4-element Vector{Int64}:
 1
 3
 4
 2
Column permutation:
2-element Vector{Int64}:
 1
 2

qr(A, pivot = NoPivot(); blocksize) -> F

행렬 A의 QR 분해를 계산합니다: 직교(또는 A가 복소수 값일 경우 유니타리) 행렬 Q와 상삼각 행렬 R이 있어 다음과 같은 관계를 만족합니다.

\[A = Q R\]

반환된 객체 F는 패킹된 형식으로 분해를 저장합니다:

• pivot == ColumnNorm()인 경우 F는 QRPivoted 객체입니다.
• 그렇지 않고 A의 요소 유형이 BLAS 유형(Float32, Float64, ComplexF32 또는 ComplexF64)인 경우, F는 QRCompactWY 객체입니다.
• 그렇지 않으면 F는 QR 객체입니다.

분해의 개별 구성 요소 F는 속성 접근자를 통해 검색할 수 있습니다:

• F.Q: 직교/유니타리 행렬 Q
• F.R: 상삼각 행렬 R
• F.p: 피벗의 순열 벡터 (QRPivoted 전용)
• F.P: 피벗의 순열 행렬 (QRPivoted 전용)

분해를 반복하면 구성 요소 Q, R, 그리고 존재하는 경우 p를 생성합니다.

QR 객체에 대해 사용할 수 있는 함수는 다음과 같습니다: inv, size, 및 \. A가 직사각형인 경우, \는 최소 제곱 해를 반환하며, 해가 유일하지 않은 경우 가장 작은 노름을 가진 해가 반환됩니다. A가 풀 랭크가 아닐 경우, 최소 노름 해를 얻기 위해 (열) 피벗을 사용한 분해가 필요합니다.

전체/정사각형 또는 비전체/비정사각형 Q에 대한 곱셈이 허용됩니다. 즉, F.Q*F.R와 F.Q*A 모두 지원됩니다. Q 행렬은 Matrix로 일반 행렬로 변환할 수 있습니다. 이 작업은 "얇은" Q 요소를 반환합니다. 즉, A가 m×n이고 m>=n인 경우, Matrix(F.Q)는 직교 정규 열을 가진 m×n 행렬을 생성합니다. "전체" Q 요소를 검색하려면 F.Q*I 또는 collect(F.Q)를 사용하십시오. m<=n인 경우, Matrix(F.Q)는 m×m 직교 행렬을 생성합니다.

QR 분해를 위한 블록 크기는 pivot == NoPivot()이고 A isa StridedMatrix{<:BlasFloat}일 때 키워드 인수 blocksize :: Integer로 지정할 수 있습니다. blocksize > minimum(size(A))인 경우 무시됩니다. QRCompactWY를 참조하십시오.

예제

julia> A = [3.0 -6.0; 4.0 -8.0; 0.0 1.0]
3×2 Matrix{Float64}:
 3.0  -6.0
 4.0  -8.0
 0.0   1.0

julia> F = qr(A)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Q 요소: 3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R 요소:
2×2 Matrix{Float64}:
 -5.0  10.0
  0.0  -1.0

julia> F.Q * F.R == A
true

qr!(A, pivot = NoPivot(); blocksize)

qr!는 A가 AbstractMatrix의 하위 유형일 때 qr와 동일하지만, 입력 A를 덮어써서 공간을 절약합니다. 인수 분해가 A의 요소 유형으로 표현할 수 없는 숫자를 생성하는 경우, 예를 들어 정수 유형의 경우, InexactError 예외가 발생합니다.

예제

julia> a = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> qr!(a)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Q 인자: 2×2 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R 인자:
2×2 Matrix{Float64}:
 -3.16228  -4.42719
  0.0      -0.632456

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

julia> qr!(a)
ERROR: InexactError: Int64(3.1622776601683795)
Stacktrace:
[...]

LQ <: Factorization

행렬 A의 LQ 분해의 행렬 분해 유형입니다. LQ 분해는 transpose(A)의 QR 분해입니다. 이는 해당 행렬 분해 함수인 lq의 반환 유형입니다.

S::LQ가 분해 객체인 경우, 하삼각 성분은 S.L을 통해 얻을 수 있으며, 직교/단위 성분은 S.Q를 통해 얻을 수 있습니다. 따라서 A ≈ S.L*S.Q입니다.

분해를 반복하면 성분 S.L과 S.Q를 생성합니다.

예제

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}

julia> S.L * S.Q
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> l, q = S; # 반복을 통한 구조 분해

julia> l == S.L &&  q == S.Q
true

lq(A) -> S::LQ

A의 LQ 분해를 계산합니다. 분해의 하삼각형 구성 요소는 LQ 객체 S에서 S.L을 통해 얻을 수 있으며, 직교/유니타리 구성 요소는 S.Q를 통해 얻을 수 있습니다. 따라서 A ≈ S.L*S.Q입니다.

분해를 반복하면 구성 요소 S.L과 S.Q를 생성합니다.

LQ 분해는 transpose(A)의 QR 분해이며, 이는 과소정의 방정식 시스템에 대한 최소 노름 해 lq(A) \ b를 계산하는 데 유용합니다(A는 열이 행보다 많지만 전체 행 랭크를 가집니다).

예제

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}

julia> S.L * S.Q
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> l, q = S; # 반복을 통한 구조 분해

julia> l == S.L &&  q == S.Q
true

lq!(A) -> LQ

입력 행렬을 작업 공간으로 사용하여 A의 LQ 분해를 계산합니다. lq도 참조하십시오.

BunchKaufman <: Factorization

대칭 또는 에르미트 행렬 A의 Bunch-Kaufman 분해의 행렬 분해 유형으로, A에 상단(기본값) 또는 하단 삼각형이 저장되는지에 따라 P'UDU'P 또는 P'LDL'P로 표현됩니다. A가 복소수 대칭인 경우 U'와 L'는 비공액 전치(transpose)를 나타내며, 즉 각각 transpose(U)와 transpose(L)입니다. 이는 bunchkaufman 함수의 반환 유형입니다.

S::BunchKaufman이 분해 객체인 경우, 구성 요소는 S.uplo 및 S.p에 따라 적절하게 S.D, S.U 또는 S.L을 통해 얻을 수 있습니다.

분해를 반복하면 S.uplo 및 S.p에 따라 적절하게 S.D, S.U 또는 S.L 구성 요소가 생성됩니다.

예제

julia> A = Float64.([1 2; 2 3])
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  3.0

julia> S = bunchkaufman(A) # A는 내부적으로 Symmetric(A)로 래핑됩니다.
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D 인자:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U 인자:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
순열:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # 반복을 통한 구조 분해

julia> d == S.D && u == S.U && p == S.p
true

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D 인자:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L 인자:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
순열:
2-element Vector{Int64}:
 2
 1

bunchkaufman(A, rook::Bool=false; check = true) -> S::BunchKaufman

대칭 또는 에르미트 행렬 A의 Bunch-Kaufman ^[Bunch1977] 분해를 P'*U*D*U'*P 또는 P'*L*D*L'*P 형태로 계산하고, A에 저장된 삼각형에 따라 BunchKaufman 객체를 반환합니다. A가 복소수 대칭인 경우 U'와 L'는 비공액 전치(transpose)를 나타내며, 즉 transpose(U)와 transpose(L)입니다.

분해를 반복하면 S.uplo에 따라 적절한 구성 요소인 S.D, S.U 또는 S.L과 S.p를 생성합니다.

rook이 true이면, rook 피벗팅이 사용됩니다. rook이 false이면, rook 피벗팅이 사용되지 않습니다.

check = true일 때, 분해가 실패하면 오류가 발생합니다. check = false일 때, 분해의 유효성을 확인하는 책임은 사용자에게 있습니다 (via issuccess).

BunchKaufman 객체에 대해 사용할 수 있는 함수는 다음과 같습니다: size, \, inv, issymmetric, ishermitian, getindex.

예제

julia> A = Float64.([1 2; 2 3])
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  3.0

julia> S = bunchkaufman(A) # A는 내부적으로 Symmetric(A)에 의해 래핑됩니다.
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D 인자:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U 인자:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
순열:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # 반복을 통한 구조 분해

julia> d == S.D && u == S.U && p == S.p
true

julia> S.U*S.D*S.U' - S.P*A*S.P'
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D 인자:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L 인자:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
순열:
2-element Vector{Int64}:
 2
 1

julia> S.L*S.D*S.L' - A[S.p, S.p]
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

bunchkaufman!(A, rook::Bool=false; check = true) -> BunchKaufman

bunchkaufman!는 bunchkaufman와 동일하지만, 복사본을 생성하는 대신 입력 A를 덮어써서 공간을 절약합니다.

Eigen <: Factorization

정방 행렬 A의 고유값/스펙트럼 분해의 행렬 분해 유형입니다. 이는 해당 행렬 분해 함수인 eigen의 반환 유형입니다.

F::Eigen이 분해 객체인 경우, 고유값은 F.values를 통해 얻을 수 있으며, 고유벡터는 행렬 F.vectors의 열로 얻을 수 있습니다. (k번째 고유벡터는 슬라이스 F.vectors[:, k]를 통해 얻을 수 있습니다.)

분해를 반복하면 구성 요소 F.values와 F.vectors가 생성됩니다.

예제

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
  1.0
  3.0
 18.0
vectors:
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Vector{Float64}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

GeneralizedEigen <: Factorization

A와 B의 일반화된 고유값/스펙트럼 분해의 행렬 분해 유형입니다. 이는 두 개의 행렬 인수로 호출될 때 해당 행렬 분해 함수인 eigen의 반환 유형입니다.

F::GeneralizedEigen이 분해 객체인 경우, 고유값은 F.values를 통해 얻을 수 있으며, 고유벡터는 행렬 F.vectors의 열로 얻을 수 있습니다. (k번째 고유벡터는 슬라이스 F.vectors[:, k]를 통해 얻을 수 있습니다.)

분해를 반복하면 구성 요소 F.values와 F.vectors가 생성됩니다.

예제

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

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> F = eigen(A, B)
GeneralizedEigen{ComplexF64, ComplexF64, Matrix{ComplexF64}, Vector{ComplexF64}}
values:
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im
vectors:
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> F.values
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

eigvals(A; permute::Bool=true, scale::Bool=true, sortby) -> values

행렬 A의 고유값을 반환합니다.

일반 비대칭 행렬의 경우 고유값 계산 전에 행렬이 어떻게 균형을 이루는지 지정할 수 있습니다. permute, scale, 및 sortby 키워드는 eigen와 동일합니다.

예제

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

julia> eigvals(diag_matrix)
2-element Vector{Float64}:
 1.0
 4.0

스칼라 입력의 경우, eigvals는 스칼라를 반환합니다.

예제

julia> eigvals(-2)
-2

eigvals(A, B) -> values

A와 B의 일반화된 고유값을 계산합니다.

예제

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

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> eigvals(A,B)
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

A의 고유값을 반환합니다. 정렬된 고유값의 인덱스를 포함하는 UnitRange irange를 지정하여 고유값의 하위 집합만 계산할 수 있습니다. 예를 들어, 2번째에서 8번째 고유값을 계산할 수 있습니다.

예제

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A, 2:2)
1-element Vector{Float64}:
 0.9999999999999996

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values

A의 고유값을 반환합니다. 고유값의 하한과 상한을 지정하여 고유값의 하위 집합만 계산하는 것이 가능합니다.

예제

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A, -1, 2)
1-element Vector{Float64}:
 1.0000000000000009

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

eigvals!(A; permute::Bool=true, scale::Bool=true, sortby) -> values

eigvals와 동일하지만, 입력 A를 덮어써서 공간을 절약합니다. permute, scale, 및 sortby 키워드는 eigen와 동일합니다.

예제

julia> A = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> eigvals!(A)
2-element Vector{Float64}:
 -0.3722813232690143
  5.372281323269014

julia> A
2×2 Matrix{Float64}:
 -0.372281  -1.0
  0.0        5.37228

eigvals!(A, B; sortby) -> values

eigvals와 동일하지만, 복사본을 생성하는 대신 입력 A(및 B)를 덮어써서 공간을 절약합니다.

예제

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

julia> eigvals!(A, B)
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> A
2×2 Matrix{Float64}:
 -0.0  -1.0
  1.0  -0.0

julia> B
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

eigvals와 동일하지만, 복사본을 생성하는 대신 입력 A를 덮어써서 공간을 절약합니다. irange는 검색할 고유값 인덱스의 범위입니다 - 예를 들어, 2번째에서 8번째 고유값까지입니다.

eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values

eigvals와 동일하지만, 복사본을 생성하는 대신 입력 A를 덮어써서 공간을 절약합니다. vl은 고유값을 찾기 위한 구간의 하한이며, vu는 상한입니다.

eigmax(A; permute::Bool=true, scale::Bool=true)

A의 가장 큰 고유값을 반환합니다. 옵션 permute=true는 행렬을 상삼각형에 더 가깝게 만들기 위해 행렬을 재배열하고, scale=true는 행렬의 대각선 요소로 행렬을 스케일링하여 행과 열의 노름을 더 균등하게 만듭니다. A의 고유값이 복소수인 경우 이 방법은 실패합니다. 복소수는 정렬할 수 없기 때문입니다.

예제

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

julia> eigmax(A)
1.0

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

julia> eigmax(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A`는 복소수 고유값을 가질 수 없습니다.
Stacktrace:
[...]

eigmin(A; permute::Bool=true, scale::Bool=true)

A의 가장 작은 고유값을 반환합니다. 옵션 permute=true는 행렬을 상삼각형에 더 가깝게 만들기 위해 행렬을 재배열하고, scale=true는 행렬의 대각선 요소로 행렬을 스케일링하여 행과 열의 노름을 더 비슷하게 만듭니다. A의 고유값이 복소수인 경우 이 방법은 실패합니다. 복소수는 정렬할 수 없기 때문입니다.

예제

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

julia> eigmin(A)
-1.0

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

julia> eigmin(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A`는 복소수 고유값을 가질 수 없습니다.
Stacktrace:
[...]

eigvecs(A::SymTridiagonal[, eigvals]) -> Matrix

행렬 M을 반환하며, M의 열은 A의 고유벡터입니다. (k번째 고유벡터는 슬라이스 M[:, k]에서 얻을 수 있습니다.)

선택적 고유값 벡터 eigvals가 지정되면, eigvecs는 해당 고유벡터를 반환합니다.

예제

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

julia> eigvecs(A)
3×3 Matrix{Float64}:
  0.418304  -0.83205      0.364299
 -0.656749  -7.39009e-16  0.754109
  0.627457   0.5547       0.546448

julia> eigvecs(A, [1.])
3×1 Matrix{Float64}:
  0.8320502943378438
  4.263514128092366e-17
 -0.5547001962252291

eigvecs(A; permute::Bool=true, scale::Bool=true, `sortby`) -> Matrix

행렬 A의 고유벡터로 구성된 행렬 M을 반환합니다. (k번째 고유벡터는 슬라이스 M[:, k]에서 얻을 수 있습니다.) permute, scale, 및 sortby 키워드는 eigen와 동일합니다.

예제

julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

eigvecs(A, B) -> Matrix

행렬 M을 반환하며, M의 열은 A와 B의 일반화된 고유벡터입니다. (k번째 고유벡터는 슬라이스 M[:, k]에서 얻을 수 있습니다.)

예제

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

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> eigvecs(A, B)
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

eigen(A; permute::Bool=true, scale::Bool=true, sortby) -> Eigen

행렬 A의 고유값 분해를 계산하여 고유값이 F.values에, 고유벡터가 행렬 F.vectors의 열에 포함된 Eigen 분해 객체 F를 반환합니다. 이는 Ax = λx 형태의 고유값 문제를 해결하는 것에 해당하며, 여기서 A는 행렬, x는 고유벡터, λ는 고유값입니다. (k번째 고유벡터는 슬라이스 F.vectors[:, k]에서 얻을 수 있습니다.)

분해를 반복하면 구성 요소 F.values와 F.vectors를 생성합니다.

다음 함수는 Eigen 객체에 대해 사용할 수 있습니다: inv, det, 및 isposdef.

일반 비대칭 행렬의 경우 고유벡터 계산 전에 행렬이 어떻게 균형을 이루는지 지정할 수 있습니다. 옵션 permute=true는 행렬을 상삼각형에 더 가깝게 만들기 위해 순열을 적용하고, scale=true는 행렬의 대각 요소로 행렬을 스케일링하여 행과 열의 노름을 더 평등하게 만듭니다. 기본값은 두 옵션 모두 true입니다.

기본적으로 고유값과 고유벡터는 (real(λ),imag(λ))에 따라 사전식으로 정렬됩니다. 다른 비교 함수 by(λ)를 sortby에 전달할 수 있으며, sortby=nothing을 전달하여 고유값을 임의의 순서로 남길 수 있습니다. 일부 특수 행렬 유형(예: Diagonal 또는 SymTridiagonal)은 자체 정렬 규칙을 구현할 수 있으며 sortby 키워드를 수용하지 않을 수 있습니다.

예제

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
  1.0
  3.0
 18.0
vectors:
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Vector{Float64}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

eigen(A, B; sortby) -> GeneralizedEigen

A와 B의 일반화된 고유값 분해를 계산하고, 일반화된 고유값이 F.values에, 일반화된 고유벡터가 행렬 F.vectors의 열에 포함된 GeneralizedEigen 분해 객체 F를 반환합니다. 이는 Ax = λBx 형태의 일반화된 고유값 문제를 해결하는 것에 해당하며, 여기서 A, B는 행렬, x는 고유벡터, λ는 고유값입니다. (k번째 일반화된 고유벡터는 슬라이스 F.vectors[:, k]에서 얻을 수 있습니다.)

분해를 반복하면 구성 요소 F.values와 F.vectors를 생성합니다.

기본적으로 고유값과 고유벡터는 (real(λ),imag(λ))에 따라 사전적으로 정렬됩니다. 다른 비교 함수 by(λ)를 sortby에 전달하거나, sortby=nothing을 전달하여 고유값을 임의의 순서로 남길 수 있습니다.

예제

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

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> F = eigen(A, B);

julia> F.values
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> vals, vecs = F; # 반복을 통한 구조 분해

julia> vals == F.values && vecs == F.vectors
true

eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> Eigen

A의 고유값 분해를 계산하고, 고유값은 F.values에, 고유벡터는 행렬 F.vectors의 열에 포함된 Eigen 분해 객체 F를 반환합니다. (k번째 고유벡터는 슬라이스 F.vectors[:, k]에서 얻을 수 있습니다.)

분해를 반복하면 구성 요소 F.values와 F.vectors를 생성합니다.

Eigen 객체에 대해 사용할 수 있는 함수는 다음과 같습니다: inv, det, 및 isposdef.

UnitRange irange는 검색할 정렬된 고유값의 인덱스를 지정합니다.

eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> Eigen

행렬 A의 고유값 분해를 계산하고, 고유값을 F.values에, 고유벡터를 행렬 F.vectors의 열에 포함하는 Eigen 분해 객체 F를 반환합니다. (k번째 고유벡터는 슬라이스 F.vectors[:, k]에서 얻을 수 있습니다.)

분해를 반복하면 구성 요소 F.values와 F.vectors를 생성합니다.

Eigen 객체에 대해 사용할 수 있는 함수는 inv, det, 및 isposdef입니다.

vl은 검색할 고유값의 윈도우의 하한이며, vu는 상한입니다.

eigen!(A; permute, scale, sortby)
eigen!(A, B; sortby)

eigen와 동일하지만, 복사본을 생성하는 대신 입력 A(및 B)를 덮어써서 공간을 절약합니다.

Hessenberg <: Factorization

Hessenberg 객체는 정방 행렬의 Hessenberg 분해 QHQ' 또는 그에 대한 이동 Q(H+μI)Q'를 나타내며, 이는 hessenberg 함수에 의해 생성됩니다.

hessenberg(A) -> Hessenberg

행렬 A의 헤센베르크 분해를 계산하고 Hessenberg 객체를 반환합니다. 만약 F가 분해 객체라면, 유니타리 행렬은 F.Q (타입 LinearAlgebra.HessenbergQ)로 접근할 수 있으며, 헤센베르크 행렬은 F.H (타입 UpperHessenberg)로 접근할 수 있습니다. 이 두 행렬은 각각 Matrix(F.H) 또는 Matrix(F.Q)를 사용하여 일반 행렬로 변환할 수 있습니다.

만약 A가 Hermitian 또는 실수-Symmetric이라면, 헤센베르크 분해는 실수-대칭 삼대각 행렬을 생성하며 F.H는 타입 SymTridiagonal입니다.

변형된 분해 A+μI = Q (H+μI) Q'는 UniformScaling 객체 I를 사용하여 F + μ*I로 효율적으로 구성할 수 있으며, 이는 공유 저장소와 수정된 이동을 가진 새로운 Hessenberg 객체를 생성합니다. 주어진 F의 이동은 F.μ로 얻을 수 있습니다. 이는 여러 개의 이동된 해를 (F + μ*I) \ b (다른 μ 및/또는 b에 대해) 효율적으로 수행할 수 있기 때문에 유용합니다. F가 생성된 후에 가능합니다.

분해를 반복하면 인수 F.Q, F.H, F.μ를 생성합니다.

예제

julia> A = [4. 9. 7.; 4. 4. 1.; 4. 3. 2.]
3×3 Matrix{Float64}:
 4.0  9.0  7.0
 4.0  4.0  1.0
 4.0  3.0  2.0

julia> F = hessenberg(A)
Hessenberg{Float64, UpperHessenberg{Float64, Matrix{Float64}}, Matrix{Float64}, Vector{Float64}, Bool}
Q factor: 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
H factor:
3×3 UpperHessenberg{Float64, Matrix{Float64}}:
  4.0      -11.3137       -1.41421
 -5.65685    5.0           2.0
   ⋅        -8.88178e-16   1.0

julia> F.Q * F.H * F.Q'
3×3 Matrix{Float64}:
 4.0  9.0  7.0
 4.0  4.0  1.0
 4.0  3.0  2.0

julia> q, h = F; # 반복을 통한 구조 분해

julia> q == F.Q && h == F.H
true

hessenberg!(A) -> 헤센베르크

hessenberg!는 hessenberg와 동일하지만, 복사본을 생성하는 대신 입력 A를 덮어써서 공간을 절약합니다.

Schur <: Factorization

행렬 A의 슈르 분해의 행렬 분해 유형입니다. 이는 schur(_)와 해당하는 행렬 분해 함수의 반환 유형입니다.

F::Schur가 분해 객체인 경우, (준)삼각형 슈르 인자는 F.Schur 또는 F.T를 통해 얻을 수 있으며, 직교/유니타리 슈르 벡터는 F.vectors 또는 F.Z를 통해 얻을 수 있습니다. 따라서 A = F.vectors * F.Schur * F.vectors'입니다. A의 고유값은 F.values로 얻을 수 있습니다.

분해를 반복하면 구성 요소 F.T, F.Z, 및 F.values가 생성됩니다.

예제

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T 인자:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z 인자:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
고유값:
2-element Vector{Float64}:
  3.0
 -2.0

julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> t, z, vals = F; # 반복을 통한 구조 분해

julia> t == F.T && z == F.Z && vals == F.values
true

GeneralizedSchur <: Factorization

두 행렬 A와 B의 일반화된 슈르 분해의 행렬 분해 유형입니다. 이는 schur(_, _) 함수의 반환 유형입니다.

F::GeneralizedSchur가 분해 객체인 경우, (준) 삼각 슈르 인자는 F.S 및 F.T를 통해 얻을 수 있으며, 왼쪽 유니타리/직교 슈르 벡터는 F.left 또는 F.Q를 통해, 오른쪽 유니타리/직교 슈르 벡터는 F.right 또는 F.Z를 통해 얻을 수 있습니다. 이때 A=F.left*F.S*F.right' 및 B=F.left*F.T*F.right'입니다. A와 B의 일반화된 고유값은 F.α./F.β를 통해 얻을 수 있습니다.

분해를 반복하면 구성 요소 F.S, F.T, F.Q, F.Z, F.α 및 F.β가 생성됩니다.

schur(A) -> F::Schur

행렬 A의 슈르 분해를 계산합니다. (준)삼각형 슈르 인자는 F라는 Schur 객체에서 F.Schur 또는 F.T를 사용하여 얻을 수 있으며, 직교/유니타리 슈르 벡터는 F.vectors 또는 F.Z를 사용하여 얻을 수 있습니다. 이때 A = F.vectors * F.Schur * F.vectors'가 성립합니다. A의 고유값은 F.values를 사용하여 얻을 수 있습니다.

실수 A의 경우, 슈르 분해는 "준삼각형"이며, 이는 복소수 고유값의 켤레 쌍에 대해 2×2 대각 블록이 있는 상삼각형임을 의미합니다. 이는 복소수 고유값이 있을 때에도 분해가 순수하게 실수일 수 있도록 합니다. 실수 준삼각형 분해에서 (복소수) 순수 상삼각형 슈르 분해를 얻으려면 Schur{Complex}(schur(A))를 사용할 수 있습니다.

분해를 반복하면 구성 요소 F.T, F.Z, 및 F.values가 생성됩니다.

예제

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T 인자:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z 인자:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
고유값:
2-element Vector{Float64}:
  3.0
 -2.0

julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> t, z, vals = F; # 반복을 통한 구조 분해

julia> t == F.T && z == F.Z && vals == F.values
true

schur(A, B) -> F::GeneralizedSchur

행렬 A와 B의 일반화된 슈르(또는 QZ) 분해를 계산합니다. (준)삼각 슈르 인자는 F라는 Schur 객체에서 F.S와 F.T로 얻을 수 있으며, 왼쪽 유니타리/직교 슈르 벡터는 F.left 또는 F.Q로, 오른쪽 유니타리/직교 슈르 벡터는 F.right 또는 F.Z로 얻을 수 있습니다. 이때 A=F.left*F.S*F.right' 및 B=F.left*F.T*F.right'입니다. A와 B의 일반화된 고유값은 F.α./F.β로 얻을 수 있습니다.

분해를 반복하면 구성 요소 F.S, F.T, F.Q, F.Z, F.α 및 F.β가 생성됩니다.

schur!(A) -> F::Schur

입력 인수 A를 작업 공간으로 사용하는 schur와 동일합니다.

예제

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur!(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T 인자:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z 인자:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
고유값:
2-element Vector{Float64}:
  3.0
 -2.0

julia> A
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0

schur!(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur

schur와 동일하지만 입력 행렬 A와 B를 작업 공간으로 사용합니다.

ordschur(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur

행렬 A = Z*T*Z'의 Schur 분해 F를 논리 배열 select에 따라 재정렬하여 재정렬된 분해 F 객체를 반환합니다. 선택된 고유값은 F.Schur의 주 대각선에 나타나며, 해당하는 F.vectors의 선두 열은 해당하는 오른쪽 불변 부분공간의 직교/유니타리 기저를 형성합니다. 실수의 경우, 복소수 켤레 쌍의 고유값은 select를 통해 모두 포함되거나 모두 제외되어야 합니다.

ordschur(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur

행렬 쌍 (A, B) = (Q*S*Z', Q*T*Z')의 일반화된 슈르 분해 F를 논리 배열 select에 따라 재정렬하고 일반화된 슈르 객체 F를 반환합니다. 선택된 고유값은 F.S와 F.T의 주 대각선에 나타나며, 왼쪽 및 오른쪽 직교/유니타리 슈르 벡터도 재정렬되어 (A, B) = F.Q*(F.S, F.T)*F.Z'가 여전히 성립하고 A와 B의 일반화된 고유값을 F.α./F.β로 여전히 얻을 수 있습니다.

ordschur!(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur

ordschur와 동일하지만 인수 분해 F를 덮어씁니다.

ordschur!(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur

ordschur와 동일하지만 인수 분해 F를 덮어씁니다.

SVD <: Factorization

행렬 A의 특이값 분해(SVD)의 행렬 분해 유형입니다. 이는 svd(_) 함수의 반환 유형입니다.

F::SVD가 분해 객체인 경우, U, S, V 및 Vt는 F.U, F.S, F.V 및 F.Vt를 통해 얻을 수 있으며, A = U * Diagonal(S) * Vt가 성립합니다. S의 특이값은 내림차순으로 정렬되어 있습니다.

분해를 반복하면 구성 요소 U, S 및 V를 생성합니다.

예제

julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> F = svd(A)
SVD{Float64, Float64, Matrix{Float64}, Vector{Float64}}
U factor:
4×4 Matrix{Float64}:
 0.0  1.0   0.0  0.0
 1.0  0.0   0.0  0.0
 0.0  0.0   0.0  1.0
 0.0  0.0  -1.0  0.0
singular values:
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0
Vt factor:
4×5 Matrix{Float64}:
 -0.0        0.0  1.0  -0.0  0.0
  0.447214   0.0  0.0   0.0  0.894427
  0.0       -1.0  0.0   0.0  0.0
  0.0        0.0  0.0   1.0  0.0

julia> F.U * Diagonal(F.S) * F.Vt
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> u, s, v = F; # destructuring via iteration

julia> u == F.U && s == F.S && v == F.V
true

GeneralizedSVD <: Factorization

두 행렬 A와 B의 일반화된 특이값 분해(SVD)의 행렬 분해 유형으로, A = F.U*F.D1*F.R0*F.Q' 및 B = F.V*F.D2*F.R0*F.Q'입니다. 이는 svd(_, _)의 반환 유형으로, 해당 행렬 분해 함수입니다.

M-by-N 행렬 A와 P-by-N 행렬 B에 대해,

• U는 M-by-M 직교 행렬입니다.
• V는 P-by-P 직교 행렬입니다.
• Q는 N-by-N 직교 행렬입니다.
• D1은 첫 K 항목에 1이 있는 M-by-(K+L) 대각 행렬입니다.
• D2는 상단 오른쪽 L-by-L 블록이 대각선인 P-by-(K+L) 행렬입니다.
• R0는 가장 오른쪽 (K+L)-by-(K+L) 블록이 비특이 상부 블록 삼각형인 (K+L)-by-N 행렬입니다.

K+L은 행렬 [A; B]의 유효 수치적 계수입니다.

분해를 반복하면 구성 요소 U, V, Q, D1, D2, 및 R0가 생성됩니다.

F.D1과 F.D2의 항목은 관련이 있으며, 이는 일반화된 SVD 및 그 아래에서 호출되는 xGGSVD3 루틴에 대한 LAPACK 문서에서 설명되어 있습니다( LAPACK 3.6.0 및 이후 버전).

예제

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

julia> F = svd(A, B)
GeneralizedSVD{Float64, Matrix{Float64}, Float64, Vector{Float64}}
U factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
V factor:
2×2 Matrix{Float64}:
 -0.0  -1.0
  1.0   0.0
Q factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
D1 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
D2 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
R0 factor:
2×2 Matrix{Float64}:
 1.41421   0.0
 0.0      -1.41421

julia> F.U*F.D1*F.R0*F.Q'
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> F.V*F.D2*F.R0*F.Q'
2×2 Matrix{Float64}:
 -0.0  1.0
  1.0  0.0

svd(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

행렬 A의 특이값 분해(SVD)를 계산하고 SVD 객체를 반환합니다.

U, S, V 및 Vt는 F의 분해에서 F.U, F.S, F.V 및 F.Vt를 사용하여 얻을 수 있으며, 이때 A = U * Diagonal(S) * Vt입니다. 알고리즘은 Vt를 생성하므로 Vt를 추출하는 것이 V보다 더 효율적입니다. S의 특이값은 내림차순으로 정렬되어 있습니다.

분해를 반복하면 구성 요소 U, S 및 V를 생성합니다.

full = false(기본값)인 경우 "얇은" SVD가 반환됩니다. $M \times N$ 행렬 A의 경우, 전체 분해에서 U는 $M \times M$이고 V는 $N \times N$이며, 얇은 분해에서 U는 $M \times K$이고 V는 $N \times K$입니다. 여기서 $K = \min(M,N)$는 특이값의 수입니다.

alg = DivideAndConquer()인 경우 분할 정복 알고리즘을 사용하여 SVD를 계산합니다. 또 다른 옵션은 alg = QRIteration()으로, 일반적으로 더 느리지만 더 정확합니다.

예제

julia> A = rand(4,3);

julia> F = svd(A); # 분해 객체 저장

julia> A ≈ F.U * Diagonal(F.S) * F.Vt
true

julia> U, S, V = F; # 반복을 통한 구조 분해

julia> A ≈ U * Diagonal(S) * V'
true

julia> Uonly, = svd(A); # U만 저장

julia> Uonly == U
true

svd(A, B) -> GeneralizedSVD

A와 B의 일반화된 SVD를 계산하여 F라는 GeneralizedSVD 분해 객체를 반환합니다. 여기서 [A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 * F.Q'입니다.

• U는 M-by-M 직교 행렬입니다.
• V는 P-by-P 직교 행렬입니다.
• Q는 N-by-N 직교 행렬입니다.
• D1은 첫 K 항목에 1이 있는 M-by-(K+L) 대각 행렬입니다.
• D2는 상단 오른쪽 L-by-L 블록이 대각선인 P-by-(K+L) 행렬입니다.
• R0는 가장 오른쪽 (K+L)-by-(K+L) 블록이 비특이 상부 블록 삼각형인 (K+L)-by-N 행렬입니다.

K+L은 행렬 [A; B]의 유효 수치적 계수입니다.

분해를 반복하면 구성 요소 U, V, Q, D1, D2, 및 R0가 생성됩니다.

일반화된 SVD는 A와 B의 비교가 필요할 때, 예를 들어 인간과 효모 유전체, 신호와 잡음, 또는 클러스터 간과 클러스터 내의 비교와 같은 응용 프로그램에서 사용됩니다. (논의는 Edelman과 Wang을 참조하십시오: https://arxiv.org/abs/1901.00485)

이것은 [A; B]를 [UC; VS]H로 분해하며, 여기서 [UC; VS]는 [A; B]의 열 공간에 대한 자연스러운 직교 기저이고, H = RQ'는 [A;B]의 행 공간에 대한 자연스러운 비직교 기저입니다. 여기서 상단 행은 A 행렬에 가장 밀접하게 귀속되고, 하단 행은 B 행렬에 귀속됩니다. 다중 코사인/사인 행렬 C와 S는 A와 B의 비율을 측정하는 다중 측정을 제공합니다. U와 V는 이러한 측정이 이루어지는 방향을 제공합니다.

예제

julia> A = randn(3,2); B=randn(4,2);

julia> F = svd(A, B);

julia> U,V,Q,C,S,R = F;

julia> H = R*Q';

julia> [A; B] ≈ [U*C; V*S]*H
true

julia> [A; B] ≈ [F.U*F.D1; F.V*F.D2]*F.R0*F.Q'
true

julia> Uonly, = svd(A,B);

julia> U == Uonly
true

svd!(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

svd!는 svd와 동일하지만, 복사본을 생성하는 대신 입력 A를 덮어써서 공간을 절약합니다. 자세한 내용은 svd 문서를 참조하세요.

svd!(A, B) -> GeneralizedSVD

svd!는 svd와 동일하지만, 복사본을 만드는 대신 인수 A와 B를 제자리에서 수정합니다. 자세한 내용은 svd 문서를 참조하십시오.

svdvals(A)

A의 특이값을 내림차순으로 반환합니다.

예제

julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> svdvals(A)
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0

svdvals(A, B)

A와 B의 일반화된 특이값 분해에서 일반화된 특이값을 반환합니다. svd도 참조하십시오.

예제

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

julia> svdvals(A, B)
2-element Vector{Float64}:
 1.0
 1.0

svdvals!(A)

A의 특이값을 반환하며, 입력을 덮어써서 공간을 절약합니다. svdvals 및 svd도 참조하세요.

svdvals!(A, B)

A와 B의 일반화된 특이값 분해에서 일반화된 특이값을 반환하며, A와 B를 덮어써서 공간을 절약합니다. 또한 svd 및 svdvals를 참조하십시오.

LinearAlgebra.Givens(i1,i2,c,s) -> G

Givens 회전 선형 연산자입니다. 필드 c와 s는 각각 회전 각도의 코사인과 사인을 나타냅니다. Givens 타입은 왼쪽 곱셈 G*A와 켤레 전치 오른쪽 곱셈 A*G'을 지원합니다. 이 타입은 size가 없으므로 G*A의 경우 i2<=size(A,2) 또는 A*G'의 경우 i2<=size(A,1)인 한 임의의 크기의 행렬과 곱할 수 있습니다.

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

givens(f::T, g::T, i1::Integer, i2::Integer) where {T} -> (G::Givens, r::T)

주어진 f와 g에 대해 Givens 회전 G와 스칼라 r을 계산합니다. 여기서 x 벡터는 다음과 같습니다.

x[i1] = f
x[i2] = g

곱셈의 결과는 다음과 같습니다.

y = G*x

이때 다음과 같은 속성을 가집니다.

y[i1] = r
y[i2] = 0

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

givens(A::AbstractArray, i1::Integer, i2::Integer, j::Integer) -> (G::Givens, r)

Givens 회전 G와 스칼라 r을 계산합니다. 이때 곱셈의 결과가

B = G*A

다음과 같은 속성을 가집니다.

B[i1,j] = r
B[i2,j] = 0

자세한 내용은 LinearAlgebra.Givens를 참조하세요. ```

givens(x::AbstractVector, i1::Integer, i2::Integer) -> (G::Givens, r)

Givens 회전 G와 스칼라 r을 계산합니다. 이때 곱셈의 결과가

B = G*x

다음과 같은 속성을 가집니다.

B[i1] = r
B[i2] = 0

자세한 내용은 LinearAlgebra.Givens를 참조하세요. ```

triu(M)

행렬의 상삼각.

예제

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 0.0  1.0  1.0  1.0
 0.0  0.0  1.0  1.0
 0.0  0.0  0.0  1.0

triu(M, k::Integer)

k번째 초대각선에서 시작하는 M의 상삼각행렬을 반환합니다.

예제

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a,3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  1.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

julia> triu(a,-3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

triu!(M)

행렬의 상삼각을 구하고, 그 과정에서 M을 덮어씁니다. 또한 triu를 참조하세요.

triu!(M, k::Integer)

M의 k번째 초대각선에서 시작하는 상삼각행렬을 반환하며, 이 과정에서 M을 덮어씁니다.

예제

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

julia> triu!(M, 1)
5×5 Matrix{Int64}:
 0  2  3  4  5
 0  0  3  4  5
 0  0  0  4  5
 0  0  0  0  5
 0  0  0  0  0

tril(M)

행렬의 하삼각.

예제

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a)
4×4 Matrix{Float64}:
 1.0  0.0  0.0  0.0
 1.0  1.0  0.0  0.0
 1.0  1.0  1.0  0.0
 1.0  1.0  1.0  1.0

tril(M, k::Integer)

k번째 초대각선에서 시작하는 M의 하삼각형을 반환합니다.

예제

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,-3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 1.0  0.0  0.0  0.0

tril!(M)

행렬의 하삼각을 구하고 그 과정에서 M을 덮어씁니다. 또한 tril를 참조하세요.

tril!(M, k::Integer)

M의 k번째 초대각선에서 시작하는 하삼각행렬을 반환하며, 이 과정에서 M을 덮어씁니다.

예제

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

julia> tril!(M, 2)
5×5 Matrix{Int64}:
 1  2  3  0  0
 1  2  3  4  0
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

diagind(M::AbstractMatrix, k::Integer = 0, indstyle::IndexStyle = IndexLinear())
diagind(M::AbstractMatrix, indstyle::IndexStyle = IndexLinear())

행렬 M의 k번째 대각선의 인덱스를 제공하는 AbstractRange입니다. 선택적으로 인덱스 스타일을 지정할 수 있으며, 이는 반환되는 범위의 유형을 결정합니다. indstyle isa IndexLinear(기본값)인 경우, 이는 AbstractRange{Integer}를 반환합니다. 반면에 indstyle isa IndexCartesian인 경우, 이는 AbstractRange{CartesianIndex{2}}를 반환합니다.

k가 제공되지 않으면 0(주 대각선에 해당)으로 간주됩니다.

참고: diag, diagm, Diagonal.

예제

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

julia> diagind(A, -1)
2:4:6

julia> diagind(A, IndexCartesian())
StepRangeLen(CartesianIndex(1, 1), CartesianIndex(1, 1), 3)

diag(M, k::Integer=0)

행렬의 k번째 대각선, 벡터로.

또한 diagm, diagind, Diagonal, isdiag를 참조하세요.

예제

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

julia> diag(A,1)
2-element Vector{Int64}:
 2
 6

diagm(kv::Pair{<:Integer,<:AbstractVector}...)
diagm(m::Integer, n::Integer, kv::Pair{<:Integer,<:AbstractVector}...)

`Pair`의 대각선과 벡터로부터 행렬을 구성합니다. 벡터 `kv.second`는 `kv.first` 대각선에 배치됩니다. 기본적으로 행렬은 정사각형이며 그 크기는 `kv`로부터 유추되지만, 필요에 따라 0으로 패딩된 비정사각형 크기 `m`×`n`을 첫 번째 인수로 `m,n`을 전달하여 지정할 수 있습니다. 반복된 대각선 인덱스 `kv.first`에 대해 해당 벡터 `kv.second`의 값이 더해집니다.

`diagm`은 전체 행렬을 구성합니다; 저장 효율적인 버전과 빠른 산술 연산을 원하신다면 [`Diagonal`](@ref), [`Bidiagonal`](@ref), [`Tridiagonal`](@ref) 및 [`SymTridiagonal`](@ref)를 참조하세요.

# 예제

jldoctest julia> diagm(1 => [1,2,3]) 4×4 Matrix{Int64}: 0 1 0 0 0 0 2 0 0 0 0 3 0 0 0 0

julia> diagm(1 => [1,2,3], -1 => [4,5]) 4×4 Matrix{Int64}: 0 1 0 0 4 0 2 0 0 5 0 3 0 0 0 0

julia> diagm(1 => [1,2,3], 1 => [1,2,3]) 4×4 Matrix{Int64}: 0 2 0 0 0 0 4 0 0 0 0 6 0 0 0 0 ```

diagm(v::AbstractVector)
diagm(m::Integer, n::Integer, v::AbstractVector)

벡터의 요소를 대각선 요소로 갖는 행렬을 생성합니다. 기본적으로 행렬은 정사각형이며 크기는 length(v)로 주어지지만, 비정사각형 크기 m×n는 첫 번째 인수로 m,n을 전달하여 지정할 수 있습니다.

예제

julia> diagm([1,2,3])
3×3 Matrix{Int64}:
 1  0  0
 0  2  0
 0  0  3

rank(::QRSparse{Tv,Ti}) -> Ti

QR 분해의 랭크를 반환합니다.

rank(S::SparseMatrixCSC{Tv,Ti}; [tol::Real]) -> Ti

S의 랭크를 QR 분해를 통해 계산합니다. tol보다 작은 값은 0으로 간주됩니다. SPQR 매뉴얼을 참조하세요.

rank(A::AbstractMatrix; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
rank(A::AbstractMatrix, rtol::Real)

행렬의 수치적 랭크를 계산하여 svdvals(A)의 출력 중 max(atol, rtol*σ₁)보다 큰 값의 개수를 셉니다. 여기서 σ₁은 A의 가장 큰 계산된 특이값입니다. atol과 rtol은 각각 절대 및 상대 허용오차입니다. 기본 상대 허용오차는 n*ϵ이며, 여기서 n은 A의 가장 작은 차원의 크기이고, ϵ는 A의 요소 유형의 eps입니다.

예제

julia> rank(Matrix(I, 3, 3))
3

julia> rank(diagm(0 => [1, 0, 2]))
2

julia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.1)
2

julia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.00001)
3

julia> rank(diagm(0 => [1, 0.001, 2]), atol=1.5)
1

norm(A, p::Real=2)

어떤 숫자의 반복 가능한 컨테이너 A(모든 차원의 배열 포함)에 대해 p-노름(p=2로 기본 설정됨)을 계산합니다. 이는 A가 해당 길이의 벡터인 것처럼 처리됩니다.

p-노름은 다음과 같이 정의됩니다.

\[\|A\|_p = \left( \sum_{i=1}^n | a_i | ^p \right)^{1/p}\]

여기서 $a_i$는 A의 항목, $| a_i |$는 norm $a_i$의 노름, $n$은 A의 길이입니다. p-노름은 A의 항목의 norm을 사용하여 계산되므로, p != 2인 경우 벡터의 벡터로서의 해석과 호환되지 않습니다.

p는 어떤 숫자 값도 가질 수 있습니다(모든 값이 수학적으로 유효한 벡터 노름을 생성하는 것은 아닙니다). 특히, norm(A, Inf)는 abs.(A)에서 가장 큰 값을 반환하고, norm(A, -Inf)는 가장 작은 값을 반환합니다. 만약 A가 행렬이고 p=2라면, 이는 프로베니우스 노름과 동등합니다.

두 번째 인수 p는 반드시 norm의 인터페이스의 일부가 아닙니다. 즉, 사용자 정의 유형은 두 번째 인수 없이 norm(A)만 구현할 수 있습니다.

행렬의 연산자 노름을 계산하려면 opnorm를 사용하십시오.

예제

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

julia> norm(v)
7.0

julia> norm(v, 1)
11.0

julia> norm(v, Inf)
6.0

julia> norm([1 2 3; 4 5 6; 7 8 9])
16.881943016134134

julia> norm([1 2 3 4 5 6 7 8 9])
16.881943016134134

julia> norm(1:9)
16.881943016134134

julia> norm(hcat(v,v), 1) == norm(vcat(v,v), 1) != norm([v,v], 1)
true

julia> norm(hcat(v,v), 2) == norm(vcat(v,v), 2) == norm([v,v], 2)
true

julia> norm(hcat(v,v), Inf) == norm(vcat(v,v), Inf) != norm([v,v], Inf)
true

norm(x::Number, p::Real=2)

숫자의 경우, $\left( |x|^p \right)^{1/p}$를 반환합니다.

예제

julia> norm(2, 1)
2.0

julia> norm(-2, 1)
2.0

julia> norm(2, 2)
2.0

julia> norm(-2, 2)
2.0

julia> norm(2, Inf)
2.0

julia> norm(-2, Inf)
2.0

opnorm(A::AbstractMatrix, p::Real=2)

벡터 p-노름에 의해 유도된 연산자 노름(또는 행렬 노름)을 계산합니다. 여기서 유효한 p 값은 1, 2, 또는 Inf입니다. (희소 행렬의 경우, 현재 p=2는 구현되어 있지 않습니다.) 프로베니우스 노름을 계산하기 위해 norm를 사용하십시오.

p=1일 때, 연산자 노름은 A의 최대 절대 열 합계입니다:

\[\|A\|_1 = \max_{1 ≤ j ≤ n} \sum_{i=1}^m | a_{ij} |\]

여기서 $a_{ij}$는 $A$의 항목이며, $m$과 $n$은 그 차원입니다.

p=2일 때, 연산자 노름은 스펙트럴 노름으로, A의 가장 큰 특이값과 같습니다.

p=Inf일 때, 연산자 노름은 A의 최대 절대 행 합계입니다:

\[\|A\|_\infty = \max_{1 ≤ i ≤ m} \sum _{j=1}^n | a_{ij} |\]

예제

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

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0

opnorm(x::Number, p::Real=2)

숫자의 경우, $\left( |x|^p \right)^{1/p}$를 반환합니다. 이는 norm와 동일합니다.

opnorm(A::Adjoint{<:Any,<:AbstractVector}, q::Real=2)
opnorm(A::Transpose{<:Any,<:AbstractVector}, q::Real=2)

Adjoint/Transpose로 감싸진 벡터의 경우, A의 연산자 $q$-노름을 반환하며, 이는 p-노름과 동등하며 값은 p = q/(q-1)입니다. 이들은 p = q = 2에서 일치합니다. norm를 사용하여 벡터로서 A의 p 노름을 계산합니다.

벡터 공간과 그 쌍대 사이의 노름 차이는 쌍대성과 내적 간의 관계를 보존하기 위해 발생하며, 결과는 1 × n 행렬의 연산자 p-노름과 일치합니다.

예제

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0

normalize!(a::AbstractArray, p::Real=2)

배열 a를 제자리에서 정규화하여 p-노름이 1이 되도록 합니다. 즉, norm(a, p) == 1입니다. 또한 normalize 및 norm를 참조하십시오.

normalize(a, p::Real=2)

a를 정규화하여 p-노름이 1이 되도록 합니다. 즉, norm(a, p) == 1입니다. 스칼라의 경우, 이는 sign(a)와 유사하지만, normalize(0) = NaN입니다. normalize!, norm, 및 sign도 참조하십시오.

예제

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

julia> b = normalize(a)
3-element Vector{Float64}:
 0.2182178902359924
 0.4364357804719848
 0.8728715609439696

julia> norm(b)
1.0

julia> c = normalize(a, 1)
3-element Vector{Float64}:
 0.14285714285714285
 0.2857142857142857
 0.5714285714285714

julia> norm(c, 1)
1.0

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

julia> norm(a)
6.48074069840786

julia> normalize(a)
2×3 Matrix{Float64}:
 0.154303  0.308607  0.617213
 0.154303  0.308607  0.617213

julia> normalize(3, 1)
1.0

julia> normalize(-8, 1)
-1.0

julia> normalize(0, 1)
NaN

cond(M, p::Real=2)

행렬 M의 조건 수로, 연산자 p-노름을 사용하여 계산됩니다. p의 유효한 값은 1, 2(기본값) 또는 Inf입니다.

condskeel(M, [x, p::Real=Inf])

\[\kappa_S(M, p) = \left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \right\Vert_p \\ \kappa_S(M, x, p) = \frac{\left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \left\vert x \right\vert \right\Vert_p}{\left \Vert x \right \Vert_p}\]

행렬 M의 Skeel 조건 수 $\kappa_S$는 선택적으로 벡터 x에 대해 계산되며, 연산자 p-노름을 사용합니다. $\left\vert M \right\vert$는 $M$의 (항목별) 절대값 행렬을 나타내며; \left\vert M \right\vert{ij} = \left\vert M{ij} \right\vert. p의 유효한 값은 1, 2 및 Inf (기본값)입니다.

이 양은 문헌에서 바우어 조건 수, 상대 조건 수 또는 항목별 상대 조건 수로도 알려져 있습니다.

tr(M)

행렬의 자취. M의 대각선 요소를 합산합니다.

예제

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

julia> tr(A)
5

det(M)

행렬의 행렬식.

참고: logdet 및 logabsdet.

예제

julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
 1  0
 2  2

julia> det(M)
2.0

logdet(M)

행렬 행렬식의 로그. log(det(M))와 동등하지만, 정확성을 높이고 오버플로우/언더플로우를 피할 수 있습니다.

예제

julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
 1  0
 2  2

julia> logdet(M)
0.6931471805599453

julia> logdet(Matrix(I, 3, 3))
0.0

logabsdet(M)

행렬 행렬식의 절대값의 로그. (log(abs(det(M))), sign(det(M)))와 동등하지만, 정확도 및/또는 속도가 향상될 수 있습니다.

예제

julia> A = [-1. 0.; 0. 1.]
2×2 Matrix{Float64}:
 -1.0  0.0
  0.0  1.0

julia> det(A)
-1.0

julia> logabsdet(A)
(0.0, -1.0)

julia> B = [2. 0.; 0. 1.]
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  1.0

julia> det(B)
2.0

julia> logabsdet(B)
(0.6931471805599453, 1.0)

inv(M)

행렬의 역행렬. 행렬 M에 대해 M * N = I가 성립하는 행렬 N을 계산합니다. 여기서 I는 단위 행렬입니다. 왼쪽 나눗셈 N = M \ I를 풀어서 계산됩니다.

예제

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

julia> N = inv(M)
2×2 Matrix{Float64}:
  3.0  -5.0
 -1.0   2.0

julia> M*N == N*M == Matrix(I, 2, 2)
true

pinv(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
pinv(M, rtol::Real) = pinv(M; rtol=rtol) # to be deprecated in Julia 2.0

Moore-Penrose 의사역행렬을 계산합니다.

부동 소수점 요소를 가진 행렬 M의 경우, σ₁이 M의 가장 큰 특이값일 때, max(atol, rtol*σ₁)보다 큰 특이값만 역전시켜 의사역행렬을 계산하는 것이 편리합니다.

절대 허용오차(atol)와 상대 허용오차(rtol)의 최적 선택은 M의 값과 의사역행렬의 의도된 응용에 따라 다릅니다. 기본 상대 허용오차는 n*ϵ이며, 여기서 n은 M의 가장 작은 차원의 크기이고, ϵ는 M의 요소 유형의 eps입니다.

밀집한 조건이 좋지 않은 행렬을 최소 제곱 방식으로 역전할 때는 rtol = sqrt(eps(real(float(oneunit(eltype(M))))))를 권장합니다.

자세한 내용은 ^[issue8859], ^[B96], ^[S84], ^[KY88]를 참조하십시오.

예제

julia> M = [1.5 1.3; 1.2 1.9]
2×2 Matrix{Float64}:
 1.5  1.3
 1.2  1.9

julia> N = pinv(M)
2×2 Matrix{Float64}:
  1.47287   -1.00775
 -0.930233   1.16279

julia> M * N
2×2 Matrix{Float64}:
 1.0          -2.22045e-16
 4.44089e-16   1.0

nullspace(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
nullspace(M, rtol::Real) = nullspace(M; rtol=rtol) # to be deprecated in Julia 2.0

M의 널 공간에 대한 기저를 계산합니다. 여기서 M의 특이값 중 크기가 max(atol, rtol*σ₁)보다 작은 특이 벡터를 포함합니다. 여기서 σ₁은 M의 가장 큰 특이값입니다.

기본적으로 상대 허용 오차 rtol은 n*ϵ이며, 여기서 n은 M의 가장 작은 차원의 크기이고, ϵ은 M의 요소 유형의 eps입니다.

예제

julia> M = [1 0 0; 0 1 0; 0 0 0]
3×3 Matrix{Int64}:
 1  0  0
 0  1  0
 0  0  0

julia> nullspace(M)
3×1 Matrix{Float64}:
 0.0
 0.0
 1.0

julia> nullspace(M, rtol=3)
3×3 Matrix{Float64}:
 0.0  1.0  0.0
 1.0  0.0  0.0
 0.0  0.0  1.0

julia> nullspace(M, atol=0.95)
3×1 Matrix{Float64}:
 0.0
 0.0
 1.0

kron(A, B)

두 벡터, 행렬 또는 숫자의 크로네커 곱을 계산합니다.

실수 벡터 v와 w에 대해, 크로네커 곱은 외적과 관련이 있으며 kron(v,w) == vec(w * transpose(v)) 또는 w * transpose(v) == reshape(kron(v,w), (length(w), length(v)))로 표현됩니다. 이러한 표현의 왼쪽과 오른쪽에서 v와 w의 순서가 다름을 주목하세요(열 우선 저장 방식 때문입니다). 복소수 벡터의 경우, 외적 w * v'는 v의 켤레에 의해 다릅니다.

예제

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

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

julia> kron(A, B)
4×4 Matrix{Complex{Int64}}:
 0+1im  1+0im  0+2im  2+0im
 1+0im  0-1im  2+0im  0-2im
 0+3im  3+0im  0+4im  4+0im
 3+0im  0-3im  4+0im  0-4im

julia> v = [1, 2]; w = [3, 4, 5];

julia> w*transpose(v)
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10

julia> reshape(kron(v,w), (length(w), length(v)))
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10

kron!(C, A, B)

A와 B의 크로네커 곱을 계산하고 결과를 C에 저장하여 C의 기존 내용을 덮어씁니다. 이것은 kron의 제자리 버전입니다.

exp(A::AbstractMatrix)

행렬 A의 지수 행렬을 계산합니다. 이는 다음과 같이 정의됩니다.

\[e^A = \sum_{n=0}^{\infty} \frac{A^n}{n!}.\]

대칭 또는 에르미트 행렬 A의 경우 고유 분해(eigen)가 사용되며, 그렇지 않은 경우 스케일링 및 제곱 알고리즘이 선택됩니다(자세한 내용은 ^[H05] 참조).

예제

julia> A = Matrix(1.0I, 2, 2)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

julia> exp(A)
2×2 Matrix{Float64}:
 2.71828  0.0
 0.0      2.71828

cis(A::AbstractMatrix)

정사각형 행렬 A의 exp(im*A)에 대한 더 효율적인 방법 (특히 A가 Hermitian 또는 실수 Symmetric인 경우).

또한 cispi, sincos, exp를 참조하십시오.

예제

julia> cis([π 0; 0 π]) ≈ -I
true

^(A::AbstractMatrix, p::Number)

행렬 거듭제곱, $\exp(p\log(A))$와 동등함

예제

julia> [1 2; 0 3]^3
2×2 Matrix{Int64}:
 1  26
 0  27

^(b::Number, A::AbstractMatrix)

행렬 지수, $\exp(\log(b)A)$와 동등합니다.

예제

julia> 2^[1 2; 0 3]
2×2 Matrix{Float64}:
 2.0  6.0
 0.0  8.0

julia> ℯ^[1 2; 0 3]
2×2 Matrix{Float64}:
 2.71828  17.3673
 0.0      20.0855

log(A::AbstractMatrix)

A에 음의 실 고유값이 없으면, A의 주 행렬 로그를 계산합니다. 즉, $e^X = A$이고 모든 고유값 $\lambda$에 대해 $-\pi < Im(\lambda) < \pi$인 유일한 행렬 $X$를 계산합니다. A에 비양수 고유값이 있는 경우, 가능한 경우 비주 행렬 함수가 반환됩니다.

A가 대칭 또는 에르미트인 경우, 그 고유 분해(eigen)가 사용되며, A가 삼각형인 경우에는 개선된 역 스케일링 및 제곱 방법이 사용됩니다(자세한 내용은 ^[AH12] 및 ^[AHR13] 참조). A가 음의 고유값이 없는 실수인 경우, 실 슈르 형식이 계산됩니다. 그렇지 않으면 복소 슈르 형식이 계산됩니다. 그런 다음 ^[AHR13]의 상부 (준)삼각형 알고리즘이 상부 (준)삼각형 요소에 사용됩니다.

예제

julia> A = Matrix(2.7182818*I, 2, 2)
2×2 Matrix{Float64}:
 2.71828  0.0
 0.0      2.71828

julia> log(A)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

sqrt(x)

Return $\sqrt{x}$.

음수 Real 인수에 대해 DomainError를 발생시킵니다. 대신 복소수 음수 인수를 사용하세요. sqrt는 음의 실수 축을 따라 분기 절단이 있음을 유의하세요.

접두사 연산자 √는 sqrt와 동일합니다.

참고: hypot.

예제

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> sqrt(-81 - 0.0im)  # -0.0im은 분기 절단 아래에 있습니다
0.0 - 9.0im

julia> .√(1:4)
4-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0

sqrt(A::AbstractMatrix)

A에 음의 실 고유값이 없으면, A의 주 행렬 제곱근을 계산합니다. 즉, $X^2 = A$를 만족하고 고유값이 양의 실수 부분을 가지는 유일한 행렬 $X$입니다. 그렇지 않으면 비주 행렬 제곱근이 반환됩니다.

A가 실 대칭 행렬이거나 에르미트 행렬인 경우, 고유 분해(eigen)를 사용하여 제곱근을 계산합니다. 이러한 행렬의 경우, 반올림 오류로 인해 약간 음수로 나타나는 고유값 λ는 0으로 간주됩니다. 보다 정확하게, 모든 고유값이 ≥ -rtol*(max |λ|)인 행렬은 반정의로 간주되어 (에르미트 제곱근을 생성함) 음의 고유값은 0으로 취급됩니다. rtol은 sqrt의 키워드 인수(에르미트/실 대칭 경우에만)로, 기본값은 size(A,1)에 의해 조정된 기계 정밀도입니다.

그렇지 않은 경우, 제곱근은 Björck-Hammarling 방법 ^[BH83]에 의해 결정되며, 이는 복소수 슈르 형식(schur)을 계산한 다음 삼각 인자의 복소수 제곱근을 계산합니다. 실 제곱근이 존재하는 경우, 이 방법의 확장 ^[H87]이 사용되어 실 슈르 형식을 계산한 다음 준삼각 인자의 실 제곱근을 계산합니다.

예제

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

julia> sqrt(A)
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0

cbrt(A::AbstractMatrix{<:Real})

실수 행렬 A의 실수 값 세제곱근을 계산합니다. T = cbrt(A)인 경우, T*T*T ≈ A가 성립합니다. 아래에 주어진 예를 참조하십시오.

A가 대칭인 경우, 즉 HermOrSym{<:Real} 유형인 경우 (eigen)를 사용하여 세제곱근을 찾습니다. 그렇지 않으면, p-번째 근 알고리즘의 특수화된 버전 ^[S03]이 사용되며, 이는 실수 값 슈르 분해 (schur)를 활용하여 세제곱근을 계산합니다.

예제

julia> A = [0.927524 -0.15857; -1.3677 -1.01172]
2×2 Matrix{Float64}:
  0.927524  -0.15857
 -1.3677    -1.01172

julia> T = cbrt(A)
2×2 Matrix{Float64}:
  0.910077  -0.151019
 -1.30257   -0.936818

julia> T*T*T ≈ A
true

cos(A::AbstractMatrix)

정사각형 행렬 A의 행렬 코사인을 계산합니다.

A가 대칭 또는 에르미트인 경우, 고유 분해(eigen)를 사용하여 코사인을 계산합니다. 그렇지 않으면, 코사인은 exp를 호출하여 결정됩니다.

예제

julia> cos(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927

sin(A::AbstractMatrix)

정방 행렬 A의 행렬 사인 값을 계산합니다.

A가 대칭 또는 에르미트인 경우, 고유 분해(eigen)를 사용하여 사인을 계산합니다. 그렇지 않으면, exp를 호출하여 사인을 결정합니다.

예제

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

sincos(A::AbstractMatrix)

정사각 행렬 A의 행렬 사인과 코사인을 계산합니다.

예제

julia> S, C = sincos(fill(1.0, (2,2)));

julia> S
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649

julia> C
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927

tan(A::AbstractMatrix)

정방 행렬 A의 행렬 탄젠트를 계산합니다.

A가 대칭 또는 에르미트인 경우, 고유 분해(eigen)를 사용하여 탄젠트를 계산합니다. 그렇지 않으면, exp를 호출하여 탄젠트를 결정합니다.

예제

julia> tan(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 -1.09252  -1.09252
 -1.09252  -1.09252

sec(A::AbstractMatrix)

정사각형 행렬 A의 행렬 시컨트를 계산합니다.

csc(A::AbstractMatrix)

정사각형 행렬 A의 행렬 코시컨을 계산합니다.

cot(A::AbstractMatrix)

정사각 행렬 A의 행렬 코탄젠트를 계산합니다.

cosh(A::AbstractMatrix)

정사각형 행렬 A의 행렬 쌍곡선 코사인 값을 계산합니다.

sinh(A::AbstractMatrix)

정사각형 행렬 A의 행렬 쌍곡선 사인(hyperbolic sine)을 계산합니다.

tanh(A::AbstractMatrix)

정사각형 행렬 A의 행렬 쌍곡선 탄젠트를 계산합니다.

sech(A::AbstractMatrix)

정방 행렬 A의 행렬 쌍곡선 시컨트를 계산합니다.

csch(A::AbstractMatrix)

정방 행렬 A의 행렬 쌍곡선 코시컨트를 계산합니다.

coth(A::AbstractMatrix)

정방 행렬 A의 행렬 쌍곡선 코탄젠트를 계산합니다.

acos(A::AbstractMatrix)

정사각형 행렬 A의 역행렬 코사인을 계산합니다.

A가 대칭 또는 에르미트인 경우, 고유 분해(eigen)를 사용하여 역 코사인을 계산합니다. 그렇지 않은 경우, 역 코사인은 log와 sqrt를 사용하여 결정됩니다. 이 함수를 계산하는 데 사용되는 이론 및 로그 공식에 대한 내용은 ^[AH16_1]을 참조하십시오.

예제

julia> acos(cos([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-8.32667e-17im  0.1+0.0im
 -0.2+2.63678e-16im  0.3-3.46945e-16im

asin(A::AbstractMatrix)

정사각형 행렬 A의 역행렬 사인 값을 계산합니다.

A가 대칭 또는 에르미트인 경우, 고유 분해(eigen)를 사용하여 역 사인을 계산합니다. 그렇지 않으면, 역 사인은 log와 sqrt를 사용하여 결정됩니다. 이 함수의 계산에 사용되는 이론과 로그 공식에 대한 내용은 ^[AH16_2]를 참조하십시오.

예제

julia> asin(sin([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-4.16334e-17im  0.1-5.55112e-17im
 -0.2+9.71445e-17im  0.3-1.249e-16im

atan(A::AbstractMatrix)

정방 행렬 A의 역행렬 탄젠트를 계산합니다.

A가 대칭 또는 에르미트인 경우, 고유 분해(eigen)를 사용하여 역 탄젠트를 계산합니다. 그렇지 않은 경우, 역 탄젠트는 log를 사용하여 결정됩니다. 이 함수의 계산에 사용되는 이론 및 로그 공식에 대한 내용은 ^[AH16_3]을 참조하십시오.

예제

julia> atan(tan([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5+1.38778e-17im  0.1-2.77556e-17im
 -0.2+6.93889e-17im  0.3-4.16334e-17im

asec(A::AbstractMatrix)

행렬 A의 역행렬 시컨트를 계산합니다.

acsc(A::AbstractMatrix)

행렬 A의 역행렬 코시컨트를 계산합니다.

acot(A::AbstractMatrix)

행렬 A의 역행렬 코탄젠트를 계산합니다.

acosh(A::AbstractMatrix)

정사각형 행렬 A의 역 쌍곡선 코사인 행렬을 계산합니다. 이 함수를 계산하는 데 사용되는 이론 및 로그 공식에 대해서는 ^[AH16_4]를 참조하십시오.

asinh(A::AbstractMatrix)

정사각형 행렬 A의 역쌍곡선 행렬 사인 값을 계산합니다. 이 함수를 계산하는 데 사용되는 이론 및 로그 공식에 대해서는 ^[AH16_5]를 참조하십시오.

atanh(A::AbstractMatrix)

정사각형 행렬 A의 역 쌍곡선 행렬 탄젠트를 계산합니다. 이 함수를 계산하는 데 사용되는 이론과 로그 공식에 대해서는 ^[AH16_6]를 참조하십시오.

asech(A::AbstractMatrix)

행렬 A의 역행렬 쌍곡선 시컨트를 계산합니다.

acsch(A::AbstractMatrix)

행렬 A의 역행렬 쌍곡선 코시컨트 값을 계산합니다.

acoth(A::AbstractMatrix)

행렬 A의 역행렬 쌍곡선 코탄젠트를 계산합니다.

lyap(A, C)

연속 리아푸노프 방정식 AX + XA' + C = 0의 해 X를 계산합니다. 여기서 A의 고유값 중 어떤 것도 실수가 0인 부분을 가지지 않으며, 두 개의 고유값이 서로 음의 복소수 켤레가 아닙니다.

예제

julia> A = [3. 4.; 5. 6]
2×2 Matrix{Float64}:
 3.0  4.0
 5.0  6.0

julia> B = [1. 1.; 1. 2.]
2×2 Matrix{Float64}:
 1.0  1.0
 1.0  2.0

julia> X = lyap(A, B)
2×2 Matrix{Float64}:
  0.5  -0.5
 -0.5   0.25

julia> A*X + X*A' ≈ -B
true

sylvester(A, B, C)

실베스터 방정식 AX + XB + C = 0의 해 X를 계산합니다. 여기서 A, B 및 C는 호환 가능한 차원을 가지며 A와 -B는 실수가 같은 고유값을 가지지 않습니다.

예제

julia> A = [3. 4.; 5. 6]
2×2 Matrix{Float64}:
 3.0  4.0
 5.0  6.0

julia> B = [1. 1.; 1. 2.]
2×2 Matrix{Float64}:
 1.0  1.0
 1.0  2.0

julia> C = [1. 2.; -2. 1]
2×2 Matrix{Float64}:
  1.0  2.0
 -2.0  1.0

julia> X = sylvester(A, B, C)
2×2 Matrix{Float64}:
 -4.46667   1.93333
  3.73333  -1.8

julia> A*X + X*B ≈ -C
true

issuccess(F::Factorization)

행렬의 인수가 성공적으로 이루어졌는지 테스트합니다.

예제

julia> F = cholesky([1 0; 0 1]);

julia> issuccess(F)
true

issuccess(F::LU; allowsingular = false)

행렬의 LU 분해가 성공했는지 테스트합니다. 기본적으로 유효하지만 랭크가 부족한 U 인자를 생성하는 분해는 실패로 간주됩니다. allowsingular = true를 전달하여 이를 변경할 수 있습니다.

예제

julia> F = lu([1 2; 1 2], check = false);

julia> issuccess(F)
false

julia> issuccess(F, allowsingular = true)
true

issymmetric(A) -> Bool

행렬이 대칭인지 테스트합니다.

예제

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

julia> issymmetric(a)
true

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

julia> issymmetric(b)
false

isposdef(A) -> Bool

행렬이 양의 정부호(및 에르미트)인지 확인하기 위해 A의 콜레스키 분해를 시도합니다.

자세한 내용은 isposdef!, cholesky를 참조하세요.

예제

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

julia> isposdef(A)
true

isposdef!(A) -> Bool

행렬이 양의 정부호(및 에르미트)인지 확인하기 위해 A의 Cholesky 분해를 시도하여 A를 덮어씁니다. isposdef도 참조하십시오.

예제

julia> A = [1. 2.; 2. 50.];

julia> isposdef!(A)
true

julia> A
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  6.78233

istril(A::AbstractMatrix, k::Integer = 0) -> Bool

A가 k번째 초대각선에서 시작하는 하삼각 행렬인지 테스트합니다.

예제

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

julia> istril(a)
false

julia> istril(a, 1)
true

julia> c = [1 1 0; 1 1 1; 1 1 1]
3×3 Matrix{Int64}:
 1  1  0
 1  1  1
 1  1  1

julia> istril(c)
false

julia> istril(c, 1)
true

istriu(A::AbstractMatrix, k::Integer = 0) -> Bool

A가 k번째 초대각선에서 시작하는 상삼각행렬인지 테스트합니다.

예시

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

julia> istriu(a)
false

julia> istriu(a, -1)
true

julia> c = [1 1 1; 1 1 1; 0 1 1]
3×3 Matrix{Int64}:
 1  1  1
 1  1  1
 0  1  1

julia> istriu(c)
false

julia> istriu(c, -1)
true

isdiag(A) -> Bool

행렬이 대각선인지 테스트합니다. iszero(A[i,j])가 i == j가 아닌 경우에 참인 경우입니다. A가 정사각형일 필요는 없으며, 정사각형인지도 확인하고 싶다면 size(A, 1) == size(A, 2)를 확인해야 합니다.

예제

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

julia> isdiag(a)
false

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

julia> isdiag(b)
true

julia> c = [1 0 0; 0 2 0]
2×3 Matrix{Int64}:
 1  0  0
 0  2  0

julia> isdiag(c)
true

julia> d = [1 0 0; 0 2 3]
2×3 Matrix{Int64}:
 1  0  0
 0  2  3

julia> isdiag(d)
false

ishermitian(A) -> Bool

행렬이 에르미트인지 테스트합니다.

예시

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

julia> ishermitian(a)
true

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

julia> ishermitian(b)
true

transpose(A)

지연 전치. 반환된 객체를 변형하면 A도 적절하게 변형됩니다. 종종, 그러나 항상 그런 것은 아니며, Transpose(A)를 생성합니다. 여기서 Transpose는 지연 전치 래퍼입니다. 이 작업은 재귀적이라는 점에 유의하십시오.

이 작업은 선형 대수 사용을 위해 의도되었습니다 - 일반 데이터 조작에 대해서는 permutedims를 참조하십시오. 이는 비재귀적입니다.

예제

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

julia> B = transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 3  0
 2  0

julia> B isa Transpose
true

julia> transpose(B) === A # 전치의 전치는 부모를 풀어냅니다
true

julia> Transpose(B) # 그러나 생성자는 항상 인수를 래핑합니다
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # B를 수정하면 A도 자동으로 수정됩니다

julia> A
2×2 Matrix{Int64}:
 3  2
 4  0

복소 행렬의 경우, adjoint 연산은 켤레 전치와 동등합니다.

julia> A = reshape([Complex(x, x) for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> adjoint(A) == conj(transpose(A))
true

AbstractVector의 transpose는 행 벡터입니다:

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

julia> transpose(v) # 행 벡터를 반환합니다
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # 내적을 계산합니다
14

행렬의 행렬에 대해 개별 블록은 재귀적으로 작동합니다:

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

julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # 블록 행렬을 구성합니다
2×2 Matrix{Matrix{Int64}}:
 [1 3; 2 4]  [3 9; 6 12]
 [2 6; 4 8]  [4 12; 8 16]

julia> transpose(D) # 블록이 재귀적으로 전치됩니다
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 2; 3 4]   [2 4; 6 8]
 [3 6; 9 12]  [4 8; 12 16]

transpose(F::Factorization)

팩토리제이션 F의 지연 전치. 기본적으로 TransposeFactorization를 반환하지만, 실수 eltype을 가진 Factorization의 경우 AdjointFactorization를 반환합니다.

transpose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

행렬 A를 전치하여 행렬 X에 저장합니다. size(X)는 size(transpose(A))와 같아야 합니다. 필요할 경우 X의 rowval 및 nzval 크기를 조정하는 것 외에는 추가 메모리가 할당되지 않습니다.

halfperm!를 참조하세요.

transpose!(dest,src)

배열 src를 전치하고 결과를 미리 할당된 배열 dest에 저장합니다. dest의 크기는 (size(src,2),size(src,1))에 해당해야 합니다. 제자리 전치는 지원되지 않으며, src와 dest가 겹치는 메모리 영역을 가지면 예기치 않은 결과가 발생할 수 있습니다.

예제

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> transpose!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3+2im  8+7im
 9+2im  4+6im

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

전치

기본 선형 대수 객체의 전치 뷰에 대한 게으른 래퍼 유형으로, 일반적으로 AbstractVector/AbstractMatrix입니다. 일반적으로 Transpose 생성자는 직접 호출하지 말고 대신 transpose를 사용하십시오. 뷰를 구체화하려면 copy를 사용하십시오.

이 유형은 선형 대수 사용을 위해 설계되었습니다 - 일반 데이터 조작에 대해서는 permutedims를 참조하십시오.

예제

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

julia> Transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 2  0
 3  0

TransposeFactorization

기본 Factorization 객체의 전치에 대한 지연 래퍼 유형입니다. 일반적으로 TransposeFactorization 생성자는 직접 호출하지 않아야 하며, 대신 transpose(:: Factorization)를 사용하십시오.

A'
adjoint(A)

게으른 수반(켤레 전치). adjoint는 요소에 재귀적으로 적용된다는 점에 유의하십시오.

숫자 유형의 경우, adjoint는 복소수 켤레를 반환하며, 따라서 실수에 대해서는 항등 함수와 동일합니다.

이 작업은 선형 대수 사용을 위해 의도되었습니다 - 일반 데이터 조작에 대해서는 permutedims를 참조하십시오.

예제

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

julia> B = A' # equivalently adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

julia> B isa Adjoint
true

julia> adjoint(B) === A # 수반의 수반은 부모를 풀어냅니다
true

julia> Adjoint(B) # 그러나 생성자는 항상 인수를 래핑합니다
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) with eltype Complex{Int64}:
 3+2im  9+2im
 0+0im  0+0im

julia> B[1,2] = 4 + 5im; # B를 수정하면 A도 자동으로 수정됩니다

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 4-5im  0+0im

실수 행렬의 경우, adjoint 작업은 transpose와 동일합니다.

julia> A = reshape([x for x in 1:4], 2, 2)
2×2 Matrix{Int64}:
 1  3
 2  4

julia> A'
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
 1  2
 3  4

julia> adjoint(A) == transpose(A)
true

AbstractVector의 수반은 행 벡터입니다:

julia> x = [3, 4im]
2-element Vector{Complex{Int64}}:
 3 + 0im
 0 + 4im

julia> x'
1×2 adjoint(::Vector{Complex{Int64}}) with eltype Complex{Int64}:
 3+0im  0-4im

julia> x'x # 내적을 계산합니다, 동등하게 x' * x
25 + 0im

행렬의 행렬에 대해 개별 블록은 재귀적으로 작동합니다:

julia> A = reshape([x + im*x for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> C = reshape([A, 2A, 3A, 4A], 2, 2)
2×2 Matrix{Matrix{Complex{Int64}}}:
 [1+1im 3+3im; 2+2im 4+4im]  [3+3im 9+9im; 6+6im 12+12im]
 [2+2im 6+6im; 4+4im 8+8im]  [4+4im 12+12im; 8+8im 16+16im]

julia> C'
2×2 adjoint(::Matrix{Matrix{Complex{Int64}}}) with eltype Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
 [1-1im 2-2im; 3-3im 4-4im]    [2-2im 4-4im; 6-6im 8-8im]
 [3-3im 6-6im; 9-9im 12-12im]  [4-4im 8-8im; 12-12im 16-16im]

adjoint(F::Factorization)

팩토리제이션 F의 지연된 어드전트. 기본적으로 AdjointFactorization 래퍼를 반환합니다.

adjoint!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

행렬 A의 전치 행렬을 변환하고 행렬 X의 요소의 어드조인트를 저장합니다. size(X)는 size(transpose(A))와 같아야 합니다. 필요할 경우 X의 rowval 및 nzval을 크기 조정하는 것 외에는 추가 메모리가 할당되지 않습니다.

halfperm!을 참조하세요.

adjoint!(dest,src)

켤레 전치 배열 src를 계산하고 결과를 미리 할당된 배열 dest에 저장합니다. dest의 크기는 (size(src,2),size(src,1))에 해당해야 합니다. 제자리 전치는 지원되지 않으며, src와 dest가 겹치는 메모리 영역을 가지면 예기치 않은 결과가 발생할 수 있습니다.

예제

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> adjoint!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3-2im  8-7im
 9-2im  4-6im

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

Adjoint

기본 선형 대수 객체의 어드전트 뷰에 대한 지연 래퍼 유형으로, 일반적으로 AbstractVector/AbstractMatrix입니다. 일반적으로 Adjoint 생성자는 직접 호출하지 말고 대신 adjoint를 사용하십시오. 뷰를 구체화하려면 copy를 사용하십시오.

이 유형은 선형 대수 사용을 위해 설계되었습니다 - 일반 데이터 조작에 대해서는 permutedims를 참조하십시오.

예제

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

julia> Adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

AdjointFactorization

기본 Factorization 객체의 수반을 위한 지연 래퍼 유형입니다. 일반적으로 AdjointFactorization 생성자는 직접 호출하지 않아야 하며, 대신 adjoint(:: Factorization)를 사용하십시오.

copy(A::Transpose)
copy(A::Adjoint)

지연 행렬 전치/수반을 즉시 평가합니다. 전치는 요소에 재귀적으로 적용된다는 점에 유의하십시오.

이 작업은 선형 대수 사용을 위해 의도되었습니다 - 일반 데이터 조작에 대해서는 permutedims를 참조하십시오. 이는 비재귀적입니다.

예제

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

julia> T = transpose(A)
2×2 transpose(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 1+0im  0-3im
 0+2im  4+0im

julia> copy(T)
2×2 Matrix{Complex{Int64}}:
 1+0im  0-3im
 0+2im  4+0im

stride1(A) -> Int

배열 요소 간의 거리를 요소 크기 단위로 차원 1에서 반환합니다.

예시

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

julia> LinearAlgebra.stride1(A)
1

julia> B = view(A, 2:2:4)
2-element view(::Vector{Int64}, 2:2:4) with eltype Int64:
 2
 4

julia> LinearAlgebra.stride1(B)
2

LinearAlgebra.checksquare(A)

행렬이 정사각형인지 확인한 다음, 공통 차원을 반환합니다. 여러 인수가 있는 경우 벡터를 반환합니다.

예제

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

julia> LinearAlgebra.checksquare(A, B)
2-element Vector{Int64}:
 4
 5

LinearAlgebra.peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3, parallel::Bool=false)

peakflops는 이중 정밀도 gemm!를 사용하여 컴퓨터의 최대 플롭 비율을 계산합니다. 기본적으로 인수가 지정되지 않으면 n x n 크기의 두 개의 Float64 행렬을 곱하며, 여기서 n = 4096입니다. 기본 BLAS가 여러 스레드를 사용하는 경우 더 높은 플롭 비율이 실현됩니다. BLAS 스레드 수는 BLAS.set_num_threads(n)로 설정할 수 있습니다.

키워드 인수 eltype이 제공되면, peakflops는 최대 플롭 비율을 계산하기 위해 eltype 유형의 요소를 가진 행렬을 구성합니다.

기본적으로 peakflops는 3회의 실험 중 가장 좋은 타이밍을 사용합니다. ntrials 키워드 인수가 제공되면, peakflops는 최상의 타이밍을 선택하기 위해 그만큼의 실험을 사용합니다.

키워드 인수 parallel이 true로 설정되면, peakflops는 모든 작업 프로세서에서 병렬로 실행됩니다. 전체 병렬 컴퓨터의 플롭 비율이 반환됩니다. 병렬로 실행할 때는 1개의 BLAS 스레드만 사용됩니다. 인수 n은 여전히 각 프로세서에서 해결되는 문제의 크기를 나타냅니다.

hermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

정사각형 행렬 A의 에르미트 부분을 반환합니다. 이는 (A + A') / 2로 정의되며, Hermitian 행렬로 반환됩니다. 실수 행렬 A의 경우, 이는 A의 대칭 부분으로도 알려져 있으며, 때때로 "연산자 실수 부분"이라고도 불립니다. 선택적 인수 uplo는 Hermitian 뷰의 해당 인수를 제어합니다. 실수 행렬의 경우, 후자는 Symmetric 뷰와 동등합니다.

상응하는 제자리 연산에 대해서는 hermitianpart!를 참조하십시오.

hermitianpart!(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

정사각형 행렬 A를 제자리에서 그 에르미트 부분 (A + A') / 2로 덮어쓰고, Hermitian(A, uplo)를 반환합니다. 실수 행렬 A의 경우, 이는 A의 대칭 부분으로도 알려져 있습니다.

상응하는 비제자리 연산에 대해서는 hermitianpart를 참조하십시오.

copy_adjoint!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

행렬 A의 요소를 다음과 같이 어드전션을 사용하여 B에 효율적으로 복사합니다:

B[ir_dest, jr_dest] = adjoint(A)[jr_src, ir_src]

요소 B[ir_dest, jr_dest]는 덮어쓰여집니다. 또한, 인덱스 범위 매개변수는 length(ir_dest) == length(jr_src) 및 length(jr_dest) == length(ir_src)를 만족해야 합니다.

copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

행렬 A의 요소를 전치하여 B에 효율적으로 복사합니다:

B[ir_dest, jr_dest] = transpose(A)[jr_src, ir_src]

요소 B[ir_dest, jr_dest]는 덮어쓰여집니다. 또한, 인덱스 범위 매개변수는 length(ir_dest) == length(jr_src) 및 length(jr_dest) == length(ir_src)를 만족해야 합니다.

copy_transpose!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
                tM::AbstractChar,
                M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B

행렬 M의 요소를 문자 매개변수 tM에 따라 B로 효율적으로 복사합니다:

요소 B[ir_dest, jr_dest]는 덮어쓰여집니다. 또한, 인덱스 범위 매개변수는 length(ir_dest) == length(jr_src) 및 length(jr_dest) == length(ir_src)를 만족해야 합니다.

또한 copyto! 및 copy_adjoint!를 참조하십시오.

mul!(Y, A, B) -> Y

행렬-행렬 또는 행렬-벡터 곱 $A B$를 계산하고 결과를 Y에 저장하여 기존의 Y 값을 덮어씁니다. Y는 A 또는 B와 별칭이 되어서는 안 됩니다.

예제

julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; Y = similar(B);

julia> mul!(Y, A, B) === Y
true

julia> Y
2×2 Matrix{Float64}:
 3.0  3.0
 7.0  7.0

julia> Y == A * B
true

구현

사용자 정의 행렬 및 벡터 유형의 경우, 가능하다면 3-인수 mul!를 직접 구현하기보다는 5-인수 mul!를 구현하는 것이 좋습니다.

mul!(C, A, B, α, β) -> C

결합된 제자리 행렬-행렬 또는 행렬-벡터 곱셈-덧셈 $A B α + C β$. 결과는 C에 저장되며, 이를 덮어씁니다. C는 A 또는 B와 별개이어야 합니다.

예제

julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; C = [1.0 2.0; 3.0 4.0];

julia> α, β = 100.0, 10.0;

julia> mul!(C, A, B, α, β) === C
true

julia> C
2×2 Matrix{Float64}:
 310.0  320.0
 730.0  740.0

julia> C_original = [1.0 2.0; 3.0 4.0]; # C의 원래 값의 복사본

julia> C == A * B * α + C_original * β
true

lmul!(a::Number, B::AbstractArray)

스칼라 a로 배열 B를 스케일링하여 B를 제자리에서 덮어씁니다. 스칼라를 오른쪽에서 곱하려면 rmul!를 사용하세요. 스케일링 작업은 a와 B의 요소 간의 곱셈 *의 의미를 존중합니다. 특히, 이는 NaN 및 ±Inf와 같은 비유한 숫자를 포함하는 곱셈에도 적용됩니다.

예제

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

julia> lmul!(2, B)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> lmul!(0.0, [Inf])
1-element Vector{Float64}:
 NaN

lmul!(A, B)

행렬-행렬 곱 $AB$를 계산하고 B를 덮어쓰며 결과를 반환합니다. 여기서 A는 Diagonal, UpperTriangular 또는 LowerTriangular와 같은 특수 행렬 유형이거나, QR에서 볼 수 있는 일부 직교 유형이어야 합니다.

예제

julia> B = [0 1; 1 0];

julia> A = UpperTriangular([1 2; 0 3]);

julia> lmul!(A, B);

julia> B
2×2 Matrix{Int64}:
 2  1
 3  0

julia> B = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> lmul!(F.Q, B)
2×2 Matrix{Float64}:
 3.0  4.0
 1.0  2.0

rmul!(A::AbstractArray, b::Number)

배열 A를 스칼라 b로 스케일링하여 A를 제자리에서 덮어씁니다. 스칼라를 왼쪽에서 곱하려면 lmul!를 사용하세요. 스케일링 작업은 A의 요소와 b 사이의 곱셈 *의 의미를 존중합니다. 특히, 이는 NaN 및 ±Inf와 같은 비유한 숫자를 포함하는 곱셈에도 적용됩니다.

예제

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

julia> rmul!(A, 2)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> rmul!([NaN], 0.0)
1-element Vector{Float64}:
 NaN

rmul!(A, B)

행렬-행렬 곱 $AB$를 계산하여 A를 덮어쓰고 결과를 반환합니다. 여기서 B는 Diagonal, UpperTriangular 또는 LowerTriangular와 같은 특수 행렬 유형이거나, QR와 같은 일부 직교 유형이어야 합니다.

예제

julia> A = [0 1; 1 0];

julia> B = UpperTriangular([1 2; 0 3]);

julia> rmul!(A, B);

julia> A
2×2 Matrix{Int64}:
 0  3
 1  2

julia> A = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> rmul!(A, F.Q)
2×2 Matrix{Float64}:
 2.0  1.0
 4.0  3.0

ldiv!(Y, A, B) -> Y

A \ B를 제자리에서 계산하고 결과를 Y에 저장하며 결과를 반환합니다.

인수 A는 행렬이 아니어야 합니다. 오히려 행렬 대신에 인수는 인수분해 객체여야 합니다(예: factorize 또는 cholesky로 생성된). 그 이유는 인수분해 자체가 비용이 많이 들고 일반적으로 메모리를 할당하기 때문입니다(비록 lu!와 같은 방법으로 제자리에서 수행할 수도 있지만), 그리고 ldiv!를 요구하는 성능이 중요한 상황은 일반적으로 A의 인수분해에 대한 세밀한 제어를 요구합니다.

예제

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> X = [1; 2.5; 3];

julia> Y = zero(X);

julia> ldiv!(Y, qr(A), X);

julia> Y ≈ A\X
true

ldiv!(A, B)

A \ B를 제자리에서 계산하고 결과를 저장하기 위해 B를 덮어씁니다.

인수 A는 행렬이 아니어야 합니다. 오히려 행렬 대신에 인수는 인수분해 객체여야 합니다(예: factorize 또는 cholesky로 생성된). 그 이유는 인수분해 자체가 비용이 많이 들고 일반적으로 메모리를 할당하기 때문입니다(비록 lu!와 같은 방법으로 제자리에서 수행할 수도 있지만), 그리고 ldiv!를 요구하는 성능이 중요한 상황은 일반적으로 A의 인수분해에 대한 세밀한 제어를 요구합니다.

예제

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> X = [1; 2.5; 3];

julia> Y = copy(X);

julia> ldiv!(qr(A), X);

julia> X ≈ A\Y
true

ldiv!(a::Number, B::AbstractArray)

스칼라 a로 배열 B의 각 항목을 나누고 B를 제자리에서 덮어씁니다. 오른쪽에서 스칼라를 나누려면 rdiv!를 사용하세요.

예제

julia> B = [1.0 2.0; 3.0 4.0]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> ldiv!(2.0, B)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0

ldiv!(A::Tridiagonal, B::AbstractVecOrMat) -> B

가우스 소거법을 사용하여 A \ B를 제자리에서 계산하고 결과를 B에 저장하며 결과를 반환합니다. 이 과정에서 A의 대각선도 덮어씌워집니다.

rdiv!(A, B)

A / B를 제자리에서 계산하고 결과를 저장하기 위해 A를 덮어씁니다.

인수 B는 행렬이 아니어야 합니다. 대신, 행렬 대신에 인수는 인수분해 객체여야 합니다(예: factorize 또는 cholesky로 생성된). 그 이유는 인수분해 자체가 비용이 많이 들고 일반적으로 메모리를 할당하기 때문입니다(비록 lu!와 같은 방법으로 제자리에서 수행할 수도 있지만), 그리고 rdiv!를 요구하는 성능이 중요한 상황은 일반적으로 B의 인수분해에 대한 세밀한 제어를 요구합니다.

rdiv!(A::AbstractArray, b::Number)

배열 A의 각 항목을 스칼라 b로 나누고 A를 제자리에서 덮어씁니다. 왼쪽에서 스칼라를 나누려면 ldiv!를 사용하세요.

예제

julia> A = [1.0 2.0; 3.0 4.0]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> rdiv!(A, 2.0)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0

BLAS 서브루틴에 대한 인터페이스.

set_num_threads(n::Integer)
set_num_threads(::Nothing)

BLAS 라이브러리가 사용할 스레드 수를 n::Integer와 같게 설정합니다.

또한 nothing을 허용하며, 이 경우 줄리아는 기본 스레드 수를 추측하려고 시도합니다. nothing을 전달하는 것은 권장되지 않으며 주로 역사적인 이유로 존재합니다.

get_num_threads()

BLAS 라이브러리가 사용하는 스레드 수를 가져옵니다.

rot!(n, X, incx, Y, incy, c, s)

X를 c*X + s*Y로 덮어쓰고 Y를 -conj(s)*X + c*Y로 덮어씁니다. 배열 X의 첫 n 요소와 보폭 incx를 사용하고 배열 Y의 첫 n 요소와 보폭 incy를 사용합니다. X와 Y를 반환합니다.

scal!(n, a, X, incx)
scal!(a, X)

배열 X의 처음 n 요소를 a*X로 덮어씁니다. 보폭은 incx입니다. X를 반환합니다.

n과 incx가 제공되지 않으면 length(X)와 stride(X,1)이 사용됩니다.

scal(n, a, X, incx)
scal(a, X)

X를 a로 스케일링하여 배열 X의 처음 n 요소를 incx의 보폭으로 반환합니다.

n과 incx가 제공되지 않으면 length(X)와 stride(X,1)이 사용됩니다.

blascopy!(n, X, incx, Y, incy)

배열 X의 n 요소를 보폭 incx로 배열 Y에 보폭 incy로 복사합니다. Y를 반환합니다.

dot(n, X, incx, Y, incy)

두 벡터의 내적, 배열 X의 n 요소와 보폭 incx, 배열 Y의 n 요소와 보폭 incy로 구성됩니다.

예제

julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0

dotu(n, X, incx, Y, incy)

두 개의 복소수 벡터에 대한 Dot 함수로, 배열 X의 n 요소와 보폭 incx, 배열 Y의 n 요소와 보폭 incy로 구성됩니다.

예제

julia> BLAS.dotu(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
-10.0 + 10.0im

dotc(n, X, incx, U, incy)

두 개의 복소수 벡터에 대한 Dot 함수로, stride incx를 가진 배열 X의 n 요소와 stride incy를 가진 배열 U의 n 요소로 구성되며, 첫 번째 벡터를 켤레합니다.

예제

julia> BLAS.dotc(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
10.0 - 10.0im

nrm2(n, X, incx)

incx의 보폭을 가진 배열 X의 n 요소로 구성된 벡터의 2-노름입니다.

예제

julia> BLAS.nrm2(4, fill(1.0, 8), 2)
2.0

julia> BLAS.nrm2(1, fill(1.0, 8), 2)
1.0

asum(n, X, incx)

배열 X의 첫 번째 n 요소의 크기의 합을 stride incx로 계산합니다.

실수 배열의 경우, 크기는 절대값입니다. 복소수 배열의 경우, 크기는 실수 부분의 절대값과 허수 부분의 절대값의 합입니다.

예제

julia> BLAS.asum(5, fill(1.0im, 10), 2)
5.0

julia> BLAS.asum(2, fill(1.0im, 10), 5)
2.0

iamax(n, dx, incx)
iamax(dx)

dx의 최대 절대값을 가진 요소의 인덱스를 찾습니다. n은 dx의 길이이며, incx는 보폭입니다. n과 incx가 제공되지 않으면 기본값인 n=length(dx)와 incx=stride1(dx)를 가정합니다.

gemv!(tA, alpha, A, x, beta, y)

벡터 y를 alpha*A*x + beta*y 또는 alpha*A'x + beta*y로 업데이트합니다. tA에 따라 다릅니다. alpha와 beta는 스칼라입니다. 업데이트된 y를 반환합니다.

gemv(tA, alpha, A, x)

alpha*A*x 또는 alpha*A'x를 반환합니다. tA에 따라 다릅니다. alpha는 스칼라입니다.

gemv(tA, A, x)

A*x 또는 A'x를 tA에 따라 반환합니다.

gbmv!(trans, m, kl, ku, alpha, A, x, beta, y)

벡터 y를 alpha*A*x + beta*y 또는 alpha*A'*x + beta*y로 업데이트합니다. 이는 trans에 따라 다릅니다. 행렬 A는 m x size(A,2) 크기의 일반 밴드 행렬로, kl 개의 하삼각 대각선과 ku 개의 상삼각 대각선을 가집니다. alpha와 beta는 스칼라입니다. 업데이트된 y를 반환합니다.

gbmv(trans, m, kl, ku, alpha, A, x)

trans에 따라 alpha*A*x 또는 alpha*A'*x를 반환합니다. 행렬 A는 kl개의 하삼각 대각선과 ku개의 상삼각 대각선을 가진 m x size(A,2) 차원의 일반 밴드 행렬이며, alpha는 스칼라입니다.

hemv!(ul, alpha, A, x, beta, y)

벡터 y를 alpha*A*x + beta*y로 업데이트합니다. A는 에르미트 행렬로 가정됩니다. A의 ul 삼각형만 사용됩니다. alpha와 beta는 스칼라입니다. 업데이트된 y를 반환합니다.

hemv(ul, alpha, A, x)

alpha*A*x를 반환합니다. A는 에르미트 행렬로 가정됩니다. A의 ul 삼각형만 사용됩니다. alpha는 스칼라입니다.

hemv(ul, A, x)

A*x를 반환합니다. A는 에르미트 행렬로 가정됩니다. A의 ul 삼각형만 사용됩니다.

hpmv!(uplo, α, AP, x, β, y)

벡터 y를 α*A*x + β*y로 업데이트합니다. 여기서 A는 패킹 형식 AP로 제공된 에르미트 행렬입니다.

uplo = 'U'인 경우, 배열 AP는 에르미트 행렬의 상삼각 부분을 열 단위로 순차적으로 포함해야 하며, 따라서 AP[1]은 A[1, 1]을 포함하고, AP[2]와 AP[3]는 각각 A[1, 2]와 A[2, 2]를 포함해야 합니다. 계속해서 이와 같은 방식으로 진행됩니다.

uplo = 'L'인 경우, 배열 AP는 에르미트 행렬의 하삼각 부분을 열 단위로 순차적으로 포함해야 하며, 따라서 AP[1]은 A[1, 1]을 포함하고, AP[2]와 AP[3]는 각각 A[2, 1]과 A[3, 1]을 포함해야 합니다. 계속해서 이와 같은 방식으로 진행됩니다.

스칼라 입력 α와 β는 복소수 또는 실수여야 합니다.

배열 입력 x, y 및 AP는 모두 ComplexF32 또는 ComplexF64 유형이어야 합니다.

업데이트된 y를 반환합니다.

symv!(ul, alpha, A, x, beta, y)

벡터 y를 alpha*A*x + beta*y로 업데이트합니다. A는 대칭으로 가정됩니다. A의 ul 삼각형만 사용됩니다. alpha와 beta는 스칼라입니다. 업데이트된 y를 반환합니다.

symv(ul, alpha, A, x)

alpha*A*x를 반환합니다. A는 대칭으로 가정됩니다. A의 ul 삼각형만 사용됩니다. alpha는 스칼라입니다.

symv(ul, A, x)

A*x를 반환합니다. A는 대칭으로 가정됩니다. A의 ul 삼각형만 사용됩니다.

sbmv!(uplo, k, alpha, A, x, beta, y)

벡터 y를 alpha*A*x + beta*y로 업데이트합니다. 여기서 A는 size(A,2) 차원의 대칭 밴드 행렬이며, k개의 슈퍼 대각선이 인수 A에 저장되어 있습니다. A의 저장 레이아웃은 https://www.netlib.org/lapack/explore-html/의 참조 BLAS 모듈, 레벨-2 BLAS에서 설명되어 있습니다. 오직 uplo 삼각형의 A만 사용됩니다.

업데이트된 y를 반환합니다.

sbmv(uplo, k, alpha, A, x)

alpha*A*x를 반환합니다. 여기서 A는 인수 A에 저장된 k개의 초대각선을 가진 대칭 밴드 행렬이며, size(A,2)의 차수를 가집니다. 오직 uplo 삼각형의 A만 사용됩니다.

sbmv(uplo, k, A, x)

A*x를 반환합니다. 여기서 A는 인수 A에 저장된 k개의 초대각선을 가진 대칭 밴드 행렬이며, 차수는 size(A,2)입니다. 오직 uplo 삼각형의 A만 사용됩니다.

spmv!(uplo, α, AP, x, β, y)

벡터 y를 α*A*x + β*y로 업데이트합니다. 여기서 A는 패킹 형식 AP로 제공되는 대칭 행렬입니다.

uplo = 'U'인 경우, 배열 AP는 대칭 행렬의 상삼각 부분을 열 단위로 순차적으로 포함해야 하며, 따라서 AP[1]은 A[1, 1]을 포함하고, AP[2]와 AP[3]는 각각 A[1, 2]와 A[2, 2]를 포함해야 하며, 계속해서 진행됩니다.

uplo = 'L'인 경우, 배열 AP는 대칭 행렬의 하삼각 부분을 열 단위로 순차적으로 포함해야 하며, 따라서 AP[1]은 A[1, 1]을 포함하고, AP[2]와 AP[3]는 각각 A[2, 1]과 A[3, 1]을 포함해야 하며, 계속해서 진행됩니다.

스칼라 입력 α와 β는 실수여야 합니다.

배열 입력 x, y 및 AP는 모두 Float32 또는 Float64 유형이어야 합니다.

업데이트된 y를 반환합니다.

trmv!(ul, tA, dA, A, b)

op(A)*b를 반환합니다. 여기서 op는 tA에 의해 결정됩니다. A의 ul 삼각형만 사용됩니다. dA는 대각선 값이 읽히는지 아니면 모두 1로 가정되는지를 결정합니다. 곱셈은 b에서 제자리에서 발생합니다.

trmv(ul, tA, dA, A, b)

op(A)*b를 반환합니다. 여기서 op는 tA에 의해 결정됩니다. A의 ul 삼각형만 사용됩니다. dA는 대각선 값이 읽히는지 아니면 모두 1로 가정되는지를 결정합니다.

trsv!(ul, tA, dA, A, b)

A*x = b의 해로 b를 덮어쓰거나 tA 및 ul에 의해 결정된 다른 두 변형 중 하나로 덮어씁니다. dA는 대각선 값이 읽히는지 아니면 모두 1로 가정되는지를 결정합니다. 업데이트된 b를 반환합니다.

trsv(ul, tA, dA, A, b)

A*x = b의 해를 반환하거나 tA 및 ul에 의해 결정된 다른 두 변형 중 하나를 반환합니다. dA는 대각선 값이 읽히는지 아니면 모두 1로 가정되는지를 결정합니다.

ger!(alpha, x, y, A)

벡터 x와 y를 사용하여 행렬 A의 순위-1 업데이트를 수행합니다: alpha*x*y' + A.

her!(uplo, alpha, x, A)

복소 배열에 대해서만 사용 가능한 메서드입니다. Hermitian 행렬 A의 랭크-1 업데이트로 벡터 x를 사용하여 alpha*x*x' + A를 계산합니다. uplo는 업데이트할 A의 삼각형을 제어합니다. A를 반환합니다.

syr!(uplo, alpha, x, A)

대칭 행렬 A의 랭크-1 업데이트로, 벡터 x를 사용하여 alpha*x*transpose(x) + A로 업데이트합니다. uplo는 업데이트할 A의 삼각형을 제어합니다. A를 반환합니다.

spr!(uplo, α, x, AP)

행렬 A를 A+α*x*x'로 업데이트합니다. 여기서 A는 패킹 형식 AP로 제공되는 대칭 행렬이고, x는 벡터입니다.

uplo = 'U'인 경우, 배열 AP는 대칭 행렬의 상삼각 부분을 열 단위로 순차적으로 포함해야 하며, 따라서 AP[1]은 A[1, 1]을 포함하고, AP[2]와 AP[3]는 각각 A[1, 2]와 A[2, 2]를 포함해야 합니다. 계속해서 이와 같은 방식으로 진행됩니다.

uplo = 'L'인 경우, 배열 AP는 대칭 행렬의 하삼각 부분을 열 단위로 순차적으로 포함해야 하며, 따라서 AP[1]은 A[1, 1]을 포함하고, AP[2]와 AP[3]는 각각 A[2, 1]과 A[3, 1]을 포함해야 합니다. 계속해서 이와 같은 방식으로 진행됩니다.

스칼라 입력 α는 실수여야 합니다.

배열 입력 x와 AP는 모두 Float32 또는 Float64 유형이어야 합니다. 업데이트된 AP를 반환합니다.

gemmt!(uplo, tA, tB, alpha, A, B, beta, C)

지정된 uplo에 따라 C의 하삼각 또는 상삼각 부분을 alpha*A*B + beta*C 또는 tA 및 tB에 따라 다른 변형으로 업데이트합니다. 업데이트된 C를 반환합니다.

gemmt(uplo, tA, tB, alpha, A, B)

uplo에 의해 지정된 A*B의 하삼각 또는 상삼각 부분 또는 tA 및 tB에 따라 다른 세 가지 변형을 반환합니다.

gemmt(uplo, tA, tB, A, B)

uplo에 의해 지정된 A*B의 하삼각 또는 상삼각 부분 또는 tA 및 tB에 따라 다른 세 가지 변형을 반환합니다.

gemm!(tA, tB, alpha, A, B, beta, C)

C를 alpha*A*B + beta*C로 업데이트하거나 tA 및 tB에 따라 다른 세 가지 변형으로 업데이트합니다. 업데이트된 C를 반환합니다.

gemm(tA, tB, alpha, A, B)

alpha*A*B 또는 tA 및 tB에 따라 다른 세 가지 변형을 반환합니다.