Julia 1.0 - Linear Algebra

रेखीय बीजगणित




julia

रेखीय बीजगणित

(के रूप में) बहु-आयामी सरणियों के लिए इसके समर्थन के अलावा, जूलिया कई सामान्य और उपयोगी रैखिक बीजगणित संचालन के मूल कार्यान्वयन प्रदान करता है। मूल संचालन, जैसे कि tr , det , और inv सभी समर्थित हैं:

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

julia> tr(A)
3

julia> det(A)
104.0

julia> inv(A)
3×3 Array{Float64,2}:
 -0.451923   0.211538    0.0865385
  0.365385  -0.192308    0.0576923
  0.240385   0.0576923  -0.0673077

साथ ही अन्य उपयोगी ऑपरेशन, जैसे कि आइजनवेल्यूज या ईजेनवेक्टर ढूंढना:

julia> A = [-4. -17.; 2. 2.]
2×2 Array{Float64,2}:
 -4.0  -17.0
  2.0    2.0

julia> eigvals(A)
2-element Array{Complex{Float64},1}:
 -1.0 + 5.0im
 -1.0 - 5.0im

julia> eigvecs(A)
2×2 Array{Complex{Float64},2}:
  0.945905+0.0im        0.945905-0.0im
 -0.166924-0.278207im  -0.166924+0.278207im

इसके अलावा, जूलिया कई factorizations प्रदान करता factorizations जो समस्या को गति देने के लिए इस्तेमाल किया जा सकता है जैसे कि समस्या को और अधिक अमननीय (प्रदर्शन या स्मृति कारणों के लिए) मैट्रिक्स को पूर्व-कारक के रूप में गुणा करके। अधिक जानकारी के लिए factorize पर दस्तावेज़ देखें। उदाहरण के तौर पे:

julia> A = [1.5 2 -4; 3 -1 -6; -10 2.3 4]
3×3 Array{Float64,2}:
   1.5   2.0  -4.0
   3.0  -1.0  -6.0
 -10.0   2.3   4.0

julia> factorize(A)
LU{Float64,Array{Float64,2}}
L factor:
3×3 Array{Float64,2}:
  1.0    0.0       0.0
 -0.15   1.0       0.0
 -0.3   -0.132196  1.0
U factor:
3×3 Array{Float64,2}:
 -10.0  2.3     4.0
   0.0  2.345  -3.4
   0.0  0.0    -5.24947

चूंकि A हर्मिटियन नहीं है, सममित, त्रिकोणीय, त्रिदलीय, या द्विभुज, एक एलयू कारक सबसे अच्छा हो सकता है जो हम कर सकते हैं। तुलना करना:

julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Array{Float64,2}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

julia> factorize(B)
BunchKaufman{Float64,Array{Float64,2}}
D factor:
3×3 Tridiagonal{Float64,Array{Float64,1}}:
 -1.64286   0.0   â‹…
  0.0      -2.8  0.0
   â‹…        0.0  5.0
U factor:
3×3 UnitUpperTriangular{Float64,Array{Float64,2}}:
 1.0  0.142857  -0.8
  â‹…   1.0       -0.6
  â‹…    â‹…         1.0
permutation:
3-element Array{Int64,1}:
 1
 2
 3

यहां, जूलिया यह पता लगाने में सक्षम था कि B वास्तव में सममित है, और अधिक उपयुक्त कारक का उपयोग किया। अक्सर एक मैट्रिक्स के लिए अधिक कुशल कोड लिखना संभव होता है जिसे कुछ गुणों के लिए जाना जाता है जैसे कि यह सममित या त्रिदलीय है। जूलिया कुछ विशेष प्रकार प्रदान करता है ताकि आप इन गुणों के रूप में मेट्रिसेस को "टैग" कर सकें। उदाहरण के लिए:

julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Array{Float64,2}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

julia> sB = Symmetric(B)
3×3 Symmetric{Float64,Array{Float64,2}}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

sB को एक मैट्रिक्स के रूप में टैग किया गया है जो (वास्तविक) सममित है, इसलिए बाद के संचालन के लिए हम इस पर प्रदर्शन कर सकते हैं, जैसे कि eigenfactorization या कंप्यूटिंग मैट्रिक्स-वेक्टर उत्पाद, दक्षता केवल इसके आधे को संदर्भित करके पाई जा सकती है। उदाहरण के लिए:

julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Array{Float64,2}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

julia> sB = Symmetric(B)
3×3 Symmetric{Float64,Array{Float64,2}}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

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

julia> sB\x
3-element Array{Float64,1}:
 -1.7391304347826084
 -1.1086956521739126
 -1.4565217391304346

यहाँ \ ऑपरेशन रैखिक समाधान करता है। बाएं-डिवीजन ऑपरेटर बहुत शक्तिशाली है और कॉम्पैक्ट, पठनीय कोड को लिखना आसान है जो रैखिक समीकरणों के सभी प्रकार के सिस्टम को हल करने के लिए पर्याप्त लचीला है।

विशेष मेट्रिसेस

विशेष समरूपता और संरचनाओं वाले मैट्रिक्स अक्सर रैखिक बीजगणित में उत्पन्न होते हैं और अक्सर विभिन्न मैट्रिक्स कारकों के साथ जुड़े होते हैं। जूलिया में विशेष मैट्रिक्स प्रकारों का एक समृद्ध संग्रह है, जो विशेष रूटीन प्रकारों के लिए विशेष रूप से विकसित किए गए विशेष रूटीन के साथ तेजी से गणना की अनुमति देता है।

निम्न तालिकाएं जूलिया में लागू किए गए विशेष मैट्रीस के प्रकारों को संक्षेप में प्रस्तुत करती हैं, साथ ही साथ कि क्या लैपैक में उनके लिए विभिन्न अनुकूलित तरीकों के लिए हुक उपलब्ध हैं।

प्रकार विवरण
Symmetric सममित मैट्रिक्स
Hermitian हर्मिटियन मैट्रिक्स
UpperTriangular ऊपरी त्रिकोणीय मैट्रिक्स
LowerTriangular कम त्रिकोणीय मैट्रिक्स
Tridiagonal त्रिदोषज मैट्रिक्स
SymTridiagonal सममित त्रिदोषन मैट्रिक्स
Bidiagonal ऊपरी / निचली बीडीओगल मैट्रिक्स
Diagonal विकर्ण मैट्रिक्स
UniformScaling यूनिफॉर्म स्केलिंग ऑपरेटर

प्राथमिक संचालन

मैट्रिक्स प्रकार + - * \ अनुकूलित तरीकों के साथ अन्य कार्य
Symmetric एमवी inv , inv , inv
Hermitian एमवी inv , inv , inv
UpperTriangular एमवी एमवी inv , det
LowerTriangular एमवी एमवी inv , det
SymTridiagonal एम एम सुश्री एमवी eigmax , eigmin
Tridiagonal एम एम सुश्री एमवी
Bidiagonal एम एम सुश्री एमवी
Diagonal एम एम एमवी एमवी inv , det , logdet , /
UniformScaling एम एम MVS MVS /

लीजेंड:

कुंजी विवरण
एम (मैट्रिक्स) मैट्रिक्स-मैट्रिक्स ऑपरेशन के लिए एक अनुकूलित तरीका उपलब्ध है
वी (वेक्टर) मैट्रिक्स-वेक्टर ऑपरेशन के लिए एक अनुकूलित तरीका उपलब्ध है
एस (स्केलर) मैट्रिक्स-स्केलर ऑपरेशन के लिए एक अनुकूलित तरीका उपलब्ध है

मैट्रिक्स कारक

मैट्रिक्स प्रकार LAPACK eigen eigvals eigvecs svd svdvals
Symmetric एसवाई ARI
Hermitian वह ARI
UpperTriangular टी.आर.
LowerTriangular टी.आर.
SymTridiagonal अनुसूचित जनजाति ARI ए वी
Tridiagonal जी.टी.
Bidiagonal BD
Diagonal डि

लीजेंड:

कुंजी विवरण उदाहरण
A (सभी) सभी विशिष्ट मूल्यों और / या वैक्टर को खोजने के लिए एक अनुकूलित विधि उपलब्ध है उदाहरण के लिए eigvals(M)
आर (रेंज) ih वें के माध्यम से il वें को खोजने के लिए एक अनुकूलित विधि विशिष्ट मूल्य उपलब्ध हैं eigvals(M, il, ih)
मैं (अंतराल) अंतराल [ vl , vh ] में विशिष्ट मूल्यों को खोजने के लिए एक अनुकूलित विधि उपलब्ध है eigvals(M, vl, vh)
वी (वैक्टर) विशेषता मान x=[x1, x2,...] अनुरूप विशेषता वाले वैक्टर को खोजने के लिए एक अनुकूलित विधि उपलब्ध है eigvecs(M, x)

वर्दी स्केलिंग ऑपरेटर

एक UniformScaling ऑपरेटर UniformScaling ऑपरेटर, λ*I स्केलर समय का प्रतिनिधित्व करता है। पहचान संचालक I को एक स्थिर के रूप में परिभाषित किया गया है और यह UniformScaling उदाहरण है। इन ऑपरेटरों का आकार सामान्य है और बाइनरी ऑपरेशन + , inv , inv और inv में अन्य मैट्रिक्स से मेल खाते हैं। A+I और AI लिए इसका मतलब है कि A को चौकोर होना चाहिए। पहचान ऑपरेटर I साथ गुणा एक शून्य है (यह जांचने के लिए कि स्केलिंग कारक एक है) और इसलिए लगभग बिना ओवरहेड।

कार्रवाई में UniformScaling ऑपरेटर को देखने के लिए:

julia> U = UniformScaling(2);

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

julia> a + U
2×2 Array{Int64,2}:
 3  2
 3  6

julia> a * U
2×2 Array{Int64,2}:
 2  4
 6  8

julia> [a U]
2×4 Array{Int64,2}:
 1  2  2  0
 3  4  0  2

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

julia> b - U
ERROR: DimensionMismatch("matrix is not square: dimensions are (2, 3)")
Stacktrace:
[...]

मैट्रिक्स कारक

मैट्रिक्स कारक (उर्फ मैट्रिक्स डिकम्पोज़िशन) मैट्रिक्स के उत्पाद में मैट्रिक्स के गुणन की गणना करते हैं, और रैखिक बीजगणित में केंद्रीय अवधारणाओं में से एक हैं।

निम्नलिखित तालिका जूलिया में लागू किए गए मैट्रिक्स कारक के प्रकार को सारांशित करती है। उनके संबद्ध तरीकों का विवरण रैखिक बीजगणित प्रलेखन के मानक कार्य खंड में पाया जा सकता है।

प्रकार विवरण
Cholesky चोल्स्की कारक
CholeskyPivoted पिवोट चोल्स्की फैक्टराइजेशन
LU LU कारक
LUTridiagonal ट्रिडियोनियल मैट्रिस के लिए एलयू कारक
QR क्यूआर कारक
QRCompactWY क्यूआर कारक के कॉम्पैक्ट WY रूप
QRPivoted पाइवोटेड क्यूआर फैक्टराइजेशन
Hessenberg हेसेनबर्ग अपघटन
Eigen वर्णक्रमीय विघटन
SVD विलक्षण मान अपघटन
GeneralizedSVD सामान्यीकृत एसवीडी

मानक कार्य

जूलिया में रैखिक बीजगणित फ़ंक्शन काफी हद तक LAPACK कार्यों को कॉल करके कार्यान्वित किए जाते हैं। स्‍पार्स SuiteSparse , SuiteSparse कार्यों को SuiteSparse

Base.:* विधि

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

मैट्रिक्स गुणन।

उदाहरण

julia> [1 1; 0 1] * [1 0; 1 1]
2×2 Array{Int64,2}:
 2  1
 1  1
source

Base.:\ विधि

\(A, B)

पॉलिटेक्ल्म का उपयोग करके मैट्रिक्स विभाजन। इनपुट A और B लिए मैट्रिक्स, परिणाम X ऐसा है कि A*X == B जब A वर्ग है। उपयोग किया जाने वाला सॉल्वर A की संरचना पर निर्भर करता है। यदि A ऊपरी या निचला त्रिकोणीय (या विकर्ण) है, तो A के A भी गुणन की आवश्यकता नहीं होती है और सिस्टम को आगे या पीछे प्रतिस्थापन के साथ हल किया जाता है। गैर-त्रिकोणीय वर्ग मैट्रिस के लिए, एक एलयू कारक का उपयोग किया जाता है।

आयताकार A लिए परिणाम A के pivoted QR फ़ैक्टराइजेशन और A के R अनुमान के आधार पर रैंक का अनुमान द्वारा गणना किया गया न्यूनतम-मानक न्यूनतम वर्ग समाधान है।

जब A विरल होता है, तो एक समान पॉलीअल्गोरिथम का उपयोग किया जाता है। अनिश्चित मैट्रिसेस के लिए, LDLt फैक्टराइजेशन संख्यात्मक फैक्टराइजेशन के दौरान LDLt उपयोग नहीं करता है और इसलिए LDLt मैट्रिसेस के लिए भी प्रक्रिया विफल हो सकती है।

उदाहरण

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

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

julia> A * X == B
true
source

LinearAlgebra.dot फ़ंक्शन

dot(x, y)
x â‹… y

किसी भी चलने योग्य कंटेनरों के लिए x और y (किसी भी आयाम के सरणियों सहित) (या किसी भी तत्व प्रकार जिसके लिए dot को परिभाषित किया गया है), डॉट उत्पाद (या आंतरिक उत्पाद या स्केलर उत्पाद) की गणना करें, अर्थात dot(x[i],y[i]) का योग dot(x[i],y[i]) , जैसे कि वे वैक्टर थे।

x ⋅ y by x ⋅ y (जहां REPL में टैब-पूर्ण \cdot द्वारा टाइप किया जा सकता है) dot(x, y) का एक पर्याय है।

उदाहरण

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
source
dot(x, y)
x â‹… y

दो वैक्टर के बीच डॉट उत्पाद की गणना करें। जटिल वैक्टर के लिए, पहला वेक्टर संयुग्मित है। जब वैक्टर की लंबाई समान होती है, तो कॉलिंग शब्द मुख्य रूप sum(dot(vx,vy) for (vx,vy) in zip(x, y)) बराबर होता है sum(dot(vx,vy) for (vx,vy) in zip(x, y))

उदाहरण

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

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

LinearAlgebra.cross फ़ंक्शन

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

दो 3-वैक्टर के क्रॉस उत्पाद की गणना करें।

उदाहरण

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

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

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

LinearAlgebra.factorize फ़ंक्शन

factorize(A)

इनपुट मैट्रिक्स के प्रकार के आधार पर, A एक सुविधाजनक कारक की गणना करें। यह देखने के लिए कि क्या यह सममित / त्रिकोणीय है / आदि यदि A को जेनेरिक मैट्रिक्स के रूप में पास किया जाता है। प्रत्येक संपत्ति के सत्यापन / शासन के लिए A हर तत्व की जाँच करें। जैसे ही यह समरूपता / त्रिकोणीय संरचना को नियंत्रित कर सकता है, यह शॉर्ट-सर्किट होगा। कई प्रणालियों के कुशल समाधान के लिए रिटर्न वैल्यू का पुन: उपयोग किया जा सकता है। उदाहरण के लिए: A=factorize(A); x=A\b; y=A\C A=factorize(A); x=A\b; y=A\C A=factorize(A); x=A\b; y=A\C

A गुण कारक का प्रकार
सकारात्मक रूप से निश्चित चोल्स्की (चोल्स्की देखें)
घने सममित / हर्मिटियन बंच-कॉफमैन (देखें bunchkaufman )
विरल सममित / हर्मिटियन LDLt (ldlt देखें)
त्रिकोणीय त्रिकोणीय
विकर्ण विकर्ण
मैट्रिक्स Bidiagonal मैट्रिक्स Bidiagonal
tridiagonal लू (देखें lu )
सममित वास्तविक त्रिदोषजन्य LDLt (ldlt देखें)
सामान्य वर्ग लू (देखें lu )
सामान्य गैर-वर्ग QR ( qr देखें)

उदाहरण के लिए, यदि फैर्मिज़ को हर्मिटियन पॉजिटिव-निश्चित मैट्रिक्स पर कहा जाता है, तो फ़ैक्टिज़ एक चोल्स्की फ़ैक्टराइज़ेशन लौटाएगा।

उदाहरण

julia> A = Array(Bidiagonal(fill(1.0, (5, 5)), :U))
5×5 Array{Float64,2}:
 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 will check to see that A is already factorized
5×5 Bidiagonal{Float64,Array{Float64,1}}:
 1.0  1.0   â‹…    â‹…    â‹…
  â‹…   1.0  1.0   â‹…    â‹…
  â‹…    â‹…   1.0  1.0   â‹…
  â‹…    â‹…    â‹…   1.0  1.0
  â‹…    â‹…    â‹…    â‹…   1.0

यह एक 5×5 Bidiagonal{Float64} , जिसे अब अन्य रैखिक बीजगणित कार्यों (जैसे 5×5 Bidiagonal{Float64} पारित किया जा सकता है जो Bidiagonal प्रकारों के लिए विशेष विधियों का उपयोग करेगा।

source

LinearAlgebra.Diagonal प्रकार

Diagonal(A::AbstractMatrix)

A के विकर्ण से एक मैट्रिक्स का निर्माण करें।

उदाहरण

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

julia> Diagonal(A)
3×3 Diagonal{Int64,Array{Int64,1}}:
 1  â‹…  â‹…
 â‹…  5  â‹…
 â‹…  â‹…  9
source
Diagonal(V::AbstractVector)

अपने विकर्ण के रूप में V साथ एक मैट्रिक्स का निर्माण करें।

उदाहरण

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

julia> Diagonal(V)
2×2 Diagonal{Int64,Array{Int64,1}}:
 1  â‹…
 â‹…  2
source

LinearAlgebra.Bidiagonal प्रकार

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

एक ऊपरी ( uplo=:U ) या लोअर ( uplo=:L ) को द्विभुज मैट्रिक्स को दिए गए विकर्ण ( dv ) और ऑफ-विकर्ण ( ev ) वैक्टर का उपयोग करते हुए बनाता है। इसका परिणाम Bidiagonal प्रकार का Bidiagonal और कुशल विशिष्ट रेखीय सॉल्वर प्रदान करता है, लेकिन इसे convert(Array, _) (या Array(_) शॉर्ट के लिए Array(_) के साथ एक नियमित मैट्रिक्स में परिवर्तित किया जा सकता है। ev की लंबाई dv की लंबाई से कम होनी चाहिए।

उदाहरण

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

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

julia> Bu = Bidiagonal(dv, ev, :U) # ev is on the first superdiagonal
4×4 Bidiagonal{Int64,Array{Int64,1}}:
 1  7  â‹…  â‹…
 â‹…  2  8  â‹…
 â‹…  â‹…  3  9
 â‹…  â‹…  â‹…  4

julia> Bl = Bidiagonal(dv, ev, :L) # ev is on the first subdiagonal
4×4 Bidiagonal{Int64,Array{Int64,1}}:
 1  â‹…  â‹…  â‹…
 7  2  â‹…  â‹…
 â‹…  8  3  â‹…
 â‹…  â‹…  9  4
source
Bidiagonal(A, uplo::Symbol)

A के मुख्य विकर्ण से एक Bidiagonal मैट्रिक्स का निर्माण करें और इसका पहला सुपर- (यदि uplo=:U ) या उप-विकर्ण (if uplo=:L )।

उदाहरण

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

julia> Bidiagonal(A, :U) # contains the main diagonal and first superdiagonal of A
4×4 Bidiagonal{Int64,Array{Int64,1}}:
 1  1  â‹…  â‹…
 â‹…  2  2  â‹…
 â‹…  â‹…  3  3
 â‹…  â‹…  â‹…  4

julia> Bidiagonal(A, :L) # contains the main diagonal and first subdiagonal of A
4×4 Bidiagonal{Int64,Array{Int64,1}}:
 1  â‹…  â‹…  â‹…
 2  2  â‹…  â‹…
 â‹…  3  3  â‹…
 â‹…  â‹…  4  4
source

LinearAlgebra.SymTridiagonal प्रकार

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

क्रमशः विकर्ण ( dv ) और पहले उप / सुपर-विकर्ण ( ev ) से एक सममित ट्राइडियोगल मैट्रिक्स का निर्माण करें। परिणाम SymTridiagonal प्रकार का SymTridiagonal और कुशल विशिष्ट SymTridiagonal प्रदान करता है, लेकिन इसे convert(Array, _) (या Array(_) शॉर्ट के लिए Array(_) के साथ एक नियमित मैट्रिक्स में परिवर्तित किया जा सकता है।

उदाहरण

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

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

julia> SymTridiagonal(dv, ev)
4×4 SymTridiagonal{Int64,Array{Int64,1}}:
 1  7  â‹…  â‹…
 7  2  8  â‹…
 â‹…  8  3  9
 â‹…  â‹…  9  4
source
SymTridiagonal(A::AbstractMatrix)

सममित मैट्रिक्स A के विकर्ण और पहले उप / सुपर-विकर्ण से एक सममित त्रिदोष मैट्रिक्स का निर्माण करें।

उदाहरण

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

julia> SymTridiagonal(A)
3×3 SymTridiagonal{Int64,Array{Int64,1}}:
 1  2  â‹…
 2  4  5
 â‹…  5  6
source

LinearAlgebra.Tridiagonal प्रकार

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

क्रमशः पहले सबडागोनल, विकर्ण और पहले सुपरडायंगल से एक त्रिदिओगनल मैट्रिक्स का निर्माण करते हैं। इसका परिणाम Tridiagonal प्रकार का है और कुशल विशिष्ट रैखिक Tridiagonal प्रदान करता है, लेकिन convert(Array, _) (या 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,Array{Int64,1}}:
 7  4  â‹…  â‹…
 1  8  5  â‹…
 â‹…  2  9  6
 â‹…  â‹…  3  0
source
Tridiagonal(A)

मैट्रिक्स ए के पहले उप-विकर्ण, विकर्ण और पहले सुपर-विकर्ण से एक त्रिभुज मैट्रिक्स का निर्माण करें।

उदाहरण

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

julia> Tridiagonal(A)
4×4 Tridiagonal{Int64,Array{Int64,1}}:
 1  2  â‹…  â‹…
 1  2  3  â‹…
 â‹…  2  3  4
 â‹…  â‹…  3  4
source

LinearAlgebra.Symmetric प्रकार

Symmetric(A, uplo=:U)

मैट्रिक्स A के ऊपरी (यदि uplo = :U ) या निचले (यदि uplo = :L ) के त्रिकोण के एक Symmetric दृश्य का निर्माण करें।

उदाहरण

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

julia> Supper = Symmetric(A)
5×5 Symmetric{Int64,Array{Int64,2}}:
 1  0  2  0  3
 0  4  0  5  0
 2  0  7  0  8
 0  5  0  1  0
 3  0  8  0  4

julia> Slower = Symmetric(A, :L)
5×5 Symmetric{Int64,Array{Int64,2}}:
 1  0  6  0  2
 0  4  0  9  0
 6  0  7  0  3
 0  9  0  1  0
 2  0  3  0  4

ध्यान दें कि Slower तब तक Slower बराबर नहीं होगा जब तक कि A खुद सममित न हो (जैसे कि A == transpose(A) )।

source

LinearAlgebra.Hermitian प्रकार

Hermitian(A, uplo=:U)

मैट्रिक्स A के ऊपरी (यदि uplo = :U ) या निम्न (यदि uplo = :L ) त्रिभुज के एक Hermitian दृश्य का निर्माण करें।

उदाहरण

julia> A = [1 0 2+2im 0 3-3im; 0 4 0 5 0; 6-6im 0 7 0 8+8im; 0 9 0 1 0; 2+2im 0 3-3im 0 4];

julia> Hupper = Hermitian(A)
5×5 Hermitian{Complex{Int64},Array{Complex{Int64},2}}:
 1+0im  0+0im  2+2im  0+0im  3-3im
 0+0im  4+0im  0+0im  5+0im  0+0im
 2-2im  0+0im  7+0im  0+0im  8+8im
 0+0im  5+0im  0+0im  1+0im  0+0im
 3+3im  0+0im  8-8im  0+0im  4+0im

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

ध्यान दें कि Hupper बराबर नहीं होगा जब तक कि A खुद हेर्मिटियन नहीं है (जैसे अगर A == adjoint(A) )।

विकर्ण के सभी गैर-वास्तविक भागों को अनदेखा किया जाएगा।

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

LinearAlgebra.LowerTriangular प्रकार

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 Array{Float64,2}:
 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,Array{Float64,2}}:
 1.0   â‹…    â‹…
 4.0  5.0   â‹…
 7.0  8.0  9.0
source

LinearAlgebra.UpperTriangular प्रकार

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 Array{Float64,2}:
 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,Array{Float64,2}}:
 1.0  2.0  3.0
  â‹…   5.0  6.0
  â‹…    â‹…   9.0
source

LinearAlgebra.UniformScaling प्रकार

UniformScaling{T<:Number}

सामान्य रूप से आकार स्केलिंग ऑपरेटर को स्केलर समय के रूप में परिभाषित किया गया है जो पहचान ऑपरेटर, λ*I I भी I

उदाहरण

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

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

julia> J*A
2×2 Array{Float64,2}:
 2.0  4.0
 6.0  8.0
source

LinearAlgebra.lu फ़ंक्शन

lu(A, pivot=Val(true); check = true) -> F::LU

A के LU गुणन की गणना करें।

जब check = true , तो अपघटन विफल होने पर एक त्रुटि डाली जाती है। जब check = false , तो अपघटन की वैधता (जारी करने के माध्यम से) की जांच करने की जिम्मेदारी उपयोगकर्ता के पास होती है।

ज्यादातर मामलों में, यदि A , A , A , T , + , और / , के तत्व प्रकार T साथ AbstractMatrix{T} का उप-प्रकार है, तो वापसी प्रकार LU{T,S{T}} । यदि पिवटिंग चुना गया है (डिफ़ॉल्ट) तत्व प्रकार को भी abs और < समर्थन करना चाहिए।

कारक F व्यक्तिगत घटकों को getproperty माध्यम से पहुँचा जा सकता है:

अंग विवरण
FL L (लो त्रिकोणीय) LU हिस्सा
FU U (ऊपरी त्रिकोणीय) LU हिस्सा
Fp (दाएं) क्रमपरिवर्तन Vector
FP (दाएं) क्रमपरिवर्तन Matrix

फैक्टराइजेशन में फेरफार करने से FL , FU , और Fp घटकों का उत्पादन होता है।

F और A बीच संबंध है

FL*FU == A[Fp, :]

F आगे के कार्यों का समर्थन करता है:

समर्थित समारोह LU LU{T,Tridiagonal{T}}
/
inv
inv
det
logdet
logabsdet
size

उदाहरण

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

julia> F = lu(A)
LU{Float64,Array{Float64,2}}
L factor:
2×2 Array{Float64,2}:
 1.0  0.0
 1.5  1.0
U factor:
2×2 Array{Float64,2}:
 4.0   3.0
 0.0  -1.5

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

julia> l, u, p = lu(A); # destructuring via iteration

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

LinearAlgebra.lu! समारोह

lu!(A, pivot=Val(true); check = true) -> LU

lu! lu के समान है, लेकिन एक प्रतिलिपि बनाने के बजाय, इनपुट A को अधिलेखित करके स्थान बचाता है। यदि कारक के प्रकार A के तत्व प्रकार द्वारा प्रतिनिधित्व योग्य संख्या नहीं पैदा करता है, तो एक InexactError अपवाद फेंक दिया जाता है, जैसे पूर्णांक प्रकार के लिए।

उदाहरण

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

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

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

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

LinearAlgebra.cholesky फ़ंक्शन

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

एक घने सममित सकारात्मक निश्चित मैट्रिक्स A के चोल्स्की फैक्टराइजेशन की गणना करें और एक Cholesky फैक्टराइजेशन Cholesky । मैट्रिक्स A या तो एक Symmetric या Hermitian StridedMatrix या एक पूरी तरह से सममित या हर्मिटियन StridedMatrix । त्रिकोणीय चोल्स्की फैक्टर को F से F : और FU साथ प्राप्त किया जा सकता है। निम्नलिखित कार्य Cholesky वस्तुओं के लिए उपलब्ध हैं: size , inv , logdet , logdet , logdet और isposdef

जब check = true , तो अपघटन विफल होने पर एक त्रुटि डाली जाती है। जब check = false , तो अपघटन की वैधता (जारी करने के माध्यम से) की जांच करने की जिम्मेदारी उपयोगकर्ता के पास होती है।

उदाहरण

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

julia> C = cholesky(A)
Cholesky{Float64,Array{Float64,2}}
U factor:
3×3 UpperTriangular{Float64,Array{Float64,2}}:
 2.0  6.0  -8.0
  â‹…   1.0   5.0
  â‹…    â‹…    3.0

julia> C.U
3×3 UpperTriangular{Float64,Array{Float64,2}}:
 2.0  6.0  -8.0
  â‹…   1.0   5.0
  â‹…    â‹…    3.0

julia> C.L
3×3 LowerTriangular{Float64,Array{Float64,2}}:
  2.0   â‹…    â‹…
  6.0  1.0   â‹…
 -8.0  5.0  3.0

julia> C.L * C.U == A
true
source
cholesky(A, Val(true); tol = 0.0, check = true) -> CholeskyPivoted

घनी सिमिट्रिक पॉजिटिव सेमी-निश्चित मैट्रिक्स A पिव्टेड चोल्स्की फैक्टराइजेशन की गणना करें और CholeskyPivoted फैक्टराइजेशन CholeskyPivoted । मैट्रिक्स A या तो एक Symmetric या Hermitian StridedMatrix या एक पूरी तरह से सममित या हर्मिटियन StridedMatrix । त्रिकोणीय चोल्स्की फैक्टर को F से F : और FU साथ प्राप्त किया जा सकता है। निम्न कार्य PivotedCholesky ऑब्जेक्ट्स के लिए उपलब्ध हैं: size , inv , PivotedCholesky , पता और rank । तर्क का निर्धारण रैंक निर्धारित करने के लिए सहिष्णुता निर्धारित करता है। नकारात्मक मूल्यों के लिए, सहिष्णुता मशीन सटीक है।

जब check = true , तो अपघटन विफल होने पर एक त्रुटि डाली जाती है। जब check = false , तो अपघटन की वैधता (जारी करने के माध्यम से) की जांच करने की जिम्मेदारी उपयोगकर्ता के पास होती है।

source

LinearAlgebra.cholesky! समारोह

cholesky!(A, Val(false); check = true) -> Cholesky

cholesky रूप में ही है, लेकिन एक प्रतिलिपि बनाने के बजाय, इनपुट A को अधिलेखित करके स्थान बचाता है। यदि कारक के प्रकार A के तत्व प्रकार द्वारा प्रतिनिधित्व योग्य संख्या नहीं पैदा करता है, तो एक InexactError अपवाद फेंक दिया जाता है, जैसे पूर्णांक प्रकार के लिए।

उदाहरण

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

julia> cholesky!(A)
ERROR: InexactError: Int64(Int64, 6.782329983125268)
Stacktrace:
[...]
source
cholesky!(A, Val(true); tol = 0.0, check = true) -> CholeskyPivoted

cholesky रूप में ही है, लेकिन एक प्रतिलिपि बनाने के बजाय, इनपुट A को अधिलेखित करके स्थान बचाता है। यदि कारक के प्रकार A के तत्व प्रकार द्वारा प्रतिनिधित्व योग्य संख्या नहीं पैदा करता है, तो एक InexactError अपवाद फेंक दिया जाता है, जैसे पूर्णांक प्रकार के लिए।

source

LinearAlgebra.lowrankupdate फंक्शन

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

वेक्टर के साथ एक चोल्स्की फ़ैक्टराइज़ेशन C अपडेट करें। यदि A = C.U'CU तो CC = cholesky(C.U'CU + v*v') लेकिन CC की गणना केवल O(n^2) संचालन का उपयोग करती है।

source

LinearAlgebra.lowrankdowndate फ़ंक्शन

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

वेक्टर के साथ एक चोल्स्की फैक्टराइजेशन C को दोवेट करें। यदि A = C.U'CU तो CC = cholesky(C.U'CU - v*v') लेकिन CC की गणना केवल O(n^2) संचालन का उपयोग करती है।

source

LinearAlgebra.lowrankupdate! समारोह

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

वेक्टर के साथ एक चोल्स्की फ़ैक्टराइज़ेशन C अपडेट करें। यदि A = C.U'CU तो CC = cholesky(C.U'CU + v*v') लेकिन CC की गणना केवल O(n^2) संचालन का उपयोग करती है। इनपुट फ़ैक्टरीकरण C को उस स्थान पर अपडेट किया C है जो C == CC बाहर निकलता C == CC । सदिश v गणना के दौरान नष्ट हो जाता है।

source

LinearAlgebra.lowrankdowndate! समारोह

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

वेक्टर के साथ एक चोल्स्की फैक्टराइजेशन C को दोवेट करें। यदि A = C.U'CU तो CC = cholesky(C.U'CU - v*v') लेकिन CC की गणना केवल O(n^2) संचालन का उपयोग करती है। इनपुट फ़ैक्टरीकरण C को उस स्थान पर अपडेट किया C है जो C == CC बाहर निकलता C == CC । सदिश v गणना के दौरान नष्ट हो जाता है।

source

LinearAlgebra.ldlt फ़ंक्शन

ldlt(S::SymTridiagonal) -> LDLt

वास्तविक सममित LDLt मैट्रिक्स S एक LDLt गुणन की गणना करें जैसे कि S = L*Diagonal(d)*L' जहां L एक इकाई कम त्रिकोणीय मैट्रिक्स है और d एक वेक्टर है। LDLt F = ldlt(S) का मुख्य उपयोग समीकरणों के रैखिक प्रणाली को Sx = b साथ F\b से हल करना है।

उदाहरण

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64,Array{Float64,1}}:
 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 Array{Float64,1}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

julia> S \ b
3-element Array{Float64,1}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255
source

LinearAlgebra.ldlt! समारोह

ldlt!(S::SymTridiagonal) -> LDLt

ldlt समान, लेकिन प्रतिलिपि बनाने के बजाय, इनपुट S को अधिलेखित करके स्थान बचाता है।

उदाहरण

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64,Array{Float64,1}}:
 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,Array{Float64,1}}:
 3.0       0.333333   â‹…
 0.333333  3.66667   0.545455
  â‹…        0.545455  3.90909
source

LinearAlgebra.qr फ़ंक्शन

qr(A, pivot=Val(false)) -> F

मैट्रिक्स A के QR गुणनखंडन की गणना करें: एक ऑर्थोगोनल (या एकात्मक यदि A जटिल-मूल्यवान है) मैट्रिक्स Q , और एक ऊपरी त्रिकोणीय मैट्रिक्स R ऐसा

\ [A = QR \]

लौटी हुई वस्तु F एक भरे हुए प्रारूप में कारक को संग्रहीत करती है:

  • अगर pivot == Val(true) तो F एक QRPivoted ऑब्जेक्ट है,

  • अन्यथा यदि A का तत्व प्रकार A Float32 प्रकार है ( Float32 , Float64 , ComplexF32 या ComplexF64 ), तो F एक QRCompactWY ऑब्जेक्ट है,

  • अन्यथा F एक QR ऑब्जेक्ट है।

अपघटन F व्यक्तिगत घटकों को संपत्ति अभिगमकर्ताओं द्वारा प्राप्त किया जा सकता है:

  • FQ : ऑर्थोगोनल / एकात्मक मैट्रिक्स Q
  • FR : ऊपरी त्रिकोणीय मैट्रिक्स R
  • Fp : धुरी का क्रमचय वेक्टर (केवल QRPivoted )
  • FP : धुरी के क्रमपरिवर्तन मैट्रिक्स (केवल QRPivoted )

विघटन को मिटाने से घटक Q , R , और यदि मौजूदा p

निम्नलिखित कार्य QR ऑब्जेक्ट्स के लिए उपलब्ध हैं: inv , size , और inv । जब A आयताकार होता है, तो \ _ एक न्यूनतम वर्ग समाधान लौटाता है और यदि समाधान अद्वितीय नहीं है, तो सबसे छोटे मानदंड वाले को लौटा दिया जाता है।

पूर्ण / वर्ग या गैर-पूर्ण / वर्ग Q संबंध में गुणा की अनुमति है, अर्थात FQ*FR और FQ*A दोनों समर्थित हैं। एक मैट्रिक्स मैट्रिक्स को मैट्रिक्स के साथ एक नियमित मैट्रिक्स में परिवर्तित किया जा सकता है। यह ऑपरेशन "पतला" क्यू कारक लौटाता है, अर्थात, यदि A m m>=n साथ m>=n × m>=n , तो Matrix(FQ) orthonormal कॉलम के साथ m × n मैट्रिक्स निकालता है। "पूर्ण" क्यू कारक को पुनः प्राप्त करने के लिए, एक m × m ऑर्थोगोनल मैट्रिक्स, FQ*Matrix(I,m,m) । यदि m<=n , तो Matrix(FQ) एक m × m ऑर्थोगोनल मैट्रिक्स देता है।

उदाहरण

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

julia> F = qr(A)
LinearAlgebra.QRCompactWY{Float64,Array{Float64,2}}
Q factor:
3×3 LinearAlgebra.QRCompactWYQ{Float64,Array{Float64,2}}:
 -0.6   0.0   0.8
 -0.8   0.0  -0.6
  0.0  -1.0   0.0
R factor:
2×2 Array{Float64,2}:
 -5.0  10.0
  0.0  -1.0

julia> F.Q * F.R == A
true
ध्यान दें

qr कई प्रकार लौटाता है क्योंकि LAPACK कई प्रतिनिधित्व का उपयोग करता है जो हाउसहोल्डर प्राथमिक रिफ्लेक्टरों के उत्पादों की मेमोरी स्टोरेज आवश्यकताओं को कम करता है, ताकि Q और R मेट्रिक्स को दो अलग-अलग घने मैट्रेस के रूप में कॉम्पैक्ट रूप से संग्रहीत किया जा सके।

source

LinearAlgebra.qr! समारोह

qr!(A, pivot=Val(false))

qr! qr के समान है जब A , StridedMatrix उपप्रकार है, लेकिन प्रतिलिपि बनाने के बजाय, इनपुट A को अधिलेखित करके स्थान बचाता है। यदि कारक के प्रकार A के तत्व प्रकार द्वारा प्रतिनिधित्व योग्य संख्या नहीं पैदा करता है, तो एक InexactError अपवाद फेंक दिया जाता है, जैसे पूर्णांक प्रकार के लिए।

उदाहरण

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

julia> qr!(a)
LinearAlgebra.QRCompactWY{Float64,Array{Float64,2}}
Q factor:
2×2 LinearAlgebra.QRCompactWYQ{Float64,Array{Float64,2}}:
 -0.316228  -0.948683
 -0.948683   0.316228
R factor:
2×2 Array{Float64,2}:
 -3.16228  -4.42719
  0.0      -0.632456

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

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

LinearAlgebra.QR प्रकार

QR <: Factorization

क्यूआर मैट्रिक्स फैक्टराइजेशन को पैक्ड प्रारूप में संग्रहीत किया जाता है, जो आमतौर पर qr से प्राप्त किया जाता है। यदि $ A $ m × n मैट्रिक्स है, तो

\ [A = QR \]

जहां $ Q $ एक ऑर्थोगोनल / एकात्मक मैट्रिक्स है और $ R $ ऊपरी त्रिकोणीय है। मैट्रिक्स $ Q $ को हाउसहोल्डर रिफ्लेक्टरों के अनुक्रम के रूप में संग्रहीत किया जाता है $ v_i $ और गुणांक $ \ tau_n $ जहां:

\ [क्यू = \ prod_ {i = 1} ^ {\ min (m, n)} (I - \ tau_i v_i v_i ^ T)।]

विघटन को Iterating घटक Q और R उत्पन्न करता है।

ऑब्जेक्ट के दो क्षेत्र हैं:

  • factors एक m × n मैट्रिक्स है।

    • ऊपरी त्रिकोणीय भाग में $ R $ के तत्व होते हैं, जो कि QR ऑब्जेक्ट F लिए R = triu(F.factors)

    • सबडागोनियल भाग में रिफ्लेक्टर्स $ v_i $ एक पैक्ड प्रारूप में संग्रहीत होते हैं, जहां $ v_i $ मैट्रिक्स V = I + tril(F.factors, -1) का $ i $ th स्तंभ है।

  • min(m,n) लंबाई min(m,n) का गुणांक $ au_i $ युक्त वेक्टर है।

source

LinearAlgebra.QRCompactWY प्रकार

QRCompactWY <: Factorization

आमतौर पर क्यूआर से प्राप्त एक कॉम्पैक्ट ब्लॉक किए गए प्रारूप में संग्रहीत क्यूआर मैट्रिक्स फैक्टराइजेशन। यदि $ A $ m × n मैट्रिक्स है, तो

\ [A = QR \]

जहां $ Q $ एक ऑर्थोगोनल / एकात्मक मैट्रिक्स है और $ R $ ऊपरी त्रिकोणीय है। यह QR प्रारूप के समान है सिवाय इसके कि ऑर्थोगोनल / एकात्मक मैट्रिक्स $ Q $ कॉम्पैक्ट WY प्रारूप [Schreiber1989] में संग्रहीत किया जाता है, निचले ट्रेपेज़ॉइडल मैट्रिक्स $ V $ के रूप में और एक ऊपरी त्रिकोणीय मैट्रिक्स $ $ $ जहाँ

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

ऐसा है कि $ v_i $ $ V $ का $ i $ th स्तंभ है, और $ a__i $ $ $ $ का $ i $ th विकर्ण तत्व है।

विघटन को Iterating घटक Q और R उत्पन्न करता है।

ऑब्जेक्ट के दो क्षेत्र हैं:

  • QR प्रकार में factors , एक m × n मैट्रिक्स है।

    • ऊपरी त्रिकोणीय भाग में $ R $ के तत्व होते हैं, जो कि QR ऑब्जेक्ट F लिए R = triu(F.factors)

    • सबडागोनियल भाग में परावर्तक $ v_i $ होते हैं जो एक पैक प्रारूप में संग्रहीत होते हैं जैसे कि V = I + tril(F.factors, -1)

  • T min(m,n) कॉलम के साथ एक वर्ग मैट्रिक्स है, जिसका ऊपरी त्रिकोणीय भाग मैट्रिक्स को $ T $ ऊपर देता है (उप-वर्गीय तत्वों को अनदेखा किया जाता है)।

ध्यान दें

इस प्रारूप को पुराने WY प्रतिनिधित्व [Bischof1987] साथ भ्रमित नहीं होना चाहिए।

[Bischof1987]

सी बिस्चोफ़ और सी वान लोन, "हाउसहोल्डर मैट्रीस के उत्पादों के लिए WY प्रतिनिधित्व", सियाम जे साइंस स्टैट कंपुट 8 (1987), s2-s13। doi:10.1137/0908009

[Schreiber1989]

आर श्रेइबर और सी वैन लोन, "हाउसहोल्डर ट्रांसफॉर्मेशन के उत्पादों के लिए एक भंडारण-कुशल WY प्रतिनिधित्व", सियाम जे साइंस स्टैट कंपुट 10 (1989), 53-57। doi:10.1137/0910005

source

LinearAlgebra.QRPivoted प्रकार

QRPivoted <: Factorization

आमतौर पर qr से प्राप्त पैक्ड फॉर्मेट में कॉलम पिविंग के साथ एक क्यूआर मैट्रिक्स फैक्टराइजेशन। यदि $ A $ m × n मैट्रिक्स है, तो

\ [एपी = क्यूआर \]

जहां $ P $ एक क्रमचय मैट्रिक्स है, $ Q $ एक ऑर्थोगोनल / एकात्मक मैट्रिक्स है और $ R $ ऊपरी त्रिकोणीय है। मैट्रिक्स $ Q $ को हाउसहोल्डर रिफ्लेक्टर के अनुक्रम के रूप में संग्रहीत किया जाता है:

\ [क्यू = \ prod_ {i = 1} ^ {\ min (m, n)} (I - \ tau_i v_i v_i ^ T)।]

विघटन को रोकने से घटक Q , R और p उत्पन्न होते हैं।

ऑब्जेक्ट के तीन क्षेत्र हैं:

  • factors एक m × n मैट्रिक्स है।

    • ऊपरी त्रिकोणीय भाग में $ R $ के तत्व होते हैं, जो कि QR ऑब्जेक्ट F लिए R = triu(F.factors)

    • सबडागोनियल भाग में रिफ्लेक्टर्स $ v_i $ एक पैक्ड प्रारूप में संग्रहीत होते हैं, जहां $ v_i $ मैट्रिक्स V = I + tril(F.factors, -1) का $ i $ th स्तंभ है।

  • min(m,n) लंबाई min(m,n) का गुणांक $ au_i $ युक्त वेक्टर है।

  • jpvt एक पूर्णांक वेक्टर की लंबाई n है जो क्रमचय $ P $ के अनुरूप है।

source

LinearAlgebra.lq! समारोह

lq!(A) -> LQ

एक कार्यक्षेत्र के रूप में इनपुट मैट्रिक्स का उपयोग करके, A के एलक्यू फैक्टराइजेशन की गणना करें। lq भी देखें।

source

LinearAlgebra.lq फ़ंक्शन

lq(A) -> S::LQ

A के LQ अपघटन की गणना करें। अपघटन का निचला त्रिकोणीय घटक LQ ऑब्जेक्ट S से SL माध्यम से और ऑर्थोगोनल / एकात्मक घटक SQ माध्यम से प्राप्त किया जा सकता है, जैसे कि A ≈ SL*SQ

विघटन को रोकने से घटक SL और SQ उत्पादन होता है।

एलक्यू अपघटन transpose(A) का क्यूआर अपघटन है।

उदाहरण

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

julia> S = lq(A)
LQ{Float64,Array{Float64,2}} with factors L and Q:
[-8.60233 0.0; 4.41741 -0.697486]
[-0.581238 -0.813733; -0.813733 0.581238]

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

julia> l, q = S; # destructuring via iteration

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

LinearAlgebra.bunchkaufman फ़ंक्शन

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

बंच-कॉफ़मैन [Bunch1977] बंच [Bunch1977] गणना एक Symmetric या [Bunch1977] मैट्रिक्स A रूप में $ P '* U * D * U' * P $ या $ P '* L * D * L' * P $ से होती है , जो त्रिकोण के आधार पर है A में संग्रहीत, और एक BunchKaufman वस्तु वापस। ध्यान दें कि यदि A जटिल सममित है तो U' और L' असंबद्ध स्थानान्तरण का द्योतक है, अर्थात transpose(U) और transpose(L)

अपघटन को S.uplo लिए घटक Sp , SU या SL को उचित रूप से दिए गए S.uplo

यदि rook true , तो रूक पिवटिंग का उपयोग किया जाता है। यदि rook गलत है, तो रूक पिवटिंग का उपयोग नहीं किया जाता है।

जब check = true , तो अपघटन विफल होने पर एक त्रुटि डाली जाती है। जब check = false , तो अपघटन की वैधता (जारी करने के माध्यम से) की जांच करने की जिम्मेदारी उपयोगकर्ता के पास होती है।

BunchKaufman ऑब्जेक्ट्स के लिए निम्न फ़ंक्शन उपलब्ध हैं: size , \ , inv , issymmetric , ishermitian , getindex

[Bunch1977]

जेआर बंच और एल कॉफमैन, जड़ता की गणना के लिए कुछ स्थिर तरीके

और सममित रैखिक प्रणालियों को हल करना, कम्प्यूटेशन का गणित 31: 137 (1977), 163-179। url

उदाहरण

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

julia> S = bunchkaufman(A)
BunchKaufman{Float64,Array{Float64,2}}
D factor:
2×2 Tridiagonal{Float64,Array{Float64,1}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64,Array{Float64,2}}:
 1.0  0.666667
  â‹…   1.0
permutation:
2-element Array{Int64,1}:
 1
 2

julia> d, u, p = S; # destructuring via iteration

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

LinearAlgebra.bunchkaufman! समारोह

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

bunchkaufman! bunchkaufman के समान है, लेकिन कॉपी बनाने के बजाय इनपुट A को ओवरराइट करके अंतरिक्ष बचाता है।

source

LinearAlgebra.eigvals फ़ंक्शन

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

A के आइजनवेल्यूज वापस करें।

सामान्य गैर-सममितीय मैट्रिक्स के लिए यह निर्दिष्ट करना संभव है कि मैट्रिक्स प्रतिजन गणना से पहले कैसे संतुलित है। विकल्प permute=true मैट्रिक्स को ऊपरी त्रिकोणीय के करीब होने की अनुमति देता है, और scale=true पंक्तियों और स्तंभों को आदर्श में अधिक समान बनाने के लिए मैट्रिक्स को अपने विकर्ण तत्वों द्वारा मापता है। डिफ़ॉल्ट true दोनों विकल्पों के लिए है।

उदाहरण

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

julia> eigvals(diag_matrix)
2-element Array{Float64,1}:
 1.0
 4.0
source

स्केलर इनपुट के लिए, eigvals एक स्केलर वापस करेगा।

उदाहरण

julia> eigvals(-2)
-2
source
eigvals(A, B) -> values

की सामान्यीकृत eigenvalues गणना करता है A और B

उदाहरण

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

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

julia> eigvals(A,B)
2-element Array{Complex{Float64},1}:
 0.0 + 1.0im
 0.0 - 1.0im
source
eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

के आइजनवेल्स लौटाता है AUnitRange irange क्रमबद्ध eigenvalues ​​के कवरिंग सूचकांकों को निर्दिष्ट करके केवल eigenvalues ​​के केवल एक सबसेट की गणना करना संभव है , उदाहरण के लिए 2 से 8 वीं eigenvalues।

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64,Array{Float64,1}}:
 1.0  2.0   â‹…
 2.0  2.0  3.0
  â‹…   3.0  1.0

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

julia> eigvals(A)
3-element Array{Float64,1}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259
source
eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values

के आइजनवेल्स लौटाता है A । यह एक जोड़ी का उल्लेख करके eigenvalues का केवल एक उपसमूह की गणना करने के लिए संभव है vl और vu eigenvalues के निचले और ऊपरी सीमाओं के लिए।

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64,Array{Float64,1}}:
 1.0  2.0   â‹…
 2.0  2.0  3.0
  â‹…   3.0  1.0

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

julia> eigvals(A)
3-element Array{Float64,1}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259
source

LinearAlgebra.eigvals! समारोह

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

के रूप में ही eigvals , लेकिन A एक कॉपी बनाने के बजाय, इनपुट को ओवरराइट करके अंतरिक्ष बचाता है। विकल्प permute=true मैट्रिक्स को ऊपरी त्रिकोणीय के करीब होने की अनुमति देता है, और scale=true पंक्तियों और स्तंभों को आदर्श में अधिक समान बनाने के लिए मैट्रिक्स को अपने विकर्ण तत्वों द्वारा मापता है।

ध्यान दें

इनपुट मैट्रिक्स के A बाद eigvals! उस पर कॉल करने के बाद उसका आईजेनवेल्यूज़ नहीं होगा - A इसका उपयोग कार्यक्षेत्र के रूप में किया जाता है।

उदाहरण

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

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

julia> A
2×2 Array{Float64,2}:
 -0.372281  -1.0
  0.0        5.37228
source
eigvals!(A, B) -> values

के रूप में ही eigvals , लेकिन प्रतियां बनाने के बजाय इनपुट A (और B ) को अधिलेखित करके अंतरिक्ष बचाता है ।

ध्यान दें

इनपुट मैट्रिसेस होता है A और कहा जाता है के B बाद उनके eigenvalues ​​शामिल नहीं होंगे eigvals! । उनका उपयोग कार्यक्षेत्र के रूप में किया जाता है।

उदाहरण

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

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

julia> eigvals!(A, B)
2-element Array{Complex{Float64},1}:
 0.0 + 1.0im
 0.0 - 1.0im

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

julia> B
2×2 Array{Float64,2}:
 1.0  0.0
 0.0  1.0
source
eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

के रूप में ही eigvals , लेकिन A एक कॉपी बनाने के बजाय, इनपुट को ओवरराइट करके अंतरिक्ष बचाता है। उदाहरण के लिए खोज करने के लिए irange eigenvalue सूचकांकों की एक श्रृंखला है - उदाहरण के लिए, दूसरी से 8 वीं eigenvalues।

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

के रूप में ही eigvals , लेकिन A एक कॉपी बनाने के बजाय, इनपुट को ओवरराइट करके अंतरिक्ष बचाता है। vl eigenvalues ​​की खोज करने के लिए अंतराल की निचली सीमा है, और vu ऊपरी सीमा है।

source

LinearAlgebra.eigmax समारोह

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

का सबसे बड़ा स्वदेश वापसी A । विकल्प permute=true मैट्रिक्स को ऊपरी त्रिकोणीय के करीब होने की अनुमति देता है, और scale=true पंक्तियों और स्तंभों को आदर्श में अधिक समान बनाने के लिए मैट्रिक्स को अपने विकर्ण तत्वों द्वारा मापता है। ध्यान दें कि यदि ईजेन्यूल्स A जटिल हैं, तो यह विधि विफल हो जाएगी, क्योंकि जटिल संख्याओं को क्रमबद्ध नहीं किया जा सकता।

उदाहरण

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

julia> eigmax(A)
1.0

julia> A = [0 im; -1 0]
2×2 Array{Complex{Int64},2}:
  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` cannot have complex eigenvalues.
Stacktrace:
[...]
source

LinearAlgebra.eigmin समारोह

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

का सबसे छोटा प्रतिध्वनि लौटाएं A । विकल्प permute=true मैट्रिक्स को ऊपरी त्रिकोणीय के करीब होने की अनुमति देता है, और scale=true पंक्तियों और स्तंभों को आदर्श में अधिक समान बनाने के लिए मैट्रिक्स को अपने विकर्ण तत्वों द्वारा मापता है। ध्यान दें कि यदि ईजेन्यूल्स A जटिल हैं, तो यह विधि विफल हो जाएगी, क्योंकि जटिल संख्याओं को क्रमबद्ध नहीं किया जा सकता।

उदाहरण

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

julia> eigmin(A)
-1.0

julia> A = [0 im; -1 0]
2×2 Array{Complex{Int64},2}:
  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` cannot have complex eigenvalues.
Stacktrace:
[...]
source

LinearAlgebra.eigvecs समारोह

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

उस मैट्रिक्स को लौटाएं M जिसके कॉलम आइजनवेक्टर हैं A । ( k वें eigenvector टुकड़ा से प्राप्त किया जा सकता है M[:, k] ।)

यदि eigenvalues ​​के वैकल्पिक वेक्टर eigvals को निर्दिष्ट किया जाता है, eigvecs तो विशिष्ट संगत eigenvectors को वापस करता है।

उदाहरण

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64,Array{Float64,1}}:
 1.0  2.0   â‹…
 2.0  2.0  3.0
  â‹…   3.0  1.0

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

julia> eigvecs(A)
3×3 Array{Float64,2}:
  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 Array{Float64,2}:
  0.8320502943378438
  4.263514128092366e-17
 -0.5547001962252291
source
eigvecs(A; permute::Bool=true, scale::Bool=true) -> Matrix

उस मैट्रिक्स को लौटाएं M जिसके कॉलम आइजनवेक्टर हैं A । ( k वें eigenvector स्लाइस से प्राप्त किया जा सकता है M[:, k] ।) permute और scale कीवर्ड के लिए समान हैं eigen

उदाहरण

julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
3×3 Array{Float64,2}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0
source
eigvecs(A, B) -> Matrix

एक मैट्रिक्स लौटें M जिसके कॉलम सामान्यीकृत eigenvectors A और हैं B । ( k वें eigenvector टुकड़ा से प्राप्त किया जा सकता है M[:, k] ।)

उदाहरण

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

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

julia> eigvecs(A, B)
2×2 Array{Complex{Float64},2}:
  0.0-1.0im   0.0+1.0im
 -1.0-0.0im  -1.0+0.0im
source

LinearAlgebra.eigen समारोह

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

गुणन ऑब्जेक्ट को A वापस करने वाले आइजनवायु के अपघटन की गणना करता है , जिसमें मैट्रिक्स के कॉलम में आईजेनवेल्यूस और ईजेनवेक्टर शामिल हैं । ( वें eigenvector टुकड़ा से प्राप्त किया जा सकता है ।) Eigen F F.values F.vectors k F.vectors[:, k]

विघटन को मिटाने से घटक उत्पन्न होते हैं F.values और F.vectors

निम्नलिखित कार्यों के लिए उपलब्ध हैं Eigen वस्तुओं: inv , det , और isposdef

सामान्य nonsymmetric matrices के लिए यह निर्दिष्ट करना संभव है कि मैट्रिक्स eigenvector गणना से पहले कैसे संतुलित है। विकल्प permute=true मैट्रिक्स को ऊपरी त्रिकोणीय के करीब होने की अनुमति देता है, और scale=true पंक्तियों और स्तंभों को आदर्श में अधिक समान बनाने के लिए मैट्रिक्स को अपने विकर्ण तत्वों द्वारा मापता है। डिफ़ॉल्ट true दोनों विकल्पों के लिए है।

उदाहरण

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64,Float64,Array{Float64,2},Array{Float64,1}}
eigenvalues:
3-element Array{Float64,1}:
  1.0
  3.0
 18.0
eigenvectors:
3×3 Array{Float64,2}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Array{Float64,1}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Array{Float64,2}:
 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
source
eigen(A, B) -> GeneralizedEigen

के सामान्यीकृत eigenvalue अपघटन की गणना करता है , A और B एक GeneralizedEigen कारक वस्तु लौटाता है F जिसमें F.values मैट्रिक्स के कॉलम में सामान्यीकृत eigenvalues और सामान्यीकृत eigenvectors शामिल होते हैं F.vectors । ( k वें सामान्यीकृत आइजनवेक्टर को स्लाइस से प्राप्त किया जा सकता है F.vectors[:, k] ।)

विघटन को मिटाने से घटक उत्पन्न होते हैं F.values और F.vectors

उदाहरण

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

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

julia> F = eigen(A, B);

julia> F.values
2-element Array{Complex{Float64},1}:
 0.0 + 1.0im
 0.0 - 1.0im

julia> F.vectors
2×2 Array{Complex{Float64},2}:
  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
source
eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> Eigen

गुणन ऑब्जेक्ट को A वापस करने वाले आइजनवायु के अपघटन की गणना करता है , जिसमें मैट्रिक्स के कॉलम में आईजेनवेल्यूस और ईजेनवेक्टर शामिल हैं । ( वें eigenvector टुकड़ा से प्राप्त किया जा सकता है ।) Eigen F F.values F.vectors k F.vectors[:, k]

विघटन को मिटाने से घटक उत्पन्न होते हैं F.values और F.vectors

निम्नलिखित कार्यों के लिए उपलब्ध हैं Eigen वस्तुओं: inv , det , और isposdef

के UnitRange irange लिए खोज करने के लिए सॉर्ट किए गए eigenvalues ​​के सूचकांकों को निर्दिष्ट करता है।

ध्यान दें

यदि irange नहीं है 1:n , जहां n का आयाम है A , तो लौटा हुआ फैक्टराइजेशन एक छोटा कारक होगा।

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

गुणन ऑब्जेक्ट को A वापस करने वाले आइजनवायु के अपघटन की गणना करता है , जिसमें मैट्रिक्स के कॉलम में आईजेनवेल्यूस और ईजेनवेक्टर शामिल हैं । ( वें eigenvector टुकड़ा से प्राप्त किया जा सकता है ।) Eigen F F.values F.vectors k F.vectors[:, k]

विघटन को मिटाने से घटक उत्पन्न होते हैं F.values और F.vectors

निम्नलिखित कार्यों के लिए उपलब्ध हैं Eigen वस्तुओं: inv , det , और isposdef

vl खोज करने के लिए eigenvalues ​​की खिड़की की निचली सीमा है, और vu ऊपरी बाध्य है।

ध्यान दें

यदि [ vl , vu ] के सभी eigenvalues ​​शामिल नहीं हैं A , तो लौटा हुआ फैक्टराइजेशन एक छोटा कारक होगा।

source

LinearAlgebra.eigen! समारोह

eigen!(A, [B])

के रूप में ही eigen , लेकिन एक प्रतिलिपि बनाने के बजाय इनपुट A (और B ) को अधिलेखित करके स्थान बचाता है।

source

LinearAlgebra.hessenberg समारोह

hessenberg(A) -> Hessenberg

A एक Hessenberg वस्तु के हेसनबर्ग अपघटन की गणना करें और एक वस्तु लौटाएं । यदि F फैक्टराइजेशन ऑब्जेक्ट है, तो एकात्मक मैट्रिक्स के साथ FQ और हेसेनबर्ग मैट्रिक्स के साथ पहुँचा जा सकता है FH । जब Q निकाला जाता है, तो परिणामी प्रकार HessenbergQ ऑब्जेक्ट होता है, और convert(Array, _) (या Array(_) संक्षेप में) के साथ एक नियमित मैट्रिक्स में परिवर्तित हो सकता है ।

अपघटन पुनरावृत्ति कारकों का उत्पादन FQ और FH

उदाहरण

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

julia> F = hessenberg(A);

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

julia> q, h = F; # destructuring via iteration

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

LinearAlgebra.hessenberg! समारोह

hessenberg!(A) -> Hessenberg

hessenberg! के रूप में ही है hessenberg , लेकिन A एक प्रतिलिपि बनाने के बजाय, इनपुट को अधिलेखित करके स्थान बचाता है।

source

LinearAlgebra.schur! समारोह

schur!(A::StridedMatrix) -> F::Schur

उसी के रूप में, schur लेकिन A कार्यक्षेत्र के रूप में इनपुट तर्क का उपयोग करता है ।

उदाहरण

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

julia> F = schur!(A)
Schur{Float64,Array{Float64,2}}
T factor:
2×2 Array{Float64,2}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Array{Float64,2}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalues:
2-element Array{Float64,1}:
  3.0
 -2.0

julia> A
2×2 Array{Float64,2}:
 3.0   9.0
 0.0  -2.0
source
schur!(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur

के रूप में ही है schur लेकिन इनपुट मैट्रिस A और B कार्यक्षेत्र के रूप में उपयोग करता है ।

source

LinearAlgebra.schur समारोह

schur(A::StridedMatrix) -> F::Schur

मैट्रिक्स के शूर कारक की गणना करता है A । (अर्ध) त्रिकोणीय Schur कारक Schur वस्तु के F साथ या F.Schur उससे प्राप्त किया जा सकता है FT और orthogonal / एकात्मक Schur वैक्टर के साथ F.vectors या FZ ऐसा प्राप्त किया जा सकता है A = F.vectors * F.Schur * F.vectors' । के eigenvalues ​​के A साथ प्राप्त किया जा सकता है F.values

अपघटन पुनरावृत्ति घटकों का उत्पादन FT , FZ और F.values

उदाहरण

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

julia> F = schur(A)
Schur{Float64,Array{Float64,2}}
T factor:
2×2 Array{Float64,2}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Array{Float64,2}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalues:
2-element Array{Float64,1}:
  3.0
 -2.0

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

julia> t, z, vals = F; # destructuring via iteration

julia> t == F.T && z == F.Z && vals == F.values
true
source
schur(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur

मैट्रिक्स की सामान्यीकृत शुर (या QZ) गुणन की गणना करता है A और B । (अर्ध) त्रिकोणीय शुर कारकों से प्राप्त किया जा सकता Schur वस्तु F के साथ FS और FT , बाईं एकात्मक / ओर्थोगोनल शुर वैक्टर के साथ प्राप्त किया जा सकता F.left या FQ और सही एकात्मक / ओर्थोगोनल शुर वैक्टर के साथ प्राप्त किया जा सकता F.right है या FZ ऐसा है कि A=F.left*FS*F.right' और B=F.left*FT*F.right' । के सामान्यीकृत प्रतिजन A और B साथ प्राप्त किया जा सकता है F.α./F.β

अपघटन पुनरावृत्ति घटकों का उत्पादन FS , FT , FQ , FZ , F.α और, F.β

source

LinearAlgebra.ordschur समारोह

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

पुनः व्यवस्थित किए गए कारक वस्तु को लौटाए जाने वाले तार्किक सरणी के अनुसार F मैट्रिक्स के Schur कारक का पुन: निर्धारण करता है । चयनित ईजेन्यूवल्स इसी प्रकार के प्रमुख विकर्ण में दिखाई देते हैं और संबंधित दाएं अपरिवर्तनीय उप-क्षेत्र के एक ऑर्थोगोनल / एकात्मक आधार बनाते हैं। वास्तविक मामले में, eigenvalues ​​की एक जटिल संयुग्म जोड़ी दोनों को शामिल किया जाना चाहिए या दोनों के माध्यम से बाहर रखा जाना चाहिए । A = Z*T*Z' select F F.Schur F.vectors select

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

लॉजिकल एरे के अनुसार F मैट्रिक्स पेयर के सामान्यीकृत शूर फैक्टर को फिर से व्यवस्थित करता है और एक GeneralizedSchur ऑब्जेक्ट देता है । चयनित eigenvalues दोनों के अग्रणी विकर्ण में दिखाई देते हैं और , और छोड़ दिया और सही ओर्थोगोनल / एकात्मक शुर वैक्टर भी इस तरह के पुनर्क्रमित कर रहे हैं कि अभी भी रखती है और की सामान्यीकृत eigenvalues और अभी भी साथ प्राप्त किया जा सकता । (A, B) = (Q*S*Z', Q*T*Z') select F FS FT (A, B) = FQ*(FS, FT)*F.Z' A B F.α./F.β

source

LinearAlgebra.ordschur! समारोह

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

के रूप में ही है ordschur लेकिन कारक का अधिलेखित करता है F

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

के रूप में ही है ordschur लेकिन कारक का अधिलेखित करता है F

source

LinearAlgebra.svd समारोह

svd(A; full::Bool = false) -> SVD

की एकवचन मान अपघटन (SVD) की गणना करें A और एक SVD वस्तु लौटाएं ।

U , S , V और Vt गुणन से प्राप्त किया जा सकता है F के साथ FU , FS , FV और F.Vt , कि इस तरह के A = U * Diagonal(S) * Vt । एल्गोरिथ्म पैदा करता है Vt और इसलिए Vt निकालने के लिए अधिक कुशल है V । एकवचन मानों S को अवरोही क्रम में क्रमबद्ध किया जाता है।

अपघटन पुनरावृत्ति घटकों का उत्पादन U , S और V

यदि full = false (डिफ़ॉल्ट), "पतली" SVD लौटा दी जाती है। एक $ M \ गुना N $ मैट्रिक्स के लिए A , पूर्ण कारक में U है M \times M और V है N \times N , जबकि पतली कारक U में M \times K और V है N \times K , जहां K = \min(M,N) एकवचन मानों की संख्या है।

उदाहरण

julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Array{Float64,2}:
 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);

julia> F.U * Diagonal(F.S) * F.Vt
4×5 Array{Float64,2}:
 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
source
svd(A, B) -> GeneralizedSVD

सामान्यीकृत एसवीडी की तुलना करें A और B , एक GeneralizedSVD कारक वस्तु लौटाएं F , जैसे कि A = FU*F.D1*F.R0*F.Q' और B = FV*F.D2*F.R0*F.Q'

एम-बाय-एन मैट्रिक्स A और पी-बाय-एन मैट्रिक्स के लिए B ,

  • U एम-बाय-एम ऑर्थोगोनल मैट्रिक्स है,
  • V पी-बाय-पी ऑर्थोगोनल मैट्रिक्स है,
  • Q एक एन-बाय-एन ऑर्थोगोनल मैट्रिक्स है,
  • D1 पहली K प्रविष्टियों में 1s के साथ M-by- (K + L) विकर्ण मैट्रिक्स है,
  • D2 P-by- (K + L) मैट्रिक्स है जिसका शीर्ष दायां L-by-L ब्लॉक विकर्ण है,
  • R0 एक (K + L) -by-N मैट्रिक्स है, जिसका सबसे दाहिना (K + L) -by- (K + L) ब्लॉक नॉनसिंगुलर अपर ब्लॉक त्रिकोणीय है,

K+L मैट्रिक्स का प्रभावी संख्यात्मक रैंक है [A; B]

अपघटन पुनरावृत्ति घटकों का उत्पादन U , V , Q , D1 , D2 और, R0

की प्रविष्टियों F.D1 और F.D2 , के रूप में के लिए LAPACK दस्तावेज में विस्तार से बताया संबंधित हैं सामान्यीकृत SVD और xGGSVD3 दिनचर्या जिसके नीचे कहा जाता है (LAPACK 3.6.0 और नए में)।

उदाहरण

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

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

julia> F = svd(A, B);

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

julia> F.V*F.D2*F.R0*F.Q'
2×2 Array{Float64,2}:
 0.0  1.0
 1.0  0.0
source

LinearAlgebra.svd! समारोह

svd!(A; full::Bool = false) -> SVD

svd! के रूप में ही है svd , लेकिन 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 Array{Float64,2}:
 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);

julia> F.U * Diagonal(F.S) * F.Vt
4×5 Array{Float64,2}:
 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> A
4×5 Array{Float64,2}:
 -2.23607   0.0   0.0  0.0  0.618034
  0.0      -3.0   1.0  0.0  0.0
  0.0       0.0   0.0  0.0  0.0
  0.0       0.0  -2.0  0.0  0.0
source
svd!(A, B) -> GeneralizedSVD

svd! के रूप में ही है svd , लेकिन प्रतियां बनाने के बजाय तर्कों A और B जगह को संशोधित करता है ।

उदाहरण

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

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

julia> F = svd!(A, B);

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

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

julia> A
2×2 Array{Float64,2}:
 1.41421   0.0
 0.0      -1.41421

julia> B
2×2 Array{Float64,2}:
 1.0  -0.0
 0.0  -1.0
source

LinearAlgebra.svdvals समारोह

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 Array{Float64,2}:
 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 Array{Float64,1}:
 3.0
 2.23606797749979
 2.0
 0.0
source
svdvals(A, B)

के सामान्यीकृत एकवचन मान के अपघटन से सामान्यीकृत एकवचन मान लौटाएं A और B । यह भी देखें svd

उदाहरण

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

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

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

LinearAlgebra.svdvals! समारोह

svdvals!(A)

A इनपुट को अधिलेखित करके अंतरिक्ष की बचत के एकवचन मूल्यों को लौटाएं । यह भी देखें svdvals और svd

उदाहरण

julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Array{Float64,2}:
 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 Array{Float64,1}:
 3.0
 2.23606797749979
 2.0
 0.0

julia> A
4×5 Array{Float64,2}:
 -2.23607   0.0   0.0  0.0  0.618034
  0.0      -3.0   1.0  0.0  0.0
  0.0       0.0   0.0  0.0  0.0
  0.0       0.0  -2.0  0.0  0.0
source
svdvals!(A, B)

की सामान्यीकृत विलक्षण मूल्य अपघटन से सामान्यीकृत विलक्षण मान A और B , ओवरराइट करके अंतरिक्ष की बचत A और B । यह भी देखें svd और svdvals

उदाहरण

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

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

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

julia> A
2×2 Array{Float64,2}:
 1.41421   0.0
 0.0      -1.41421

julia> B
2×2 Array{Float64,2}:
 1.0  -0.0
 0.0  -1.0
source

LinearAlgebra.Givens प्रकार

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

एक Givens रोटेशन रैखिक ऑपरेटर। खेतों c और s क्रमशः रोटेशन कोण के कोसाइन और साइन का प्रतिनिधित्व करते हैं। Givens प्रकार बाईं गुणन का समर्थन करता है G*A और संयुग्मित सही गुणा स्थानांतरित A*G' । प्रकार एक नहीं है size और इसलिए जब तक मनमाने ढंग से आकार के मैट्रिक्स के साथ गुणा किया जा सकता i2<=size(A,2) के लिए G*A या i2<=size(A,1) के लिए A*G'

यह भी देखें: givens

source

LinearAlgebra.givens समारोह

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

Givens रोटेशन G और स्केलर की गणना r करता है, x जहां किसी भी वेक्टर के लिए

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

गुणन का परिणाम है

y = G*x

संपत्ति है कि

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

यह भी देखें: LinearAlgebra.Givens

source
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

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

Givens रोटेशन G और स्केलर की गणना करता r है ताकि गुणा का परिणाम हो

B = G*x

संपत्ति है कि

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

यह भी देखें: LinearAlgebra.Givens

source

LinearAlgebra.triu समारोह

triu(M)

एक मैट्रिक्स का ऊपरी त्रिकोण।

उदाहरण

julia> a = fill(1.0, (4,4))
4×4 Array{Float64,2}:
 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 Array{Float64,2}:
 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
source
triu(M, k::Integer)

वें सुपरडायंगल M से शुरू होने के ऊपरी त्रिकोण को लौटाता है k

उदाहरण

julia> a = fill(1.0, (4,4))
4×4 Array{Float64,2}:
 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 Array{Float64,2}:
 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 Array{Float64,2}:
 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
source

LinearAlgebra.triu! समारोह

triu!(M)

एक मैट्रिक्स के ऊपरी त्रिकोण, M प्रक्रिया में ओवरराइटिंग । यह भी देखें triu

source
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 Array{Int64,2}:
 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 Array{Int64,2}:
 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
source

LinearAlgebra.tril समारोह

tril(M)

एक मैट्रिक्स का निचला त्रिकोण।

उदाहरण

julia> a = fill(1.0, (4,4))
4×4 Array{Float64,2}:
 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 Array{Float64,2}:
 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
source
tril(M, k::Integer)

वें सुपरडायंगल M से शुरू होने के निचले त्रिकोण को लौटाता है k

उदाहरण

julia> a = fill(1.0, (4,4))
4×4 Array{Float64,2}:
 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 Array{Float64,2}:
 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 Array{Float64,2}:
 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
source

LinearAlgebra.tril! समारोह

tril!(M)

मैट्रिक्स का निचला त्रिकोण, M प्रक्रिया में ओवरराइटिंग । यह भी देखें tril

source
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 Array{Int64,2}:
 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 Array{Int64,2}:
 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
source

LinearAlgebra.diagind समारोह

diagind(M, k::Integer=0)

एक AbstractRange के सूचकांकों देने k मैट्रिक्स के वें विकर्ण M

उदाहरण

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

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

LinearAlgebra.diag समारोह

diag(M, k::Integer=0)

k सदिश के रूप में एक मैट्रिक्स का वें विकर्ण।

यह भी देखें: diagm

उदाहरण

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

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

LinearAlgebra.diagm समारोह

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

Pair विकर्णों और वैक्टरों में से एक वर्ग मैट्रिक्स का निर्माण करें । वेक्टर kv.second को kv.first विकर्ण पर रखा जाएगा । diagm एक पूर्ण मैट्रिक्स का निर्माण करता है; यदि आप तेज़ अंकगणित के साथ भंडारण-कुशल संस्करण चाहते हैं, तो देखें Diagonal , और । Bidiagonal Tridiagonal SymTridiagonal

उदाहरण

julia> diagm(1 => [1,2,3])
4×4 Array{Int64,2}:
 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 Array{Int64,2}:
 0  1  0  0
 4  0  2  0
 0  5  0  3
 0  0  0  0
source

LinearAlgebra.rank समारोह

rank(A[, tol::Real])

एक मैट्रिक्स की रैंक की गणना करके गणना करें कि जहां एक A से अधिक एकवचन मान हैं, tol*σ₁ वहां से अधिक एकवचन के कितने विलक्षण मान हैं। डिफ़ॉल्ट रूप से, के मूल्य में सबसे छोटी आयाम है से गुणा की की । σ₁ A tol A eps eltype A

उदाहरण

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

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

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

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

LinearAlgebra.norm समारोह

norm(A, p::Real=2)

किसी भी चलने योग्य कंटेनर A (किसी भी आयाम के सरणियों सहित) (या किसी भी तत्व प्रकार जिसके norm लिए परिभाषित किया गया है) के लिए, p -norm (डिफ़ॉल्ट p=2 रूप से ) की गणना करें जैसे A कि संबंधित लंबाई के वेक्टर थे।

p -Norm के रूप में परिभाषित किया गया है

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

साथ a_i $ $ की प्रविष्टियों $ A $ , $ | a_i | $ norm के $ a_i $ , और $ n $ की लंबाई $ A $ । चूंकि p -norm norm की प्रविष्टियों के उपयोग से गणना की जाती है A , p वैक्टर के वेक्टर का -नॉर्म सामान्य रूप से ब्लॉक वेक्टर के रूप में इसकी व्याख्या के अनुकूल नहीं है 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 Array{Int64,1}:
  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
source
norm(x::Number, p::Real=2)

संख्याओं के लिए, $ $ बाएँ (| x | ^ p \ right) ^ {1 / p} $

उदाहरण

julia> norm(2, 1)
2

julia> norm(-2, 1)
2

julia> norm(2, 2)
2

julia> norm(-2, 2)
2

julia> norm(2, Inf)
2

julia> norm(-2, Inf)
2
source

LinearAlgebra.opnorm समारोह

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

ऑपरेटर के आदर्श (या मैट्रिक्स के आदर्श) वेक्टर द्वारा प्रेरित कंप्यूट p -norm, जहां की मान्य मान 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 $ , और $ एम $ और $ 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 Array{Int64,2}:
 1  -2  -3
 2   3  -1

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0
source
opnorm(x::Number, p::Real=2)

संख्याओं के लिए, $ $ बाएँ (| x | ^ p \ right) ^ {1 / p} $ । इसके बराबर है norm

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

एडजॉइंट / ट्रांसपोज़-लिपटे वैक्टर के लिए, ऑपरेटर $ q $ -norm लौटाएं A , जो p मूल्य के साथ -norm के बराबर है p = q/(q-1) । वे इत्तेफाक रखते हैं p = q = 2 । एक वेक्टर के रूप norm में p आदर्श की गणना करने के लिए उपयोग करें A

सदिश स्थान और उसके दोहरे के बीच के मानदंड में अंतर, द्वैत और डॉट उत्पाद के बीच संबंध को बनाए रखने के लिए उत्पन्न होता है, और परिणाम p एक 1 × n मैट्रिक्स के ऑपरेटर -norm के अनुरूप है ।

उदाहरण

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
source

LinearAlgebra.normalize! समारोह

normalize!(v::AbstractVector, p::Real=2)

वेक्टर सामान्य v में जगह ताकि उसके p -norm, एकता के बराबर होती है यानी norm(v, p) == 1 । यह भी देखें normalize और norm

source

LinearAlgebra.normalize समारोह

normalize(v::AbstractVector, p::Real=2)

वेक्टर को सामान्य करें v ताकि इसकी p -norm एकता के बराबर हो, अर्थात norm(v, p) == vecnorm(v, p) == 1 । यह भी देखें normalize! और norm

उदाहरण

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

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

julia> norm(b)
1.0

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

julia> norm(c, 1)
1.0
source

LinearAlgebra.cond समारोह

cond(M, p::Real=2)

मैट्रिक्स की स्थिति संख्या M , ऑपरेटर p -norm का उपयोग करके गणना की जाती है । के लिए मान्य मान p हैं 1 , 2 (डिफ़ॉल्ट), या Inf

source

LinearAlgebra.condskeel समारोह

condskeel(M, [x, p::Real=Inf])
\ [\ _ kappa_S (M, p) = \ left \ Vert \ Left \ vert M \ right \ vert \ vert \ _ M ^ {- 1} \ right \ vert \ right \ Vert_p \\ \ kappa_S (M, x) p) = \ left \ Vert \ Left M की दाईं या बाईं ओर की \ _ \ _ \ _ M ^ {- 1} \ right \ vert \ बाईं \ vert \ \ x \ right \ right \ Vert \p \]

Skeel हालत संख्या $ \ kappa_S $ मैट्रिक्स की M , वैकल्पिक रूप से वेक्टर के संबंध में x , के रूप में ऑपरेटर के उपयोग से गणना p -norm। $ \ left \ vert M \ right \ vert $ का मैट्रिक्स (प्रवेश वार) $ M $ के निरपेक्ष मान को दर्शाता है ; $ \ left \ vert M \ right \ vert_ {ij} = \ left \ vert M_ {ij} \ right \ vert $ । मान्य मान p हैं 1 , 2 और Inf (डिफ़ॉल्ट)।

इस मात्रा को साहित्य में बाउर स्थिति संख्या, सापेक्ष स्थिति संख्या या घटकवार सापेक्ष स्थिति संख्या के रूप में भी जाना जाता है।

source

LinearAlgebra.tr समारोह

tr(M)

मैट्रिक्स का निशान। के विकर्ण तत्वों को बताता है M

उदाहरण

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

julia> tr(A)
5
source

LinearAlgebra.det समारोह

det(M)

मैट्रिक्स निर्धारक।

उदाहरण

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

julia> det(M)
2.0
source

LinearAlgebra.logdet समारोह

logdet(M)

मैट्रिक्स निर्धारक का लॉग। के समतुल्य log(det(M)) , लेकिन बढ़ी हुई सटीकता और / या गति प्रदान कर सकता है।

उदाहरण

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

julia> logdet(M)
0.6931471805599453

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

LinearAlgebra.logabsdet समारोह

logabsdet(M)

मैट्रिक्स निर्धारक के पूर्ण मान का लॉग। के समतुल्य (log(abs(det(M))), sign(det(M))) , लेकिन बढ़ी हुई सटीकता और / या गति प्रदान कर सकता है।

उदाहरण

julia> A = [-1. 0.; 0. 1.]
2×2 Array{Float64,2}:
 -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 Array{Float64,2}:
 2.0  0.0
 0.0  1.0

julia> det(B)
2.0

julia> logabsdet(B)
(0.6931471805599453, 1.0)
source

Base.inv तरीका

inv(M)

मैट्रिक्स का उलटा। N ऐसे मैट्रिक्स की गणना करता है M * N = I , जहां I पहचान मैट्रिक्स है। बाएँ-मंडल को हल करके गणना की N = M \ I

उदाहरण

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

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

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

LinearAlgebra.pinv समारोह

pinv(M[, tol::Real])

मूर-पेनरोज़ स्यूडोइनवेरस की गणना करता है।

M फ़्लोटिंग पॉइंट तत्वों वाले मेट्रिसेस के लिए , किसी दिए गए दहलीज के ऊपर केवल एकवचन मानों को सम्मिलित करके छद्म बिंदु की गणना करना सुविधाजनक है tol

का इष्टतम विकल्प tol दोनों के मूल्य M और छद्म सूचक के इच्छित अनुप्रयोग के साथ भिन्न होता है । का डिफ़ॉल्ट मान tol है eps(real(float(one(eltype(M)))))*minimum(size(M)) , जो अनिवार्य रूप से बड़े मैट्रिक्स आयाम द्वारा गुणा किए गए मैट्रिक्स तत्व के वास्तविक भाग के लिए मशीन एप्सिलॉन है। कम से कम वर्गों के अर्थों में घने बीमार-वातानुकूलित मैटरों को निकालने के लिए, tol = sqrt(eps(real(float(one(eltype(M)))))) सिफारिश की जाती है।

अधिक जानकारी के लिए, [issue8859] , [B96] , [S84] , [KY88]

उदाहरण

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

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

julia> M * N
2×2 Array{Float64,2}:
 1.0          -2.22045e-16
 4.44089e-16   1.0
[issue8859]

अंक 8859, "फिक्स कम से कम वर्ग", https://github.com/JuliaLang/julia/pull/8809

[B96]

Åke Björck, "न्यूमेरिकल मेथड्स फॉर लीस्ट स्क्वेयर प्रॉब्लम्स", सियाम प्रेस, फिलाडेल्फिया, 1996, "एप्लाइड मैथमैटिक्स में अन्य टाइटल", वॉल्यूम। 51. doi:10.1137/1.9781611971484

[S84]

जीडब्ल्यू स्टीवर्ट, "रैंक डीजेनरेसी", वैज्ञानिक और सांख्यिकीय कम्प्यूटिंग पर SIAM जर्नल, 5 (2), 1984, 403-413। doi:10.1137/0905030

[KY88]

कॉनस्टैन्टिनो कोन्स्टेंटिनाइड्स और कुंग याओ, "मैट्रिक्स रैंक निर्धारण में प्रभावी विलक्षण मूल्यों का सांख्यिकीय विश्लेषण", एक्टैक्टिक्स, भाषण और सिग्नल प्रोसेसिंग पर आईईईई लेनदेन, 36 (5), 1988, 757-763। doi:10.1109/29.1585

source

LinearAlgebra.nullspace समारोह

nullspace(M[, tol::Real])

की nullspace के लिए एक आधार की गणना करता है M एक के एकमात्र वैक्टर जिसका एकमात्र परिमाण है से अधिक हैं शामिल करके tol*σ₁ , जहां σ₁ है A 'के सबसे बड़े विलक्षण मूल्यों। डिफ़ॉल्ट रूप से, के मूल्य tol में सबसे छोटी आयाम है A से गुणा eps की eltype की A

उदाहरण

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

julia> nullspace(M)
3×1 Array{Float64,2}:
 0.0
 0.0
 1.0

julia> nullspace(M, 2)
3×3 Array{Float64,2}:
 0.0  1.0  0.0
 1.0  0.0  0.0
 0.0  0.0  1.0
source

Base.kron समारोह

kron(A, B)

दो वैक्टर या दो मैट्रीक का क्रोनर टेंसर उत्पाद।

उदाहरण

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

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

julia> kron(A, B)
4×4 Array{Complex{Int64},2}:
 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
source

Base.exp तरीका

exp(A::AbstractMatrix)

A द्वारा परिभाषित मैट्रिक्स घातांक की गणना करें

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

सममित या हेर्मिटियन के लिए A , एक इगेंडेकम्पोजीशन ( eigen ) का उपयोग किया जाता है, अन्यथा स्केलिंग और स्क्वैरिंग एल्गोरिथ्म (देखें [H05] ) चुना जाता है।

[H05]

निकोलस जे। हिघम, "मैट्रिक्स एक्सपोनेंशियल रिविज़िटेड के लिए स्क्वेरिंग और स्केलिंग विधि", मैट्रिक्स विश्लेषण और अनुप्रयोग पर SIAM जर्नल, 26 (4) 2005, 1179-1193 doi:10.1137/090768539

उदाहरण

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

julia> exp(A)
2×2 Array{Float64,2}:
 2.71828  0.0
 0.0      2.71828
source

Base.log तरीका

log(A{T}::StridedMatrix{T})

यदि A कोई ऋणात्मक वास्तविक आईगेंवल्यू नहीं है, तो मूल मैट्रिक्स लॉगरिदम की गणना करें A , अर्थात अद्वितीय मैट्रिक्स $ X $ जैसे कि $ e ^ X = A $ और $ - \ pi <Im (\ lambda) <\ pi $ सभी eigenvalues $ के लिए \ lambda $ के $ X $ । यदि A गैर-संवेदी eigenvalues ​​है, तो एक nonprincipal मैट्रिक्स फ़ंक्शन जब भी संभव हो वापस किया जाता है।

यदि A सममित या हरमिटियन है, तो इसके ईगेंडेकोम्पोजिशन ( eigen ) का उपयोग किया जाता है, अगर A त्रिकोणीय उलटा स्केलिंग और [AH12] विधि का एक उन्नत संस्करण कार्यरत है (देखें [AH12] और [AHR13] )। सामान्य मैट्रिसेस के लिए, जटिल शूर फॉर्म ( schur ) की गणना की जाती है और त्रिकोणीय कारक पर त्रिकोणीय एल्गोरिथ्म का उपयोग किया जाता है।

[AH12]

अवाड एच। अल-मोही और निकोलस जे। हिघम, "मैट्रिक्स लॉगरिदम के लिए बेहतर उलटा स्केलिंग और स्क्वॉयर एल्गोरिदम", साइमैट जर्नल ऑन साइंटिफिक कंप्यूटिंग, 34 (4), 2012, C153-C169। doi:10.1137/110852553

[AHR13]

अवध एच। अल-मोही, निकोलस जे। हिघम और सैमुअल डी। रिल्टन, "मैट्रिक्स लॉगरिदम के फ्रैचेट व्युत्पन्न की गणना और स्थिति संख्या का आकलन", SIAM जर्नल ऑन साइंटिफिक कंप्यूटिंग, 35 (4), 2013, C394-C410। doi:10.1137/120885991

उदाहरण

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

julia> log(A)
2×2 Array{Float64,2}:
 1.0  0.0
 0.0  1.0
source

Base.sqrt तरीका

sqrt(A::AbstractMatrix)

यदि A कोई नकारात्मक वास्तविक eigenvalues ​​नहीं है, तो प्रिंसिपल मैट्रिक्स स्क्वायर रूट की गणना करें A , जो कि विशिष्ट वास्तविक भाग वाले eigenvalues ​​के साथ अद्वितीय मैट्रिक्स $ X $ है जैसे कि $ X ^ 2 = A $ । अन्यथा, एक nonprincipal वर्गमूल वापस आ जाता है।

यदि A सममित या हर्मिटियन है, तो इसका इगेंडेकोम्पोजिशन ( eigen ) वर्गमूल की गणना करने के लिए उपयोग किया जाता है। अन्यथा, वर्गमूल Björck-Hammarling विधि [BH83] माध्यम से निर्धारित किया जाता है , जो कि जटिल Schur रूप ( schur ) और फिर त्रिकोणीय कारक के जटिल वर्गमूल की गणना करता है।

[BH83]

Åके ब्योर्क और स्वेन हैमरलिंग, "मैट्रिक्स के वर्गमूल के लिए एक शूर विधि", रेखीय बीजगणित और इसके अनुप्रयोग, 52-53, 1983, 127-140। doi:10.1016/0024-3795(83)80010-X

उदाहरण

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

julia> sqrt(A)
2×2 Array{Float64,2}:
 2.0  0.0
 0.0  2.0
source

Base.cos तरीका

cos(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के मैट्रिक्स कोसाइन की गणना करें A

यदि A सममित या हरमिटियन है, तो इसके ईगेंडेकोम्पोजिशन ( eigen ) का उपयोग कॉशन की गणना के लिए किया जाता है। अन्यथा, कॉशन को कॉल करके निर्धारित किया जाता है inv

उदाहरण

julia> cos(fill(1.0, (2,2)))
2×2 Array{Float64,2}:
  0.291927  -0.708073
 -0.708073   0.291927
source

Base.sin तरीका

sin(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के मैट्रिक्स साइन की गणना करें A

यदि A सममित या हरमिटियन है, तो इसका इगेंडेकोम्पोजिशन ( eigen ) साइन की गणना करने के लिए उपयोग किया जाता है। अन्यथा, कॉल करके साइन निर्धारित किया जाता है inv

उदाहरण

julia> sin(fill(1.0, (2,2)))
2×2 Array{Float64,2}:
 0.454649  0.454649
 0.454649  0.454649
source

Base.Math.sincos तरीका

sincos(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के मैट्रिक्स साइन और कोसाइन की गणना करें A

उदाहरण

julia> S, C = sincos(fill(1.0, (2,2)));

julia> S
2×2 Array{Float64,2}:
 0.454649  0.454649
 0.454649  0.454649

julia> C
2×2 Array{Float64,2}:
  0.291927  -0.708073
 -0.708073   0.291927
source

Base.tan तरीका

tan(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के मैट्रिक्स स्पर्शरेखा की गणना करें A

यदि A सममित या हरमिटियन है, तो इसके एगेंडेकम्पोजिशन ( eigen ) का उपयोग स्पर्शरेखा की गणना करने के लिए किया जाता है। अन्यथा, स्पर्शरेखा को कॉल करके निर्धारित किया जाता है inv

उदाहरण

julia> tan(fill(1.0, (2,2)))
2×2 Array{Float64,2}:
 -1.09252  -1.09252
 -1.09252  -1.09252
source

Base.Math.sec तरीका

sec(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के मैट्रिक्स सेकंड की गणना करें A

source

Base.Math.csc तरीका

csc(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के मैट्रिक्स cosecant की गणना करें A

source

Base.Math.cot तरीका

cot(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के मैट्रिक्स कॉटेजेंट की गणना करें A

source

Base.cosh तरीका

cosh(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के मैट्रिक्स हाइपरबोलिक कोसाइन की गणना करें A

source

Base.sinh तरीका

sinh(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के मैट्रिक्स हाइपरबोलिक साइन की गणना करें A

source

Base.tanh तरीका

tanh(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के मैट्रिक्स हाइपरबोलिक स्पर्शरेखा की गणना करें A

source

Base.Math.sech तरीका

sech(A::AbstractMatrix)

वर्ग मैट्रिक्स के मैट्रिक्स हाइपरबोलिक सेकेंट की गणना करें A

source

Base.Math.csch तरीका

csch(A::AbstractMatrix)

वर्ग मैट्रिक्स के मैट्रिक्स हाइपरबोलिक कोसेंट की गणना करें A

source

Base.Math.coth तरीका

coth(A::AbstractMatrix)

वर्ग मैट्रिक्स के मैट्रिक्स हाइपरबोलिक कॉटेजेंट की गणना करें A

source

Base.acos तरीका

acos(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के व्युत्क्रम मैट्रिक्स कोसाइन की गणना करें A

यदि A सममित या हेर्मिटियन है, तो इसके ईगेंडेकोम्पोसिशन ( eigen ) का उपयोग उलटा कोसाइन की गणना के लिए किया जाता है। अन्यथा, उलटा कोसाइन का उपयोग करके निर्धारित किया जाता है inv और inv । इस फ़ंक्शन की गणना करने के लिए उपयोग किए जाने वाले सिद्धांत और लघुगणक सूत्र के लिए, [AH16_1]

[AH16_1]

मैरी एप्रामियन और निकोलस जे। हिघम, "मैट्रिक्स व्युत्क्रम त्रिकोणमितीय और व्युत्क्रम हाइपरबोलिक फ़ंक्शंस: सिद्धांत और एल्गोरिथ्म", एमआईएमएस अंश: 2016.4। https://doi.org/10.1137/16M1057577

उदाहरण

julia> acos(cos([0.5 0.1; -0.2 0.3]))
2×2 Array{Complex{Float64},2}:
  0.5-5.55112e-17im  0.1-2.77556e-17im
 -0.2+2.498e-16im    0.3-3.46945e-16im
source

Base.asin तरीका

asin(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के व्युत्क्रम मैट्रिक्स साइन की गणना करें A

यदि A सममित या हरमिटियन है, तो इसके ईगेंडेकोम्पोजिशन ( eigen ) का उपयोग उलटा साइन की गणना करने के लिए किया जाता है। अन्यथा, उलटा साइन का उपयोग करके निर्धारित किया जाता है inv और inv । इस फ़ंक्शन की गणना करने के लिए उपयोग किए जाने वाले सिद्धांत और लघुगणक सूत्र के लिए, [AH16_2]

[AH16_2]

मैरी एप्रामियन और निकोलस जे। हिघम, "मैट्रिक्स व्युत्क्रम त्रिकोणमितीय और व्युत्क्रम हाइपरबोलिक फ़ंक्शंस: सिद्धांत और एल्गोरिथ्म", एमआईएमएस अंश: 2016.4। https://doi.org/10.1137/16M1057577

उदाहरण

julia> asin(sin([0.5 0.1; -0.2 0.3]))
2×2 Array{Complex{Float64},2}:
  0.5-4.16334e-17im  0.1-5.55112e-17im
 -0.2+9.71445e-17im  0.3-1.249e-16im
source

Base.atan तरीका

atan(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के व्युत्क्रम मैट्रिक्स स्पर्शरेखा की गणना करें A

यदि A सममित या हर्मिटियन है, तो इसके एगेंडेकम्पोजीशन ( eigen ) का उपयोग उलटे स्पर्शरेखा की गणना के लिए किया जाता है। अन्यथा, उलटा स्पर्शरेखा का उपयोग करके निर्धारित किया जाता है inv । इस फ़ंक्शन की गणना करने के लिए उपयोग किए जाने वाले सिद्धांत और लघुगणक सूत्र के लिए, [AH16_3]

[AH16_3]

मैरी एप्रामियन और निकोलस जे। हिघम, "मैट्रिक्स व्युत्क्रम त्रिकोणमितीय और व्युत्क्रम हाइपरबोलिक फ़ंक्शंस: सिद्धांत और एल्गोरिथ्म", एमआईएमएस अंश: 2016.4। https://doi.org/10.1137/16M1057577

उदाहरण

julia> atan(tan([0.5 0.1; -0.2 0.3]))
2×2 Array{Complex{Float64},2}:
  0.5+1.38778e-17im  0.1-2.77556e-17im
 -0.2+6.93889e-17im  0.3-4.16334e-17im
source

Base.Math.asec तरीका

asec(A::AbstractMatrix)

प्रतिलोम मैट्रिक्स की गणना करें A

source

Base.Math.acsc तरीका

acsc(A::AbstractMatrix)

व्युत्क्रम मैट्रिक्स cosecant की तुलना करें A

source

Base.Math.acot तरीका

acot(A::AbstractMatrix)

उलटा मैट्रिक्स के कॉटेजेंट की गणना करें A

source

Base.acosh तरीका

acosh(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के उलटे हाइपरबोलिक मैट्रिक्स कोसाइन की गणना करें A । इस फ़ंक्शन की गणना करने के लिए उपयोग किए जाने वाले सिद्धांत और लघुगणक सूत्र के लिए, [AH16_4]

[AH16_4]

मैरी एप्रामियन और निकोलस जे। हिघम, "मैट्रिक्स व्युत्क्रम त्रिकोणमितीय और व्युत्क्रम हाइपरबोलिक फ़ंक्शंस: सिद्धांत और एल्गोरिथ्म", एमआईएमएस अंश: 2016.4। https://doi.org/10.1137/16M1057577

source

Base.asinh तरीका

asinh(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के व्युत्क्रम हाइपरबोलिक मैट्रिक्स साइन की गणना करें A । इस फ़ंक्शन की गणना करने के लिए उपयोग किए जाने वाले सिद्धांत और लघुगणकीय सूत्र के लिए, देखें [AH16_5]

[AH16_5]

मैरी एप्रामियन और निकोलस जे। हिघम, "मैट्रिक्स व्युत्क्रम त्रिकोणमितीय और व्युत्क्रम हाइपरबोलिक फ़ंक्शंस: सिद्धांत और एल्गोरिथ्म", एमआईएमएस अंश: 2016.4। https://doi.org/10.1137/16M1057577

source

Base.atanh तरीका

atanh(A::AbstractMatrix)

एक वर्ग मैट्रिक्स के उलटे हाइपरबोलिक मैट्रिक्स स्पर्शरेखा की गणना करें A । इस फ़ंक्शन की गणना करने के लिए उपयोग किए जाने वाले सिद्धांत और लघुगणकीय सूत्र के लिए, देखें [AH16_6]

[AH16_6]

मैरी एप्रामियन और निकोलस जे। हिघम, "मैट्रिक्स व्युत्क्रम त्रिकोणमितीय और व्युत्क्रम हाइपरबोलिक फ़ंक्शंस: सिद्धांत और एल्गोरिथ्म", एमआईएमएस अंश: 2016.4। https://doi.org/10.1137/16M1057577

source

Base.Math.asech तरीका

asech(A::AbstractMatrix)

उल्टे मैट्रिक्स हाइपरबोलिक सेकुलर की गणना करें A

source

Base.Math.acsch तरीका

acsch(A::AbstractMatrix)

उलटा मैट्रिक्स हाइपरबोलिक कॉसेकेंट की गणना करें A

source

Base.Math.acoth तरीका

acoth(A::AbstractMatrix)

उलटा मैट्रिक्स हाइपरबोलिक कॉटंगेंट की गणना करें A

source

LinearAlgebra.lyap समारोह

lyap(A, C)

X निरंतर लयापुणोव समीकरण के समाधान की गणना करता है AX + XA' + C = 0 , जहां किसी भी ईजेनवल्यू का A शून्य वास्तविक भाग नहीं होता है और कोई दो ईजेनवल एक दूसरे के नकारात्मक जटिल संयुग्म होते हैं।

उदाहरण

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

julia> B = [1. 1.; 1. 2.]
2×2 Array{Float64,2}:
 1.0  1.0
 1.0  2.0

julia> X = lyap(A, B)
2×2 Array{Float64,2}:
  0.5  -0.5
 -0.5   0.25

julia> A*X + X*A' + B
2×2 Array{Float64,2}:
 0.0          6.66134e-16
 6.66134e-16  8.88178e-16
source

LinearAlgebra.sylvester समारोह

sylvester(A, B, C)

समाधान की गणना करता है X सिलवेस्टर समीकरण को AX + XB + C = 0 , जहां A , B और C संगत आयाम है और A और -B बराबर असली भाग के साथ कोई eigenvalues है।

उदाहरण

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

julia> B = [1. 1.; 1. 2.]
2×2 Array{Float64,2}:
 1.0  1.0
 1.0  2.0

julia> C = [1. 2.; -2. 1]
2×2 Array{Float64,2}:
  1.0  2.0
 -2.0  1.0

julia> X = sylvester(A, B, C)
2×2 Array{Float64,2}:
 -4.46667   1.93333
  3.73333  -1.8

julia> A*X + X*B + C
2×2 Array{Float64,2}:
  2.66454e-15  1.77636e-15
 -3.77476e-15  4.44089e-16
source

LinearAlgebra.issuccess समारोह

issuccess(F::Factorization)

परीक्षण करें कि मैट्रिक्स का एक कारक सफल हुआ।

julia> F = cholesky([1 0; 0 1]);

julia> LinearAlgebra.issuccess(F)
true

julia> F = lu([1 0; 0 0]; check = false);

julia> LinearAlgebra.issuccess(F)
false
source

LinearAlgebra.issymmetric समारोह

issymmetric(A) -> Bool

परीक्षण करें कि क्या मैट्रिक्स सममित है।

उदाहरण

julia> a = [1 2; 2 -1]
2×2 Array{Int64,2}:
 1   2
 2  -1

julia> issymmetric(a)
true

julia> b = [1 im; -im 1]
2×2 Array{Complex{Int64},2}:
 1+0im  0+1im
 0-1im  1+0im

julia> issymmetric(b)
false
source

LinearAlgebra.isposdef समारोह

isposdef(A) -> Bool

परीक्षण करें कि क्या एक मैट्रिक्स सकारात्मक है (और हर्मिटियन) जो चोल्स्की के कारक का प्रदर्शन करने की कोशिश कर रहा है A । यह भी देखें isposdef!

उदाहरण

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

julia> isposdef(A)
true
source

LinearAlgebra.isposdef! समारोह

isposdef!(A) -> Bool

परीक्षण करें कि क्या कोई मैट्रिक्स सकारात्मक है (और हर्मिटियन) A , A प्रक्रिया में ओवरराइटिंग के चोल्स्की फैक्टराइज़ेशन को करने की कोशिश करके । यह भी देखें isposdef

उदाहरण

julia> A = [1. 2.; 2. 50.];

julia> isposdef!(A)
true

julia> A
2×2 Array{Float64,2}:
 1.0  2.0
 2.0  6.78233
source

LinearAlgebra.istril समारोह

istril(A::AbstractMatrix, k::Integer = 0) -> Bool

परीक्षण करें कि क्या A निम्न त्रिकोणीय k वें सुपरडाइगनल से शुरू हो रहा है ।

उदाहरण

julia> a = [1 2; 2 -1]
2×2 Array{Int64,2}:
 1   2
 2  -1

julia> istril(a)
false

julia> istril(a, 1)
true

julia> b = [1 0; -im -1]
2×2 Array{Complex{Int64},2}:
 1+0im   0+0im
 0-1im  -1+0im

julia> istril(b)
true

julia> istril(b, -1)
false
source

LinearAlgebra.istriu समारोह

istriu(A::AbstractMatrix, k::Integer = 0) -> Bool

परीक्षण करें कि क्या A ऊपरी त्रिकोणीय त्रिकोणीय से शुरू हो रहा है k

उदाहरण

julia> a = [1 2; 2 -1]
2×2 Array{Int64,2}:
 1   2
 2  -1

julia> istriu(a)
false

julia> istriu(a, -1)
true

julia> b = [1 im; 0 -1]
2×2 Array{Complex{Int64},2}:
 1+0im   0+1im
 0+0im  -1+0im

julia> istriu(b)
true

julia> istriu(b, 1)
false
source

LinearAlgebra.isdiag समारोह

isdiag(A) -> Bool

परीक्षण करें कि क्या मैट्रिक्स विकर्ण है।

उदाहरण

julia> a = [1 2; 2 -1]
2×2 Array{Int64,2}:
 1   2
 2  -1

julia> isdiag(a)
false

julia> b = [im 0; 0 -im]
2×2 Array{Complex{Int64},2}:
 0+1im  0+0im
 0+0im  0-1im

julia> isdiag(b)
true
source

LinearAlgebra.ishermitian समारोह

ishermitian(A) -> Bool

परीक्षण करें कि क्या मैट्रिक्स हर्मिटियन है।

उदाहरण

julia> a = [1 2; 2 -1]
2×2 Array{Int64,2}:
 1   2
 2  -1

julia> ishermitian(a)
true

julia> b = [1 im; -im 1]
2×2 Array{Complex{Int64},2}:
 1+0im  0+1im
 0-1im  1+0im

julia> ishermitian(b)
true
source

Base.transpose समारोह

transpose(A)

आलसी संक्रमण। लौटी हुई वस्तु को म्यूट करना उचित रूप से परिवर्तित करना चाहिए A । अक्सर, लेकिन हमेशा नहीं, पैदावार Transpose(A) , जहां Transpose एक आलसी ट्रांसपोज़र आवरण होता है। ध्यान दें कि यह ऑपरेशन पुनरावर्ती है।

यह ऑपरेशन रैखिक बीजगणित उपयोग के लिए है - सामान्य डेटा हेरफेर देखने के लिए permutedims , जो गैर-पुनरावर्ती है।

उदाहरण

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Array{Complex{Int64},2}:
 3+2im  9+2im
 8+7im  4+6im

julia> transpose(A)
2×2 Transpose{Complex{Int64},Array{Complex{Int64},2}}:
 3+2im  8+7im
 9+2im  4+6im
source

LinearAlgebra.transpose! समारोह

transpose!(dest,src)

सरणी को स्थानांतरित करें src और परिणाम को उपदेशित सरणी में संग्रहीत करें dest , जिसका आकार इसके अनुरूप होना चाहिए (size(src,2),size(src,1)) । कोई इन-जगह स्थानांतरण समर्थित है और अप्रत्याशित परिणाम होगा यदि src और dest अतिव्यापी स्मृति क्षेत्रों की है।

उदाहरण

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Array{Complex{Int64},2}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Array{Complex{Int64},2}:
 0+0im  0+0im
 0+0im  0+0im

julia> transpose!(B, A);

julia> B
2×2 Array{Complex{Int64},2}:
 3+2im  8+7im
 9+2im  4+6im

julia> A
2×2 Array{Complex{Int64},2}:
 3+2im  9+2im
 8+7im  4+6im
source

Base.adjoint समारोह

adjoint(A)

आलसी आसन्न (संयुग्मन ट्रांसपोज़िशन) (पोस्टफिक्स भी ' )। ध्यान दें कि adjoint तत्वों को पुनरावर्ती रूप से लागू किया जाता है।

यह ऑपरेशन रैखिक बीजगणित उपयोग के लिए है - सामान्य डेटा हेरफेर देखने के लिए permutedims

उदाहरण

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Array{Complex{Int64},2}:
 3+2im  9+2im
 8+7im  4+6im

julia> adjoint(A)
2×2 Adjoint{Complex{Int64},Array{Complex{Int64},2}}:
 3-2im  8-7im
 9-2im  4-6im
source

LinearAlgebra.adjoint! समारोह

adjoint!(dest,src)

Conjugate transpose array src और resultllocated array में स्टोर करें dest , जिसका आकार एक जैसा होना चाहिए (size(src,2),size(src,1)) । कोई इन-जगह स्थानांतरण समर्थित है और अप्रत्याशित परिणाम होगा यदि src और dest अतिव्यापी स्मृति क्षेत्रों की है।

उदाहरण

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Array{Complex{Int64},2}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Array{Complex{Int64},2}:
 0+0im  0+0im
 0+0im  0+0im

julia> adjoint!(B, A);

julia> B
2×2 Array{Complex{Int64},2}:
 3-2im  8-7im
 9-2im  4-6im

julia> A
2×2 Array{Complex{Int64},2}:
 3+2im  9+2im
 8+7im  4+6im
source

Base.copy तरीका

copy(A::Transpose)
copy(A::Adjoint)

बेसब्री से आलसी मैट्रिक्स ट्रांसजेंड / आसन्न का मूल्यांकन करें। ध्यान दें कि ट्रांसपोज़िशन तत्वों पर पुनरावर्ती रूप से लागू होता है।

यह ऑपरेशन रैखिक बीजगणित उपयोग के लिए है - सामान्य डेटा हेरफेर देखने के लिए permutedims , जो गैर-पुनरावर्ती है।

उदाहरण

julia> A = [1 2im; -3im 4]
2×2 Array{Complex{Int64},2}:
 1+0im  0+2im
 0-3im  4+0im

julia> T = transpose(A)
2×2 Transpose{Complex{Int64},Array{Complex{Int64},2}}:
 1+0im  0-3im
 0+2im  4+0im

julia> copy(T)
2×2 Array{Complex{Int64},2}:
 1+0im  0-3im
 0+2im  4+0im
source

LinearAlgebra.stride1 समारोह

stride1(A) -> Int

तत्व आकार की इकाइयों में आयाम 1 में क्रमिक सरणी तत्वों के बीच की दूरी लौटाएं।

उदाहरण

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

julia> LinearAlgebra.stride1(A)
1

julia> B = view(A, 2:2:4)
2-element view(::Array{Int64,1}, 2:2:4) with eltype Int64:
 2
 4

julia> LinearAlgebra.stride1(B)
2
source

LinearAlgebra.checksquare समारोह

LinearAlgebra.checksquare(A)

जांचें कि एक मैट्रिक्स चौकोर है, फिर इसके सामान्य आयाम को वापस करें। कई तर्कों के लिए, एक वेक्टर लौटाएं।

उदाहरण

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

julia> LinearAlgebra.checksquare(A, B)
2-element Array{Int64,1}:
 4
 5
source

निम्न-स्तरीय मैट्रिक्स ऑपरेशन

कई मामलों में मैट्रिक्स ऑपरेशंस के इन-प्लेस वर्जन होते हैं जो आपको प्री-एलोकेटेड आउटपुट वेक्टर या मैट्रिक्स की आपूर्ति करने की अनुमति देते हैं। बार-बार आवंटन के ओवरहेड से बचने के लिए महत्वपूर्ण कोड का अनुकूलन करते समय यह उपयोगी है। ये स्थान-संचालन सामान्य जूलिया सम्मेलन के अनुसार ! नीचे (जैसे mul! ) से प्रत्ययबद्ध हैं ।

LinearAlgebra.mul! समारोह

mul!(Y, A, B) -> Y

मैट्रिक्स-मैट्रिक्स या मैट्रिक्स-वेक्टर उत्पाद $ AB $ की गणना करता है और Y मौजूदा मूल्य को अधिलेखित करते हुए परिणाम को संग्रहीत करता है Y । ध्यान दें कि या Y तो साथ aliased नहीं होना चाहिए A या B

उदाहरण

julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; Y = similar(B); mul!(Y, A, B);

julia> Y
2×2 Array{Float64,2}:
 3.0  3.0
 7.0  7.0
source

LinearAlgebra.lmul! समारोह

lmul!(a::Number, B::AbstractArray)

B स्केलर a ओवरराइट करके B इन-प्लेस में एक स्केल स्केल करें ।

उदाहरण

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

julia> lmul!(2, B)
2×2 Array{Int64,2}:
 2  4
 6  8
source
lmul!(A, B)

मैट्रिक्स-मैट्रिक्स उत्पाद $ AB $ , ओवरराइटिंग की गणना करें B और परिणाम लौटाएं।

उदाहरण

julia> B = [0 1; 1 0];

julia> A = LinearAlgebra.UpperTriangular([1 2; 0 3]);

julia> LinearAlgebra.lmul!(A, B);

julia> B
2×2 Array{Int64,2}:
 2  1
 3  0
source

LinearAlgebra.rmul! समारोह

rmul!(A::AbstractArray, b::Number)

A स्केलर b ओवरराइट करके A इन-प्लेस में एक स्केल स्केल करें ।

उदाहरण

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

julia> rmul!(A, 2)
2×2 Array{Int64,2}:
 2  4
 6  8
source
rmul!(A, B)

मैट्रिक्स-मैट्रिक्स उत्पाद $ AB $ , ओवरराइटिंग की गणना करें A और परिणाम लौटाएं।

उदाहरण

julia> A = [0 1; 1 0];

julia> B = LinearAlgebra.UpperTriangular([1 2; 0 3]);

julia> LinearAlgebra.rmul!(A, B);

julia> A
2×2 Array{Int64,2}:
 0  3
 1  2
source

LinearAlgebra.ldiv! समारोह

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
3-element Array{Float64,1}:
  0.7128099173553719
 -0.051652892561983674
  0.10020661157024757

julia> A\X
3-element Array{Float64,1}:
  0.7128099173553719
 -0.05165289256198333
  0.10020661157024785
source
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
3-element Array{Float64,1}:
  0.7128099173553719
 -0.051652892561983674
  0.10020661157024757

julia> A\Y
3-element Array{Float64,1}:
  0.7128099173553719
 -0.05165289256198333
  0.10020661157024785
source

LinearAlgebra.rdiv! समारोह

rdiv!(A, B)

परिणाम को संग्रहीत करने के लिए A / B इन-प्लेस और ओवरराइटिंग की गणना करें A

तर्क मैट्रिक्स नहीं होना B चाहिए । बल्कि, मैट्रिस के बजाय यह एक फैक्टराइजेशन ऑब्जेक्ट होना चाहिए (उदाहरण के लिए या इसके द्वारा निर्मित )। इसका कारण यह है कि फैक्टरिज़ेशन स्वयं महंगा है और आम तौर पर मेमोरी आवंटित करता है (हालांकि इसे इन-प्लेस के माध्यम से, उदाहरण के लिए भी किया जा सकता है ), और प्रदर्शन-महत्वपूर्ण परिस्थितियों में आमतौर पर फैक्टरलाइज़ेशन पर ठीक-ठीक नियंत्रण की आवश्यकता होती है । factorize cholesky lu! rdiv! B

source

BLAS कार्य

जूलिया में (वैज्ञानिक गणना के रूप में), घने रैखिक-बीजगणित संचालन LAPACK पर आधारित हैं , जो कि मूल रैखिक-बीजगणित भवन-ब्लॉकों के शीर्ष पर BLAS रूप में जाना जाता है । प्रत्येक कंप्यूटर आर्किटेक्चर के लिए BLAS के अत्यधिक अनुकूलित कार्यान्वयन उपलब्ध हैं, और कभी-कभी उच्च-प्रदर्शन रैखिक बीजगणित दिनचर्या में यह BLAS कार्यों को सीधे कॉल करने के लिए उपयोगी है।

LinearAlgebra.BLAS कुछ बीएलएएस कार्यों के लिए आवरण प्रदान करता है। उन BLAS फ़ंक्शंस में से जो इनपुट सरणियों में से एक को ओवरराइट करते हैं, उनमें नाम समाप्त होते हैं '!' । आमतौर पर, एक BLAS समारोह चार विधियों में परिभाषित किया गया, के लिए है Float64 , Float32 , ComplexF64 , और ComplexF32 सरणियों।

BLAS चरित्र तर्क

कई बीएलएएस फ़ंक्शन उन तर्कों को स्वीकार करते हैं जो निर्धारित करते हैं कि क्या एक तर्क ( trans ) को स्थानांतरित करना है , जो मैट्रिक्स के त्रिकोण को संदर्भित करता है ( uplo या ul ), क्या त्रिकोणीय मैट्रिक्स का विकर्ण सभी को माना जा सकता है ( dA या मैट्रिक्स मैट्रिक्स के किस पक्ष को) इनपुट तर्क पर ( side ) है। संभावनाएं हैं:

गुणन क्रम

side अर्थ
'L' तर्क मैट्रिक्स-मैट्रिक्स ऑपरेशन के बाईं ओर जाता है ।
'R' तर्क मैट्रिक्स-मैट्रिक्स ऑपरेशन के दाईं ओर जाता है ।

त्रिभुज संदर्भ

uplo / ul अर्थ
'U' केवल मैट्रिक्स के ऊपरी त्रिकोण का उपयोग किया जाएगा।
'L' केवल मैट्रिक्स के निचले त्रिकोण का उपयोग किया जाएगा।

ट्रांसपोजेशन ऑपरेशन

trans / tX अर्थ
'N' इनपुट मैट्रिक्स X को ट्रांसपोज़ या संयुग्मित नहीं किया जाता है।
'T' इनपुट मैट्रिक्स X को ट्रांसपोज़ किया जाएगा।
'C' इनपुट मैट्रिक्स X को संयुग्मित और ट्रांसपोज़ किया जाएगा।

इकाई विकर्ण

diag / dX अर्थ
'N' मैट्रिक्स के विकर्ण मूल्यों को X पढ़ा जाएगा।
'U' मैट्रिक्स X का विकर्ण सभी को माना जाता है।

LinearAlgebra.BLAS मॉड्यूल

BLAS सबरूटीन्स को इंटरफ़ेस।

source

LinearAlgebra.BLAS.dotu समारोह

dotu(n, X, incx, Y, incy)

दो जटिल से मिलकर वैक्टर के लिए डॉट समारोह n सरणी के तत्वों के X कदम के साथ incx और n सरणी के तत्वों के Y कदम के साथ incy

उदाहरण

julia> BLAS.dotu(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
-10.0 + 10.0im
source

LinearAlgebra.BLAS.dotc समारोह

dotc(n, X, incx, U, incy)

दो जटिल वैक्टर के लिए डॉट समारोह, से मिलकर n सरणी के तत्वों के X कदम के साथ incx और n सरणी के तत्वों के U कदम के साथ incy , प्रथम वेक्टर conjugating।

उदाहरण

julia> BLAS.dotc(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
10.0 - 10.0im
source

LinearAlgebra.BLAS.blascopy! समारोह

blascopy!(n, X, incx, Y, incy)

कॉपी n सरणी के तत्वों के X कदम के साथ incx सरणी के लिए Y कदम के साथ incy । लौटता है Y

source

LinearAlgebra.BLAS.nrm2 समारोह

nrm2(n, X, incx)

वेक्टर के 2-मान जिसमें स्ट्राइड के साथ n सरणी के तत्व शामिल हैं । X incx

उदाहरण

julia> BLAS.nrm2(4, fill(1.0, 8), 2)
2.0

julia> BLAS.nrm2(1, fill(1.0, 8), 2)
1.0
source

LinearAlgebra.BLAS.asum समारोह

asum(n, X, incx)

स्ट्राइड के साथ n एरे के पहले तत्वों के पूर्ण मूल्यों का योग । X incx

उदाहरण

julia> BLAS.asum(5, fill(1.0im, 10), 2)
5.0

julia> BLAS.asum(2, fill(1.0im, 10), 5)
2.0
source

LinearAlgebra.axpy! समारोह

axpy!(a, X, Y)

के Y साथ अधिलेखित a*X + Y , जहां a एक अदिश राशि है। वापसी Y

उदाहरण

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

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

julia> BLAS.axpy!(2, x, y)
3-element Array{Int64,1}:
  6
  9
 12
source

LinearAlgebra.BLAS.scal! समारोह

scal!(n, a, X, incx)

ओवरराइट करें X साथ a*X पहले के लिए n सरणी के तत्वों के X कदम के साथ incx । लौटता है X

source

LinearAlgebra.BLAS.scal समारोह

scal(n, a, X, incx)

स्ट्राइड वाले एरे के पहले तत्वों के लिए X स्केल्ड रिटर्न । a n X incx

source

LinearAlgebra.BLAS.ger! समारोह

ger!(alpha, x, y, A)

रैंक -1 मैट्रिक्स के अद्यतन A वैक्टर के साथ x और y के रूप में alpha*x*y' + A

source

LinearAlgebra.BLAS.syr! समारोह

syr!(uplo, alpha, x, A)

रैंक -1 सममित मैट्रिक्स के अद्यतन A वेक्टर के साथ x के रूप में alpha*x*transpose(x) + A uplo नियंत्रित किया जाता है कि कौन सा त्रिकोण A अपडेट किया गया है। लौटता है A

source

LinearAlgebra.BLAS.syrk! समारोह

syrk!(uplo, trans, alpha, A, beta, C)

सममित मैट्रिक्स के रैंक-कश्मीर अद्यतन C के रूप में alpha*A*transpose(A) + beta*C या alpha*transpose(A)*A + beta*C के अनुसार trans । केवल uplo त्रिभुज का C उपयोग किया जाता है। लौटता है C

source

LinearAlgebra.BLAS.syrk समारोह

syrk(uplo, trans, alpha, A)

रिटर्न या तो ऊपरी त्रिकोण या के निचले त्रिकोण A , के अनुसार uplo , की alpha*A*transpose(A) या alpha*transpose(A)*A , के अनुसार trans

source

LinearAlgebra.BLAS.her! समारोह

her!(uplo, alpha, x, A)

केवल जटिल सरणियों के लिए तरीके। रैंक -1 मैट्रिक्स Hermitian का अद्यतन A वेक्टर के साथ x के रूप में alpha*x*x' + A uplo नियंत्रित किया जाता है कि कौन सा त्रिकोण A अपडेट किया गया है। लौटता है A

source

LinearAlgebra.BLAS.herk! समारोह

herk!(uplo, trans, alpha, A, beta, C)

केवल जटिल सरणियों के लिए तरीके। मैट्रिक्स Hermitian की रैंक-कश्मीर अद्यतन C के रूप में alpha*A*A' + beta*C या alpha*A'*A + beta*C के अनुसार trans । केवल uplo त्रिकोण C को अद्यतन किया गया है। लौटता है C

source

LinearAlgebra.BLAS.herk समारोह

herk(uplo, trans, alpha, A)

केवल जटिल सरणियों के लिए तरीके। के अनुसार या के uplo त्रिकोण देता है । alpha*A*A' alpha*A'*A trans

source

LinearAlgebra.BLAS.gbmv! समारोह

gbmv!(trans, m, kl, ku, alpha, A, x, beta, y)

वेक्टर अद्यतन y के रूप में alpha*A*x + beta*y या alpha*A'*x + beta*y के अनुसार trans । मैट्रिक्स A आयाम की एक सामान्य बैंड मैट्रिक्स है m द्वारा size(A,2) साथ kl उप विकर्णों और ku सुपर विकर्ण। alpha और beta स्केलर हैं। अपडेट लौटाएं y

source

LinearAlgebra.BLAS.gbmv समारोह

gbmv(trans, m, kl, ku, alpha, A, x)

के अनुसार alpha*A*x या वापस लौटें । मैट्रिक्स आयाम की एक सामान्य बैंड मैट्रिक्स है द्वारा साथ उप विकर्णों और सुपर विकर्ण, और एक अदिश है। alpha*A'*x trans A m size(A,2) kl ku alpha

source

LinearAlgebra.BLAS.sbmv! समारोह

sbmv!(uplo, k, alpha, A, x, beta, y)

वेक्टर y को अपडेट करें alpha*A*x + beta*y जहां तर्क में सुपर-विकर्णों के साथ A ऑर्डर का एक सममित बैंड मैट्रिक्स है । के लिए संग्रहण लेआउट को संदर्भ BLAS मॉड्यूल, स्तर -2 BLAS http://www.netlib.org/lapack/explore-html/ पर वर्णित किया गया है । केवल त्रिभुज का उपयोग किया जाता है। size(A,2) k A A http://www.netlib.org/lapack/explore-html/ uplo A

अपडेट लौटाएं y

source

LinearAlgebra.BLAS.sbmv तरीका

sbmv(uplo, k, alpha, A, x)

तर्क में संग्रहीत सुपर-विकर्णों के साथ ऑर्डर का एक सममित बैंड मैट्रिक्स है alpha*A*x जहां लौटें । केवल त्रिभुज का उपयोग किया जाता है। A size(A,2) k A uplo A

source

LinearAlgebra.BLAS.sbmv तरीका

sbmv(uplo, k, A, x)

तर्क में संग्रहीत सुपर-विकर्णों के साथ ऑर्डर का एक सममित बैंड मैट्रिक्स है A*x जहां लौटें । केवल त्रिभुज का उपयोग किया जाता है। A size(A,2) k A uplo A

source

LinearAlgebra.BLAS.gemm! समारोह

gemm!(tA, tB, alpha, A, B, beta, C)

अद्यतन C के रूप में alpha*A*B + beta*C या अन्य तीन के अनुसार वेरिएंट trans और tB । अपडेट लौटाएं C

source

LinearAlgebra.BLAS.gemm तरीका

gemm(tA, tB, alpha, A, B)

और alpha*A*B के अनुसार वापसी या अन्य तीन वेरिएंट । trans tB

source

LinearAlgebra.BLAS.gemm तरीका

gemm(tA, tB, A, B)

और A*B के अनुसार वापसी या अन्य तीन वेरिएंट । trans tB

source

LinearAlgebra.BLAS.gemv! समारोह

gemv!(tA, alpha, A, x, beta, y)

के अनुसार या के अनुसार वेक्टर y को अपडेट करें । और स्केलर हैं। अपडेट लौटाएं । alpha*A*x + beta*y alpha*A'x + beta*y trans alpha beta y

source

LinearAlgebra.BLAS.gemv तरीका

gemv(tA, alpha, A, x)

के अनुसार alpha*A*x या वापस लौटें । एक अदिश राशि है। alpha*A'x trans alpha

source

LinearAlgebra.BLAS.gemv तरीका

gemv(tA, A, x)

के अनुसार A*x या वापस लौटें । A'x trans

source

LinearAlgebra.BLAS.symm! समारोह

symm!(side, ul, alpha, A, B, beta, C)

अद्यतन C के रूप में alpha*A*B + beta*C या alpha*B*A + beta*C के अनुसार side A सममित माना जाता है। केवल uplo त्रिभुज का A उपयोग किया जाता है। अपडेट लौटाएं C

source

LinearAlgebra.BLAS.symm तरीका

symm(side, ul, alpha, A, B)

के अनुसार alpha*A*B या वापस लौटें । सममित माना जाता है। केवल त्रिभुज का उपयोग किया जाता है। alpha*B*A side A uplo A

source

LinearAlgebra.BLAS.symm तरीका

symm(side, ul, A, B)

के अनुसार A*B या वापस लौटें । सममित माना जाता है। केवल त्रिभुज का उपयोग किया जाता है। B*A side A uplo A

source

LinearAlgebra.BLAS.symv! समारोह

symv!(ul, alpha, A, x, beta, y)

वेक्टर y को अपडेट करें alpha*A*x + beta*yA सममित माना जाता है। केवल uplo त्रिभुज का A उपयोग किया जाता है। alpha और beta स्केलर हैं। अपडेट लौटाएं y

source

LinearAlgebra.BLAS.symv तरीका

symv(ul, alpha, A, x)

वापसी alpha*A*xA सममित माना जाता है। केवल uplo त्रिभुज का A उपयोग किया जाता है। alpha एक अदिश राशि है।

source

LinearAlgebra.BLAS.symv तरीका

symv(ul, A, x)

वापसी A*xA सममित माना जाता है। केवल uplo त्रिभुज का A उपयोग किया जाता है।

source

LinearAlgebra.BLAS.trmm! समारोह

trmm!(side, ul, tA, dA, alpha, A, B)

अद्यतन B के रूप में alpha*A*B या द्वारा निर्धारित अन्य तीन वेरिएंट में से एक side और trans । केवल uplo त्रिभुज का A उपयोग किया जाता है। dA निर्धारित करता है कि विकर्ण मान पढ़े जाते हैं या सभी को मान लिया जाता है। अद्यतन लौटाता है B

source

LinearAlgebra.BLAS.trmm समारोह

trmm(side, ul, tA, dA, alpha, A, B)

रिटर्न alpha*A*B या अन्य तीन वैरिएंट में से एक side और द्वारा निर्धारित trans । केवल uplo त्रिभुज का A उपयोग किया जाता है। dA निर्धारित करता है कि विकर्ण मान पढ़े जाते हैं या सभी को मान लिया जाता है।

source

LinearAlgebra.BLAS.trsm! समारोह

trsm!(side, ul, tA, dA, alpha, A, B)

ओवरराइट करें B करने के लिए समाधान के साथ A*X = alpha*B या द्वारा निर्धारित अन्य तीन वेरिएंट में से एक side और trans । केवल uplo त्रिभुज का A उपयोग किया जाता है। dA निर्धारित करता है कि विकर्ण मान पढ़े जाते हैं या सभी को मान लिया जाता है। अद्यतन लौटाता है B

source

LinearAlgebra.BLAS.trsm समारोह

trsm(side, ul, tA, dA, alpha, A, B)

का हल लौटें A*X = alpha*B या निर्धारित द्वारा निर्धारित से अन्य तीन वेरिएंट में से एक side और trans । केवल uplo त्रिभुज का A उपयोग किया जाता है। dA निर्धारित करता है कि विकर्ण मान पढ़े जाते हैं या सभी को मान लिया जाता है।

source

LinearAlgebra.BLAS.trmv! समारोह

trmv!(ul, tA, dA, A, b)

लौटें op(A)*b , जहां op द्वारा निर्धारित किया जाता है trans । केवल uplo त्रिभुज का A उपयोग किया जाता है। dA निर्धारित करता है कि विकर्ण मान पढ़े जाते हैं या सभी को मान लिया जाता है। गुणा-इन पर जगह-जगह होता है b

source

LinearAlgebra.BLAS.trmv समारोह

trmv(ul, tA, dA, A, b)

लौटें op(A)*b , जहां op द्वारा निर्धारित किया जाता है trans । केवल uplo त्रिभुज का A उपयोग किया जाता है। dA निर्धारित करता है कि विकर्ण मान पढ़े जाते हैं या सभी को मान लिया जाता है।

source

LinearAlgebra.BLAS.trsv! समारोह

trsv!(ul, tA, dA, A, b)

ओवरराइट करें b करने के लिए समाधान के साथ A*x = b या द्वारा निर्धारित अन्य दो वेरिएंट में से एक trans और uplo dA निर्धारित करता है कि विकर्ण मान पढ़े जाते हैं या सभी को मान लिया जाता है। अपडेट लौटाएं b

source

LinearAlgebra.BLAS.trsv समारोह

trsv(ul, tA, dA, A, b)

का हल लौटें A*x = b या द्वारा निर्धारित अन्य दो वेरिएंट में से एक trans और uplo dA निर्धारित करता है कि विकर्ण मान पढ़े जाते हैं या सभी को मान लिया जाता है।

source

LinearAlgebra.BLAS.set_num_threads समारोह

set_num_threads(n)

थ्रेड्स की संख्या सेट करें जिसे BLAS लाइब्रेरी का उपयोग करना चाहिए।

source

LinearAlgebra.I स्थिर

I

UniformScaling किसी भी आकार के एक पहचान मैट्रिक्स का प्रतिनिधित्व करने वाली एक प्रकार की वस्तु ।

उदाहरण

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

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

LAPACK फ़ंक्शंस

LinearAlgebra.LAPACK रैखिक बीजगणित के लिए LAPACK कार्यों में से कुछ के लिए आवरण प्रदान करता है। वे कार्य जो इनपुट सरणियों में से एक को अधिलेखित करते हैं उनमें नाम समाप्त होते हैं '!'

आम तौर पर एक समारोह में परिभाषित किया गया 4 तरीकों, के लिए एक-एक है Float64 , Float32 , ComplexF64 और ComplexF32 सरणियों।

ध्यान दें कि जूलिया द्वारा प्रदान किया गया LAPACK API भविष्य में बदल सकता है। चूंकि यह एपीआई उपयोगकर्ता-सामना नहीं कर रहा है, इसलिए भविष्य के रिलीज में कार्यों के इस विशिष्ट सेट का समर्थन / चित्रण करने के लिए कोई प्रतिबद्धता नहीं है।

LinearAlgebra.LAPACK मॉड्यूल

LAPACK सबरूटीन्स के लिए इंटरफेस।

source

LinearAlgebra.LAPACK.gbtrf! समारोह

gbtrf!(kl, ku, m, AB) -> (AB, ipiv)

एक बैंडेड मैट्रिक्स के एलयू गुणन की गणना करें ABkl नॉनज़ेरो बैंड वाला पहला सबडागोनल ku है, अंतिम सुपरडायंगल है जिसमें एक है, और m मैट्रिक्स का पहला आयाम है AB । एलयू फैक्टराइजेशन को इन-प्लेस और ipiv पीवॉट्स के वेक्टर का उपयोग करता है।

source

LinearAlgebra.LAPACK.gbtrs! समारोह

gbtrs!(trans, kl, ku, m, AB, ipiv, B)

समीकरण हल करें AB * X = Btrans के उन्मुखीकरण को निर्धारित करता है AB । यह N (कोई संक्रमण नहीं) हो सकता है , T (संक्रमण), या C (संयुग्म स्थानांतरण)। kl नॉनज़ेरो बैंड वाला पहला सबडागोनल ku है, अंतिम सुपरडायंगल है जिसमें एक है, और m मैट्रिक्स का पहला आयाम है ABipiv पीवोट्स के वेक्टर से लौटा है gbtrf! । वेक्टर या मैट्रिक्स लौटाता है X , ओवरराइटिंग B इन-प्लेस।

source

LinearAlgebra.LAPACK.gebal! समारोह

gebal!(job, A) -> (ilo, ihi, scale)

मैट्रिक्स A को उसके ईजेंसिस्टम या शूर फैक्टराइजेशन की गणना करने से पहले संतुलित करें। job इनमें से एक हो सकता है N ( A अनुमति नहीं दी जाएगी या स्केल की जाएगी), P ( A केवल अनुमत होगी ), S ( A केवल स्केल की जाएगी), या B ( A दोनों की अनुमति और माप की जाएगी)। संशोधित करता है A यथा-स्थान और रिटर्न ilo , ihi , और scale । यदि अनुमति देना चालू था, A[i,j] = 0 यदि j > i और 1 < j < ilo या j > ihiscale शामिल स्केलिंग / क्रमपरिवर्तन के बारे में जानकारी शामिल है।

source

LinearAlgebra.LAPACK.gebak! समारोह

gebak!(job, side, ilo, ihi, scale, V)

Eigenvectors रूपांतरण V एक मैट्रिक्स का उपयोग कर संतुलित का gebal! मूल मैट्रिक्स के बगैर माप / unpermuted eigenvectors करने के लिए। V जगह में संशोधित करता है। side हो सकता है L (बाएं ईजेनवेक्टर तब्दील हो जाते हैं) या R (दाएं ईजेनवेक्टर बदल दिए जाते हैं)।

source

LinearAlgebra.LAPACK.gebrd! समारोह

gebrd!(A) -> (A, d, e, tauq, taup)

A इन-प्लेस को बिडिओगल रूप में कम करें A = QBP' । रिटर्न A , बीडीओगल मैट्रिक्स से युक्त B ; d , के विकर्ण तत्वों से युक्त B ; e के ऑफ-विकर्ण तत्वों से युक्त B ; tauq , जिसमें प्राथमिक रिफ्लेक्टर शामिल हैं Q ; और taup , प्रतिनिधित्व करने वाले प्राथमिक परावर्तकों से युक्त P

source

LinearAlgebra.LAPACK.gelqf! समारोह

gelqf!(A, tau)

कंप्यूट LQ की गुणन A , A = LQtau स्केलर होते हैं जो कि कारक के प्रारंभिक परावर्तकों को परिमाणित करते हैं। tau सबसे छोटे आयाम के बराबर या उससे अधिक की लंबाई होनी चाहिए A

रिटर्न A और tau संशोधित जगह

source
gelqf!(A) -> (A, tau)

कंप्यूट LQ की गुणन A , A = LQ

रिटर्न A , इन-प्लेस संशोधित, और tau , जिसमें स्केलर होते हैं जो कि कारक के प्रारंभिक रिफ्लेक्टरों को मानकीकृत करते हैं।

source

LinearAlgebra.LAPACK.geqlf! समारोह

geqlf!(A, tau)

कंप्यूट QL की गुणन A , A = QLtau स्केलर होते हैं जो कि कारक के प्रारंभिक परावर्तकों को परिमाणित करते हैं। tau सबसे छोटे आयाम के बराबर या उससे अधिक की लंबाई होनी चाहिए A

रिटर्न A और tau संशोधित जगह

source
geqlf!(A) -> (A, tau)

कंप्यूट QL की गुणन A , A = QL

रिटर्न A , इन-प्लेस संशोधित, और tau , जिसमें स्केलर होते हैं जो कि कारक के प्रारंभिक रिफ्लेक्टरों को मानकीकृत करते हैं।

source

LinearAlgebra.LAPACK.geqrf! समारोह

geqrf!(A, tau)

कंप्यूट QR की गुणन A , A = QRtau स्केलर होते हैं जो कि कारक के प्रारंभिक परावर्तकों को परिमाणित करते हैं। tau सबसे छोटे आयाम के बराबर या उससे अधिक की लंबाई होनी चाहिए A

रिटर्न A और tau संशोधित जगह

source
geqrf!(A) -> (A, tau)

कंप्यूट QR की गुणन A , A = QR

रिटर्न A , इन-प्लेस संशोधित, और tau , जिसमें स्केलर होते हैं जो कि कारक के प्रारंभिक रिफ्लेक्टरों को मानकीकृत करते हैं।

source

LinearAlgebra.LAPACK.geqp3! समारोह

geqp3!(A, jpvt, tau)

BLAS स्तर 3 का उपयोग करते हुए , के pivoted QR कारक की गणना करें , द्वारा प्रतिनिधित्व किया गया एक धुरी मैट्रिक्स है । प्राथमिक रिफ्लेक्टरों को संग्रहीत करता है। यदि मैट्रिक्स है, तो उसकी लंबाई या उससे अधिक की लंबाई होनी चाहिए । सबसे छोटे आयाम के बराबर या उससे अधिक की लंबाई होनी चाहिए । A AP = QR P jpvt tau jpvt n A (mxn) tau A

A , jpvt और tau जगह में संशोधित कर रहे हैं।

source
geqp3!(A, jpvt) -> (A, jpvt, tau)

BLAS स्तर 3 का उपयोग करते हुए , के pivoted QR कारक की गणना करें , द्वारा प्रतिनिधित्व किया गया एक धुरी मैट्रिक्स है । यदि मैट्रिक्स है तो उससे अधिक या उसके बराबर लंबाई होनी चाहिए । A AP = QR P jpvt jpvt n A (mxn)

रिटर्न A और jpvt , संशोधित-इन-प्लेस, और tau , जो प्राथमिक रिफ्लेक्टरों को संग्रहीत करता है।

source
geqp3!(A) -> (A, jpvt, tau)

BLAS स्तर 3 का उपयोग करते हुए , की फैली हुई QR गुणन की गणना करें । A AP = QR

रिटर्न A , संशोधित-इन-प्लेस, jpvt जो धुरी मैट्रिक्स का प्रतिनिधित्व करता है P , और tau , जो प्राथमिक रिफ्लेक्टरों को संग्रहीत करता है।

source

LinearAlgebra.LAPACK.gerqf! समारोह

gerqf!(A, tau)

कंप्यूट RQ की गुणन A , A = RQtau स्केलर होते हैं जो कि कारक के प्रारंभिक परावर्तकों को परिमाणित करते हैं। tau सबसे छोटे आयाम के बराबर या उससे अधिक की लंबाई होनी चाहिए A

रिटर्न A और tau संशोधित जगह

source
gerqf!(A) -> (A, tau)

कंप्यूट RQ की गुणन A , A = RQ

रिटर्न A , इन-प्लेस संशोधित, और tau , जिसमें स्केलर होते हैं जो कि कारक के प्रारंभिक रिफ्लेक्टरों को मानकीकृत करते हैं।

source

LinearAlgebra.LAPACK.geqrt! समारोह

geqrt!(A, T)

अवरुद्ध कंप्यूट QR की गुणन A , A = QRT ऊपरी त्रिकोणीय ब्लॉक परावर्तक होते हैं जो कारक के प्राथमिक परावर्तकों को मापते हैं। T ब्लॉक आकार का पहला आयाम सेट करता है और इसे 1 और के बीच होना चाहिए n । के दूसरे आयाम के T सबसे छोटे आयाम के बराबर होना चाहिए A

रिटर्न A और T संशोधित जगह

source
geqrt!(A, nb) -> (A, T)

अवरुद्ध कंप्यूट QR की गुणन A , A = QRnb ब्लॉक आकार सेट करता है और यह 1 और n , के बीच का दूसरा आयाम होना चाहिए A

रिटर्न A , इन-प्लेस संशोधित, और T , जिसमें ऊपरी त्रिकोणीय ब्लॉक रिफ्लेक्टर शामिल हैं जो कि कारक के प्राथमिक रिफ्लेक्टरों को मापते हैं।

source

LinearAlgebra.LAPACK.geqrt3! समारोह

geqrt3!(A, T)

रिकर्सिवली अवरुद्ध गणना QR की गुणन A , A = QRT ऊपरी त्रिकोणीय ब्लॉक परावर्तक होते हैं जो कारक के प्राथमिक परावर्तकों को मापते हैं। T ब्लॉक आकार का पहला आयाम सेट करता है और इसे 1 और के बीच होना चाहिए n । के दूसरे आयाम के T सबसे छोटे आयाम के बराबर होना चाहिए A

रिटर्न A और T संशोधित जगह

source
geqrt3!(A) -> (A, T)

रिकर्सिवली अवरुद्ध गणना QR की गुणन A , A = QR

रिटर्न A , इन-प्लेस संशोधित, और T , जिसमें ऊपरी त्रिकोणीय ब्लॉक रिफ्लेक्टर शामिल हैं जो कि कारक के प्राथमिक रिफ्लेक्टरों को मापते हैं।

source

LinearAlgebra.LAPACK.getrf! समारोह

getrf!(A) -> (A, ipiv, info)

पिवट किए कंप्यूट LU की गुणन A , A = LU

रिटर्न A , इन-इन-प्लेस, संशोधित ipiv जानकारी, और एक info कोड जो सफलता को इंगित करता है ( info = 0 ), U ( info = i जिसमें केस U[i,i] एकवचन है) या एक त्रुटि कोड ( info < 0 ) में एक विलक्षण मूल्य ।

source

LinearAlgebra.LAPACK.tzrzf! समारोह

tzrzf!(A) -> (A, tau)

ऊपरी ट्रैपोज़ाइडल मैट्रिक्स A को ऊपरी त्रिकोणीय रूप में जगह में बदल देता है। रिटर्न A और tau , परिवर्तन के प्राथमिक रिफ्लेक्टर के लिए स्केलर पैरामीटर।

source

LinearAlgebra.LAPACK.ormrz! समारोह

ormrz!(side, trans, A, tau, C)

C द्वारा Q प्रदान किए गए परिवर्तन से मैट्रिक्स को गुणा करता है tzrzf! । पर निर्भर करता है side या trans गुणा बाएं तरफा ( side = L, Q*C ) या दाएं तरफा ( side = R, C*Q ) किया Q जा सकता है और अनमॉडिफाइड ( trans = N ), ट्रांसपोज़्ड ( trans = T ), या संयुग्मित ट्रांसपोज़्ड ( trans = C ) हो सकता है। मैट्रिक्स लौटाता है C जिसे गुणन के परिणाम के साथ संशोधित किया जाता है।

source

LinearAlgebra.LAPACK.gels! समारोह

gels!(trans, A, B) -> (F, B, ssr)

हल करती है रेखीय समीकरण A * X = B , transpose(A) * X = B या adjoint(A) * X = B एक QR या एलक्यू गुणन का उपयोग कर। B समाधान के साथ जगह में मैट्रिक्स / वेक्टर को संशोधित करता है । A इसके QR या LQ कारक के साथ अधिलेखित है। trans इनमें से एक N (कोई संशोधन नहीं), T (संक्रमण), या C (संयुग्म स्थानांतरण) हो सकता है। gels! न्यूनतम मानक / कम से कम वर्गों के समाधान की खोज करता है। A के तहत या निर्धारित किया जा सकता है। में समाधान वापस आ गया है B

source

LinearAlgebra.LAPACK.gesv! समारोह

gesv!(A, B) -> (B, A, ipiv)

रैखिक समीकरण को हल करता है, A * X = B जहाँ A के LU गुणन का उपयोग करके एक वर्ग मैट्रिक्स है AA इसके LU कारक के B साथ ओवरराइट किया गया है और समाधान के साथ ओवरराइट किया गया है Xipiv के LU कारक के लिए धुरी जानकारी शामिल है A

source

LinearAlgebra.LAPACK.getrs! समारोह

getrs!(trans, A, ipiv, B)

रेखीय समीकरण को हल करती है A * X = B , transpose(A) * X = B या adjoint(A) * X = B वर्ग के लिए AB समाधान के साथ जगह में मैट्रिक्स / वेक्टर को संशोधित करता है । A है LU से गुणन getrf! के साथ, ipiv पिवट जानकारी। trans इनमें से एक N (कोई संशोधन नहीं), T (संक्रमण), या C (संयुग्म स्थानांतरण) हो सकता है।

source

LinearAlgebra.LAPACK.getri! समारोह

getri!(A, ipiv)

द्वारा पाया गया A इसके LU कारक का उपयोग करते हुए, के व्युत्क्रम की गणना करता है getrf!ipiv धुरी सूचना उत्पादन है और A इसमें LU कारक का समावेश है getrf!A इसके विलोम के साथ ओवरराइट किया गया है।

source

LinearAlgebra.LAPACK.gesvx! समारोह

gesvx!(fact, trans, A, AF, ipiv, equed, R, C, B) -> (X, equed, R, C, B, rcond, ferr, berr, work)

के समीकरण का उपयोग कर रैखिक समीकरण A * X = B ( trans = N ), transpose(A) * X = B ( trans = T ), या adjoint(A) * X = B ( trans = C ) को हल करता LU है Afact हो सकता है E , जिस स्थिति A में उसे समतुल्य और कॉपी किया जाएगा AF ; F किस मामले में AF और ipiv पिछले LU कारक से इनपुट हैं; या N , किस मामले में A कॉपी किया जाएगा AF और फिर फैक्टर किया जाएगा। यदि fact = F , equed हो सकता है N , अर्थ A संतुलित नहीं किया गया है; R , अर्थ बाईं ओर से A गुणा किया गया था Diagonal(R) ; C , अर्थ सही से A गुणा किया गया था Diagonal(C) ; या से गुणा किया गया था B , अर्थ A Diagonal(R) बाईं ओर Diagonal(C) से और दाईं ओर से। तो fact = F और equed = R या B के तत्वों R चाहिए सभी सकारात्मक हो। तो fact = F और equed = C या B के तत्वों C चाहिए सभी सकारात्मक हो।

समाधान लौटाता है X ; equed , जो एक आउटपुट है अगर fact नहीं है N , और उस संतुलन का वर्णन करता है जो प्रदर्शन किया गया था; R , पंक्ति संतुलन विकर्ण; C , स्तंभ संतुलन विकर्ण; B , जो इसके समतुल्य रूप Diagonal(R)*B (यदि trans = N और equed = R,B ) या Diagonal(C)*B (यदि trans = T,C और equed = C,B ) के साथ अधिलेखित हो सकता है ; संतुलन rcond के A बाद की पारस्परिक स्थिति संख्या ; ferr , प्रत्येक सदिश वेक्टर के लिए बाध्य त्रुटि X ; berr , प्रत्येक सदिश वेक्टर के लिए बाध्य त्रुटि X ; और work , पारस्परिक धुरी वृद्धि कारक।

source
gesvx!(A, B)

नो-इक्वलाइब्रेशन, नो-ट्रांज़ोज़ सरलीकरण gesvx!

source

LinearAlgebra.LAPACK.gelsd! समारोह

gelsd!(A, B, rcond) -> (B, rnk)

A * X = B के SVD गुणन का पता लगाकर कम से कम मानक समाधान की गणना करता है A , फिर समस्या को विभाजित करना और जीतना। B समाधान के साथ ओवरराइट किया गया है X । नीचे दिए गए एकवचन मान rcond को शून्य माना जाएगा। में समाधान B और प्रभावी रैंक A देता है rnk

source

LinearAlgebra.LAPACK.gelsy! समारोह

gelsy!(A, B, rcond) -> (B, rnk)

A * X = B की पूर्ण QR फैक्टराइजेशन को खोजने के द्वारा कम से कम मानक समाधान की गणना करता है A , फिर समस्या को विभाजित करना और जीतना। B समाधान के साथ ओवरराइट किया गया है X । नीचे दिए गए एकवचन मान rcond को शून्य माना जाएगा। में समाधान B और प्रभावी रैंक A देता है rnk

source

LinearAlgebra.LAPACK.gglse! समारोह

gglse!(A, c, B, d) -> (X,res)

समीकरण को हल करता है A * x = c जहां x समानता की बाधा के अधीन है B * x = d||c - A*x||^2 = 0 हल करने के लिए सूत्र का उपयोग करता है । रिटर्न X और अवशिष्ट राशि के वर्ग।

source

LinearAlgebra.LAPACK.geev! समारोह

geev!(jobvl, jobvr, A) -> (W, VL, VR)

के इग्निशन सिस्टम को ढूंढता है A । यदि jobvl = N , बाएं ईजीनवेक्टर्स की A गणना नहीं की जाती है। यदि jobvr = N , सही eigenvectors की A गणना नहीं की जाती है। यदि jobvl = V या jobvr = V , इसी eigenvectors की गणना की जाती है। में eigenvalues ​​लौटाता है W , दाएं eigenvectors में VR और बाएं eigenvectors में VL

source

LinearAlgebra.LAPACK.gesdd! समारोह

gesdd!(job, A) -> (U, S, VT)

फूट डालो और जीतो दृष्टिकोण का उपयोग करते हुए A , एकवचन मूल्य के अपघटन को ढूँढता है A = U * S * V' । यदि job = A , सभी कॉलम U और पंक्तियों की V' गणना की जाती है। यदि job = N , कोई स्तंभ U या पंक्तियों की V' गणना नहीं की जाती है। यदि job = O , A (पतली) U और (पतली) की पंक्तियों के साथ ओवरराइट किया जाता है V' । यदि job = S , (पतले) U और (पतले) की पंक्तियों की V' गणना की जाती है और अलग से लौटाया जाता है।

source

LinearAlgebra.LAPACK.gesvd! समारोह

gesvd!(jobu, jobvt, A) -> (U, S, VT)

के एकमात्र मूल्य अपघटन ढूँढता है A , A = U * S * V' । यदि jobu = A , सभी स्तंभों की U गणना की जाती है। यदि jobvt = A सभी पंक्तियों की V' गणना की जाती है। यदि jobu = N , कोई कॉलम U संकलित नहीं किया गया है। यदि jobvt = N कोई पंक्तियों की V' गणना नहीं की जाती है। यदि jobu = O , A (पतले) कॉलम के साथ ओवरराइट किया गया है U । यदि jobvt = O , A (पतली) की पंक्तियों के साथ ओवरराइट किया गया है V' । यदि jobu = S , (पतले) स्तंभों की U गणना की जाती है और उन्हें अलग से लौटाया जाता है। यदि jobvt = S (पतली) की पंक्तियों की V' गणना की जाती है और अलग से लौटाई जाती है। jobu और jobvt दोनों नहीं हो सकते O

रिटर्न U , S और, और Vt जहां S के एकवचन मान हैं A

source

LinearAlgebra.LAPACK.ggsvd! समारोह

ggsvd!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)

A और B , U'*A*Q = D1*R और , के सामान्यीकृत एकवचन मूल्य को ढूँढता है V'*B*Q = D2*RD1 है alpha इसके विकर्ण पर और D2 है beta इसके विकर्ण पर। यदि jobu = U , ऑर्थोगोनल / एकात्मक मैट्रिक्स U की गणना की जाती है। यदि jobv = V ऑर्थोगोनल / एकात्मक मैट्रिक्स V की गणना की जाती है। यदि jobq = Q , ऑर्थोगोनल / एकात्मक मैट्रिक्स Q की गणना की जाती है। यदि jobu , jobv या jobq है N , तो उस मैट्रिक्स की गणना नहीं की जाती है। यह फ़ंक्शन केवल 3.6.0 से पहले LAPACK संस्करणों में उपलब्ध है।

source

LinearAlgebra.LAPACK.ggsvd3! समारोह

ggsvd3!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)

A और B , U'*A*Q = D1*R और , के सामान्यीकृत एकवचन मूल्य को ढूँढता है V'*B*Q = D2*RD1 है alpha इसके विकर्ण पर और D2 है beta इसके विकर्ण पर। यदि jobu = U , ऑर्थोगोनल / एकात्मक मैट्रिक्स U की गणना की जाती है। यदि jobv = V ऑर्थोगोनल / एकात्मक मैट्रिक्स V की गणना की जाती है। यदि jobq = Q , ऑर्थोगोनल / एकात्मक मैट्रिक्स Q की गणना की जाती है। यदि jobu , jobv या jobq है N , तो उस मैट्रिक्स की गणना नहीं की जाती है। इस फ़ंक्शन के लिए LAPACK 3.6.0 की आवश्यकता है।

source

LinearAlgebra.LAPACK.geevx! समारोह

geevx!(balanc, jobvl, jobvr, sense, A) -> (A, w, VL, VR, ilo, ihi, scale, abnrm, rconde, rcondv)

A मैट्रिक्स बैलेंसिंग के साथ इग्नेसिस्टम को ढूँढता है । यदि jobvl = N , बाएं ईजीनवेक्टर्स की A गणना नहीं की जाती है। यदि jobvr = N , सही eigenvectors की A गणना नहीं की जाती है। यदि jobvl = V या jobvr = V , इसी eigenvectors की गणना की जाती है। यदि balanc = N , कोई संतुलन नहीं किया जाता है। यदि balanc = P , अनुमति दी गई A है , लेकिन स्केल नहीं की गई है। यदि balanc = S , A बढ़ाया गया है, लेकिन अनुमति नहीं है। यदि balanc = B , अनुमति दी A और बढ़ाया है। यदि sense = N , कोई पारस्परिक स्थिति संख्याओं की गणना नहीं की जाती है। यदि sense = E , पारस्परिक स्थिति संख्याओं की गणना केवल स्वदेशी के लिए की जाती है। यदि sense = V , पारस्परिक स्थिति संख्याओं की गणना केवल सही eigenvectors के लिए की जाती है। अगर sense = B , पारस्परिक स्थिति संख्याओं की गणना सही ईजेनवेक्टरों और ईजेनवेक्टरों के लिए की जाती है। अगर sense = E,B दाएं और बाएं eigenvectors की गणना की जानी चाहिए।

source

LinearAlgebra.LAPACK.ggev! समारोह

ggev!(jobvl, jobvr, A, B) -> (alpha, beta, vl, vr)

की सामान्यीकृत eigendecomposition ढूँढता है A और B । यदि jobvl = N , बाएं आइगेनवेक्टर की गणना नहीं की जाती है। यदि jobvr = N , सही eigenvectors की गणना नहीं की जाती है। यदि jobvl = V या jobvr = V , इसी eigenvectors की गणना की जाती है।

source

LinearAlgebra.LAPACK.gtsv! समारोह

gtsv!(dl, d, du, B)

उस समीकरण को हल करता है A * X = B जहां A उप त्रिभुज के साथ त्रिभुज मैट्रिक्स होता है dl , d विकर्ण du पर और सुपरडायंगल पर।

B समाधान के साथ ओवरराइट करता है X और इसे वापस करता है।

source

LinearAlgebra.LAPACK.gttrf! समारोह

gttrf!(dl, d, du) -> (dl, d, du, du2, ipiv)

LU त्रिविकाल मैट्रिक्स के गुणन को उपखंड के साथ dl , d विकर्ण du पर और अतिशेष पर ढूँढता है ।

संशोधित करता है dl , d और एक du स्थान पर और उन्हें और दूसरा सुपरडाइगनल du2 और धुरी वेक्टर को वापस करता है ipiv

source

LinearAlgebra.LAPACK.gttrs! समारोह

gttrs!(trans, dl, d, du, du2, ipiv, B)

समीकरण A * X = B ( trans = N ), transpose(A) * X = B ( trans = T ), या adjoint(A) * X = B ( द्वारा गणना किए गए गुणनखंड trans = C का उपयोग करके) हल करता LU है gttrf!B समाधान के साथ ओवरराइट किया गया है X

source

LinearAlgebra.LAPACK.orglq! समारोह

orglq!(A, tau, k = length(tau))

स्पष्ट रूप से कॉल करने के बाद Q एक LQ कारक का मैट्रिक्स पाता है । के आउटपुट का उपयोग करता है gelqf! A gelqf!A द्वारा अधिलेखित है Q

source

LinearAlgebra.LAPACK.orgqr! समारोह

orgqr!(A, tau, k = length(tau))

स्पष्ट रूप से कॉल करने के बाद Q एक QR कारक का मैट्रिक्स पाता है । के आउटपुट का उपयोग करता है geqrf! A geqrf!A द्वारा अधिलेखित है Q

source

LinearAlgebra.LAPACK.orgql! समारोह

orgql!(A, tau, k = length(tau))

स्पष्ट रूप से कॉल करने के बाद Q एक QL कारक का मैट्रिक्स पाता है । के आउटपुट का उपयोग करता है geqlf! A geqlf!A द्वारा अधिलेखित है Q

source

LinearAlgebra.LAPACK.orgrq! समारोह

orgrq!(A, tau, k = length(tau))

स्पष्ट रूप से कॉल करने के बाद Q एक RQ कारक का मैट्रिक्स पाता है । के आउटपुट का उपयोग करता है gerqf! A gerqf!A द्वारा अधिलेखित है Q

source

LinearAlgebra.LAPACK.ormlq! समारोह

ormlq!(side, trans, A, tau, C)

गणना करता है Q * C ( trans = N ), transpose(Q) * C ( trans = T ), adjoint(Q) * C ( trans = C के लिए) side = L या के लिए बराबर सही तरफा गुणन side = R का उपयोग कर Q एक से LQ गुणन के A उपयोग से गणना gelqf!C अधिलेखित है।

source

LinearAlgebra.LAPACK.ormqr! समारोह

ormqr!(side, trans, A, tau, C)

गणना करता है Q * C ( trans = N ), transpose(Q) * C ( trans = T ), adjoint(Q) * C ( trans = C के लिए) side = L या के लिए बराबर सही तरफा गुणन side = R का उपयोग कर Q एक से QR गुणन के A उपयोग से गणना geqrf!C अधिलेखित है।

source

LinearAlgebra.LAPACK.ormql! समारोह

ormql!(side, trans, A, tau, C)

गणना करता है Q * C ( trans = N ), transpose(Q) * C ( trans = T ), adjoint(Q) * C ( trans = C के लिए) side = L या के लिए बराबर सही तरफा गुणन side = R का उपयोग कर Q एक से QL गुणन के A उपयोग से गणना geqlf!C अधिलेखित है।

source

LinearAlgebra.LAPACK.ormrq! समारोह

ormrq!(side, trans, A, tau, C)

गणना करता है Q * C ( trans = N ), transpose(Q) * C ( trans = T ), adjoint(Q) * C ( trans = C के लिए) side = L या के लिए बराबर सही तरफा गुणन side = R का उपयोग कर Q एक से RQ गुणन के A उपयोग से गणना gerqf!C अधिलेखित है।

source

LinearAlgebra.LAPACK.gemqrt! समारोह

gemqrt!(side, trans, V, T, C)

गणना करता है Q * C ( trans = N ), transpose(Q) * C ( trans = T ), adjoint(Q) * C ( trans = C के लिए) side = L या के लिए बराबर सही तरफा गुणन side = R का उपयोग कर Q एक से QR गुणन के A उपयोग से गणना geqrt!C अधिलेखित है।

source

LinearAlgebra.LAPACK.posv! समारोह

posv!(uplo, A, B) -> (A, B)

A * X = B जहाँ A सममित या हर्मिटियन पॉजिटिव निश्चित मैट्रिक्स है, वहां समाधान ढूंढता है । यदि uplo = U ऊपरी चोल्स्की अपघटन की A गणना की जाती है। यदि uplo = L निम्न चोल्स्की अपघटन की A गणना की जाती है। A इसकी चॉल्स्की अपघटन द्वारा अधिलेखित है। B समाधान के साथ ओवरराइट किया गया है X

source

LinearAlgebra.LAPACK.potrf! समारोह

potrf!(uplo, A)

सकारात्मक-निश्चित मैट्रिक्स के अपघटन चोल्स्की (ऊपरी अगर uplo = U , कम अगर uplo = L ) की गणना करता है AA ओवरराइट किया गया है और एक सूचना कोड के साथ लौटा है।

source

LinearAlgebra.LAPACK.potri! समारोह

potri!(uplo, A)

पॉल्सी अपघटन के अपने (ऊपरी अगर , कम अगर ) खोजने के लिए A कॉल potrf! करने के बाद सकारात्मक-निश्चित मैट्रिक्स के व्युत्क्रम की गणना करता है। uplo = U uplo = L

A इसके विलोम द्वारा अधिलेखित और वापस आ गया है।

source

LinearAlgebra.LAPACK.potrs! समारोह

potrs!(uplo, A, B)

का हल ढूँढता है A * X = B जहां A एक सममित या Hermitian सकारात्मक निश्चित मैट्रिक्स जिसका Cholesky अपघटन द्वारा गणना की गई थी potrf! । यदि uplo = U ऊपरी चोल्स्की के अपघटन की A गणना की गई थी। यदि uplo = L कम चोल्स्की के अपघटन की A गणना की गई थी। B समाधान के साथ ओवरराइट किया गया है X

source

LinearAlgebra.LAPACK.pstrf! समारोह

pstrf!(uplo, A, tol) -> (A, piv, rank, info)

उपयोगकर्ता-सेट सहिष्णुता के साथ सकारात्मक-निश्चित मैट्रिक्स के चोल्स्की अपघटन को पिवोट किया गया ऊपरी (यदि uplo = U , तो कम है uplo = L ) की गणना करता है । इसकी चॉल्स्की अपघटन द्वारा अधिलेखित है। A tol A

रिटर्न A , पिवोट्स piv , रैंक A और एक info कोड। अगर info = 0 , कारकत्व सफल हुआ। यदि info = i > 0 , तो A अनिश्चित या रैंक-कमी है।

source

LinearAlgebra.LAPACK.ptsv! समारोह

ptsv!(D, E, B)

A * X = B सकारात्मक-निश्चित त्रिदोष के लिए हल AD के विकर्ण है A और E ऑफ-विकर्ण है। B समाधान के साथ ओवरराइट किया गया X और वापस आ गया।

source

LinearAlgebra.LAPACK.pttrf! समारोह

pttrf!(D, E)

D विकर्ण के E रूप में और ऑफ-विकर्ण के साथ एक सकारात्मक-निश्चित त्रिदलीय मैट्रिक्स के एलडीएलटी गुणन की गणना करता है । D और E अधिलेखित और वापस आ गए हैं।

source

LinearAlgebra.LAPACK.pttrs! समारोह

pttrs!(D, E, B)

हल करती है A * X = B सकारात्मक-निश्चित त्रिविकर्णिक के लिए A साथ विकर्ण D और ऑफ विकर्ण E कंप्यूटिंग के बाद A की LDLt गुणन का उपयोग कर pttrf!B समाधान के साथ ओवरराइट किया गया है X

source

LinearAlgebra.LAPACK.trtri! समारोह

trtri!(uplo, diag, A)

त्रिकोणीय मैट्रिक्स के (ऊपरी अगर uplo = U , कम अगर uplo = L ) के व्युत्क्रम को ढूँढता है A । यदि diag = N , A गैर-इकाई विकर्ण तत्व हैं। यदि diag = U , सभी विकर्ण तत्व A एक हैं। A इसके विलोम के साथ ओवरराइट किया गया है।

source

LinearAlgebra.LAPACK.trtrs! समारोह

trtrs!(uplo, trans, diag, A, B)

एकल A * X = B ( trans = N ), transpose(A) * X = B ( trans = T ), या adjoint(A) * X = B ( trans = C ) के लिए (अगर ऊपरी uplo = U , कम अगर uplo = L ) त्रिकोणीय मैट्रिक्स A । यदि diag = N , A गैर-इकाई विकर्ण तत्व हैं। यदि diag = U , सभी विकर्ण तत्व A एक हैं। B समाधान के साथ ओवरराइट किया गया है X

source

LinearAlgebra.LAPACK.trcon! समारोह

trcon!(norm, uplo, diag, A)

त्रिभुजाकार मैट्रिक्स की पारस्परिक स्थिति संख्या (ऊपरी अगर uplo = U , कम यदि uplo = L ) को ढूँढता है A । यदि diag = N , A गैर-इकाई विकर्ण तत्व हैं। यदि diag = U , सभी विकर्ण तत्व A एक हैं। यदि norm = I , स्थिति संख्या अनंत मानदंड में पाई जाती है। यदि norm = O या 1 , हालत नंबर एक मानदंड में पाया जाता है।

source

LinearAlgebra.LAPACK.trevc! समारोह

trevc!(side, howmny, select, T, VL = similar(T), VR = similar(T))

एक ऊपरी त्रिकोणीय मैट्रिक्स के ईगेंस सिस्टम को ढूंढता है T । यदि side = R , सही आइजनवेक्टर की गणना की जाती है। यदि side = L , बाएं ईजेनवेक्टर की गणना की जाती है। यदि side = B , दोनों सेटों की गणना की जाती है। यदि howmny = A , सभी स्वदेशी पाए जाते हैं। यदि howmny = B , सभी eigenvectors पाए जाते हैं और backtransformed का उपयोग कर VL और VR । यदि howmny = S , केवल आइजनवेक्टर की select गणना मूल्यों के अनुरूप है ।

source

LinearAlgebra.LAPACK.trrfs! समारोह

trrfs!(uplo, trans, diag, A, B, X, Ferr, Berr) -> (Ferr, Berr)

का हल में त्रुटि अनुमान A * X = B ( trans = N ), transpose(A) * X = B ( trans = T ), adjoint(A) * X = B ( trans = C ) के लिए side = L , या समकक्ष समीकरणों को दाएं हाथ side = R X * A की गणना के बाद X का उपयोग कर trtrs! । यदि uplo = U , A ऊपरी त्रिकोणीय है। यदि uplo = L , A निम्न त्रिकोणीय है। यदि diag = N , A गैर-इकाई विकर्ण तत्व हैं। यदि diag = U , सभी विकर्ण तत्व A एक हैं। Ferr और Berr वैकल्पिक इनपुट हैं। Ferr फॉरवर्ड एरर है और Berr बैकवर्ड एरर है, प्रत्येक कंपोनेंट-वाइज।

source

LinearAlgebra.LAPACK.stev! समारोह

stev!(job, dv, ev) -> (dv, Zmat)

सममित त्रिदोषन मैट्रिक्स के लिए इगेंस सिस्टम dv को विकर्ण और ev ऑफ-विकर्ण के रूप में गणना करता है । यदि job = N केवल प्रतिजन पाए जाते हैं और वापस आते हैं dv । यदि job = V तब आइजनवेक्टर भी पाए जाते हैं और वापस लौट आते हैं Zmat

source

LinearAlgebra.LAPACK.stebz! समारोह

stebz!(range, order, vl, vu, il, iu, abstol, dv, ev) -> (dv, iblock, isplit)

सममित त्रिदोषन मैट्रिक्स के लिए प्रतिजन के dv रूप में और ev ऑफ-विकर्ण के रूप में प्रतिजन की गणना करता है । यदि range = A , सभी स्वदेशी पाए जाते हैं। यदि range = V , आधे खुले अंतराल में प्रतिजन (vl, vu] पाए जाते हैं। यदि range = I , के बीच के सूचकांकों के साथ स्वदेशी il और iu पाए जाते हैं। यदि order = B , किसी खंड के भीतर इग्ल्वेज़ का आदेश दिया जाता है। यदि order = E , वे सभी ब्लॉकों में दिए गए हैं। abstol अभिसरण के लिए सहिष्णुता के रूप में स्थापित किया जा सकता है।

source

LinearAlgebra.LAPACK.stegr! समारोह

stegr!(jobz, range, dv, ev, vl, vu, il, iu) -> (w, Z)

सममित त्रिदोषन मैट्रिक्स के लिए विकर्ण और ऑफ-विकर्ण के रूप में eigenvalues ​​( jobz = N ) या eigenvalues ​​और eigenvectors ( jobz = V ) की गणना करता है । यदि , सभी स्वदेशी पाए जाते हैं। यदि , आधे खुले अंतराल में प्रतिजन पाए जाते हैं। यदि , के बीच के सूचकांकों के साथ स्वदेशी और पाए जाते हैं। Eigenvalues ​​में वापस आ गए हैं और eigenvectors में हैं । dv ev range = A range = V (vl, vu] range = I il iu w Z

source

LinearAlgebra.LAPACK.stein! समारोह

stein!(dv, ev_in, w_in, iblock_in, isplit_in)

dv विकर्ण के ev_in रूप में और ऑफ-विकर्ण के साथ एक सममित त्रिदोषजन्य मैट्रिक्स के लिए eigenvectors की गणना करता है । w_in इनपुट eigenvalues ​​को निर्दिष्ट करता है जिसके लिए संबंधित eigenvectors को ढूंढना है। iblock_in में eigenvalues ​​के अनुरूप उपमात्राओं को निर्दिष्ट करता है w_inisplit_in सबमेट्रिक्स ब्लॉकों के बीच विभाजन बिंदुओं को निर्दिष्ट करता है।

source

LinearAlgebra.LAPACK.syconv! समारोह

syconv!(uplo, A, ipiv) -> (A, work)

एक सममित मैट्रिक्स A (जिसे त्रिकोणीय मैट्रिक्स में फैक्टर किया गया है) को दो मैट्रिक्स में परिवर्तित करता है L और D । यदि uplo = U , A ऊपरी त्रिकोणीय है। यदि uplo = L , यह कम त्रिकोणीय है। ipiv त्रिकोणीय कारक से धुरी वेक्टर है। A द्वारा अधिलेखित है L और D

source

LinearAlgebra.LAPACK.sysv! समारोह

sysv!(uplo, A, B) -> (B, A, ipiv)

A * X = B सममित मैट्रिक्स के लिए समाधान ढूंढता है A । यदि uplo = U , का ऊपरी आधा भाग A संग्रहित है। यदि uplo = L , निचले आधे को संग्रहीत किया जाता है। B समाधान द्वारा अधिलेखित है XA इसके बंच-कॉफमैन फैक्टराइजेशन द्वारा अधिलेखित है। ipiv जिसमें फैक्टराइजेशन के बारे में जानकारी होती है।

source

LinearAlgebra.LAPACK.sytrf! समारोह

sytrf!(uplo, A) -> (A, ipiv, info)

एक सममित मैट्रिक्स के बंच-कॉफ़मैन कारक की गणना करता है A । यदि uplo = U , का ऊपरी आधा भाग A संग्रहित है। यदि uplo = L , निचले आधे को संग्रहीत किया जाता है।

रिटर्न A , कारक द्वारा अधिलेखित, एक धुरी वेक्टर ipiv , और त्रुटि कोड info जो एक गैर-नकारात्मक पूर्णांक है। यदि info धनात्मक है तो मैट्रिक्स एकवचन है और गुणन का विकर्ण भाग स्थिति में बिल्कुल शून्य है info

source

LinearAlgebra.LAPACK.sytri! समारोह

sytri!(uplo, A, ipiv)

A के परिणामों का उपयोग करके एक सममित मैट्रिक्स के व्युत्क्रम की गणना करता है sytrf! । यदि uplo = U , का ऊपरी आधा भाग A संग्रहित है। यदि uplo = L , निचले आधे को संग्रहीत किया जाता है। A इसके विलोम द्वारा अधिलेखित है।

source

LinearAlgebra.LAPACK.sytrs! समारोह

sytrs!(uplo, A, ipiv, B)

के परिणामों का उपयोग करके A * X = B एक सममित मैट्रिक्स के लिए समीकरण को हल करता है A sytrf! । यदि uplo = U , का ऊपरी आधा भाग A संग्रहित है। यदि uplo = L , निचले आधे को संग्रहीत किया जाता है। B समाधान द्वारा अधिलेखित है X

source

LinearAlgebra.LAPACK.hesv! समारोह

hesv!(uplo, A, B) -> (B, A, ipiv)

A * X = B हरमिटियन मैट्रिक्स के लिए समाधान ढूँढता है A । यदि uplo = U , का ऊपरी आधा भाग A संग्रहित है। यदि uplo = L , निचले आधे को संग्रहीत किया जाता है। B समाधान द्वारा अधिलेखित है XA इसके बंच-कॉफमैन फैक्टराइजेशन द्वारा अधिलेखित है। ipiv जिसमें फैक्टराइजेशन के बारे में जानकारी होती है।

source

LinearAlgebra.LAPACK.hetrf! समारोह

hetrf!(uplo, A) -> (A, ipiv, info)

एक हर्मिटियन मैट्रिक्स के बंच-कॉफ़मैन कारक की गणना करता है A । यदि uplo = U , का ऊपरी आधा भाग A संग्रहित है। यदि uplo = L , निचले आधे को संग्रहीत किया जाता है।

रिटर्न A , कारक द्वारा अधिलेखित, एक धुरी वेक्टर ipiv , और त्रुटि कोड info जो एक गैर-नकारात्मक पूर्णांक है। यदि info धनात्मक है तो मैट्रिक्स एकवचन है और गुणन का विकर्ण भाग स्थिति में बिल्कुल शून्य है info

source

LinearAlgebra.LAPACK.hetri! समारोह

hetri!(uplo, A, ipiv)

A के परिणामों का उपयोग करके एक हर्मिटियन मैट्रिक्स के विलोम की गणना करता है sytrf! । यदि uplo = U , का ऊपरी आधा भाग A संग्रहित है। यदि uplo = L , निचले आधे को संग्रहीत किया जाता है। A इसके विलोम द्वारा अधिलेखित है।

source

LinearAlgebra.LAPACK.hetrs! समारोह

hetrs!(uplo, A, ipiv, B)

के परिणामों का उपयोग करके A * X = B एक हर्मिटियन मैट्रिक्स के लिए समीकरण को हल करता है A sytrf! । यदि uplo = U , का ऊपरी आधा भाग A संग्रहित है। यदि uplo = L , निचले आधे को संग्रहीत किया जाता है। B समाधान द्वारा अधिलेखित है X

source

LinearAlgebra.LAPACK.syev! समारोह

syev!(jobz, uplo, A)

एक सममित मैट्रिक्स के eigenvalues ​​( jobz = N ) या eigenvalues ​​और eigenvectors ( jobz = V ) को ढूँढता है A । यदि uplo = U , के ऊपरी त्रिकोण का A उपयोग किया जाता है। यदि uplo = L , के निचले त्रिकोण का A उपयोग किया जाता है।

source

LinearAlgebra.LAPACK.syevr! समारोह

syevr!(jobz, range, uplo, A, vl, vu, il, iu, abstol) -> (W, Z)

एक सममित मैट्रिक्स के eigenvalues ​​( jobz = N ) या eigenvalues ​​और eigenvectors ( jobz = V ) को ढूँढता है A । यदि uplo = U , के ऊपरी त्रिकोण का A उपयोग किया जाता है। यदि uplo = L , के निचले त्रिकोण का A उपयोग किया जाता है। यदि range = A , सभी स्वदेशी पाए जाते हैं। यदि range = V , आधे खुले अंतराल में प्रतिजन (vl, vu] पाए जाते हैं। यदि range = I , के बीच के सूचकांकों के साथ स्वदेशी il और iu पाए जाते हैं। abstol अभिसरण के लिए सहिष्णुता के रूप में स्थापित किया जा सकता है।

Eigenvalues ​​में वापस आ गए हैं W और eigenvectors में हैं Z

source

LinearAlgebra.LAPACK.sygvd! समारोह

sygvd!(itype, jobz, uplo, A, B) -> (w, A, B)

एक सममित मैट्रिक्स और सममितीय सकारात्मक-निश्चित मैट्रिक्स के सामान्यीकृत eigenvalues ​​( jobz = N ) या eigenvalues ​​और eigenvectors ( jobz = V ) ढूँढता है । यदि , का ऊपरी त्रिकोण और उपयोग किया जाता है। यदि , के निचले त्रिकोण और उपयोग किए जाते हैं। यदि , हल करने के लिए समस्या है । यदि , हल करने के लिए समस्या है । यदि , हल करने के लिए समस्या है । A B uplo = U A B uplo = L A B itype = 1 A * x = lambda * B * x itype = 2 A * B * x = lambda * x itype = 3 B * A * x = lambda * x

source

LinearAlgebra.LAPACK.bdsqr! समारोह

bdsqr!(uplo, d, e_, Vt, U, C) -> (d, Vt, U, C)

d विकर्ण के साथ और e_ ऑफ-विकर्ण पर एक द्विभुज मैट्रिक्स के एकवचन मूल्य अपघटन की गणना करता है। अगर uplo = U , e_ सुपरडायंगल है। यदि है uplo = L , e_ तो उपशाखा है। वैकल्पिक रूप से उत्पाद की गणना भी कर सकते हैं Q' * C

में एकवचन मान लौटाता है d , और मैट्रिक्स के C साथ ओवरराइट किया जाता है Q' * C

source

LinearAlgebra.LAPACK.bdsdc! समारोह

bdsdc!(uplo, compq, d, e_) -> (d, e, u, vt, q, iq)

एक विकर्ण मैट्रिक्स के साथ द्विभुज मैट्रिक्स के एकवचन मूल्य अपघटन की गणना d करता है और e_ ऑफ-विकर्ण पर एक विभाजित और शंकु विधि का उपयोग करता है। अगर uplo = U , e_ सुपरडायंगल है। यदि है uplo = L , e_ तो उपशाखा है। यदि compq = N , केवल एकवचन मान पाए जाते हैं। यदि compq = I , एकवचन मान और वैक्टर पाए जाते हैं। यदि compq = P , एकवचन मान और वैक्टर कॉम्पैक्ट रूप में पाए जाते हैं। केवल वास्तविक प्रकारों के लिए काम करता है।

में d , और अगर compq = P , कॉम्पैक्ट एकवचन वैक्टर में एकवचन मान लौटाता है iq

source

LinearAlgebra.LAPACK.gecon! समारोह

gecon!(normtype, A, anorm)

मैट्रिक्स की पारस्परिक स्थिति संख्या को ढूँढता है A । यदि normtype = I , स्थिति संख्या अनंत मानदंड में पाई जाती है। यदि normtype = O या 1 , हालत नंबर एक मानदंड में पाया जाता है। A का परिणाम होना चाहिए getrf! और anorm के आदर्श है A प्रासंगिक आदर्श में।

source

LinearAlgebra.LAPACK.gehrd! समारोह

gehrd!(ilo, ihi, A) -> (A, tau)

एक मैट्रिक्स A को हेसनबर्ग रूप में परिवर्तित करता है । अगर तब के A साथ संतुलित है और के आउटपुट हैं gebal! ilo ihi gebal! । अन्यथा वे किया जाना चाहिए ilo = 1 और ihi = size(A,2)tau इसमें कारक के प्राथमिक प्रतिबिंब होते हैं।

source

LinearAlgebra.LAPACK.orghr! समारोह

orghr!(ilo, ihi, A, tau)

स्पष्ट रूप से पाता है Q , ऑर्थोगोनल / एकात्मक मैट्रिक्स से gehrd!ilo , ihi , A , और tau इनपुट / आउटपुट के लिए के अनुरूप होना चाहिए gehrd!

source

LinearAlgebra.LAPACK.gees! समारोह

gees!(jobvs, A) -> (A, vs, w)

मैट्रिक्स के eigenvalues ​​( jobvs = N ) या eigenvalues ​​और Schur वैक्टर ( jobvs = V ) की गणना करता है AA अपने Schur रूप से अधिलेखित है।

रिटर्न A , vs Schur वैक्टर युक्त, और w , eigenvalues ​​युक्त।

source

LinearAlgebra.LAPACK.gges! समारोह

gges!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)

सामान्यीकृत eigenvalues, सामान्यीकृत Schur रूप, बाएं Schur वैक्टर ( jobsvl = V ), या दाएं Schur वैक्टर ( jobvsr = V ) A और की गणना करता है B

सामान्यीकृत eigenvalues में लौटा दिए जाते हैं alpha और beta । बाएं शूअर वैक्टर वापस आ गए हैं vsl और दाएं शूर वैक्टर वापस आ गए हैं vsr

source

LinearAlgebra.LAPACK.trexc! समारोह

trexc!(compq, ifst, ilst, T, Q) -> (T, Q)

एक मैट्रिक्स के Schur कारक को फिर से व्यवस्थित करें। यदि compq = V , Schur वैक्टर पुन: व्यवस्थित Q किए जाते हैं। यदि compq = N उन्हें संशोधित नहीं किया गया है। ifst और ilst वैक्टर के पुनः क्रमांकन को निर्दिष्ट करें।

source

LinearAlgebra.LAPACK.trsen! समारोह

trsen!(compq, job, select, T, Q) -> (T, Q, w, s, sep)

एक मैट्रिक्स के Schur कारक को फिर से व्यवस्थित करें और वैकल्पिक रूप से पारस्परिक स्थिति संख्याएं पाता है। यदि job = N , कोई शर्त संख्या नहीं मिली है। यदि job = E , केवल इस समूह के आइजेन्यूल्स के लिए स्थिति संख्या पाई जाती है। यदि job = V , केवल अपरिवर्तनीय उप-संख्या के लिए शर्त संख्या पाई जाती है। यदि job = B तब क्लस्टर और सबस्पेस के लिए स्थिति संख्याएँ पाई जाती हैं। यदि compq = V शूअर वैक्टर Q अपडेट किए जाते हैं। यदि compq = N शूअर वैक्टर को संशोधित नहीं किया गया है। select निर्धारित करता है कि क्लस्टर में कौन से प्रतिजन हैं।

रिटर्न T ,, Q में पुन: क्रमबद्ध eigenvalues, eigenvalues w के क्लस्टर की s स्थिति संख्या और अपरिवर्तनीय उप-संख्या की स्थिति संख्या sep

source

LinearAlgebra.LAPACK.tgsen! समारोह

tgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)

एक सामान्यीकृत शूर अपघटन के वैक्टर को फिर से व्यवस्थित करता है। select प्रत्येक क्लस्टर में eigenvalues ​​निर्दिष्ट करता है।

source

LinearAlgebra.LAPACK.trsyl! समारोह

trsyl!(transa, transb, A, B, C, isgn=1) -> (C, scale)

सिलवेस्टर मैट्रिक्स समीकरण को हल करती है A * X +/- X * B = scale*C जहां A और B दोनों अर्ध ऊपरी त्रिकोणीय हैं। यदि transa = N , A संशोधित नहीं किया गया है। यदि transa = T , A इसका प्रत्यारोपण किया जाता है। यदि transa = C , A संयुग्मित है। इसी तरह के लिए transb और B । यदि isgn = 1 , समीकरण A * X + X * B = scale * C हल हो गया है। यदि isgn = -1 , समीकरण A * X - X * B = scale * C हल हो गया है।

रिटर्न X (ओवरराइटिंग C ) और scale

source

Original text