मैट्रिक्स का उल्टा करना अच्छा क्यों नहीं है, इसका व्यावहारिक उदाहरण

Question

मैं इस बारे में अवगत हूं कि लीनियर सिस्टम को हल करने के लिए एक मैट्रिक्स में प्रवेश करना एक अच्छा विचार नहीं है, क्योंकि यह उतना सटीक और कुशल नहीं है जितना कि सिस्टम को सीधे हल करना या एलयू, चोल्स्की या क्यूआर अपघटन का उपयोग करना है।

हालांकि, मैं इसे व्यावहारिक उदाहरण के साथ जांचने में सक्षम नहीं हूं। मैंने इस कोड की कोशिश की है (MATLAB में)

M   = 500;    
A   = rand(M,M);
A   = real(expm(1i*(A+A.')));
b   = rand(M,1);

x1  = A\b;
x2  = inv(A)*b;

disp(norm(b-A*x1))
disp(norm(b-A*x2))

और अवशिष्ट हमेशा एक ही क्रम (10 ^ -13) के होते हैं।

क्या कोई व्यक्ति एक व्यावहारिक उदाहरण प्रदान कर सकता है जिसमें A (b) की तुलना में inv (A) * b बहुत कम गलत है?

------ प्रश्न अद्यतन ------

आपके जवाबों के लिये धन्यवाद। हालांकि, मान लीजिए कि हमें x ए b = n सिस्टम को हल करना है , जहां ए हमेशा एक ही मैट्रिक्स है। उस पर विचार करे$n$$Ax = b$$A$

- भरा हुआ है, और इस तरह एक - 1 से एक ही स्मृति भंडारण की आवश्यकता है एक ।$A$$A^{-1}$$A$

की -इस हालत संख्या छोटा सा है, इसलिए एक - 1 सटीकता के साथ की जा सकती है।$A$$A^{-1}$

उस स्थिति में, क्या LU अपघटन का उपयोग करने के बजाय गणना करना अधिक कुशल नहीं होगा ? उदाहरण के लिए, मैंने इस माटलब कोड की कोशिश की है:$A^{-1}$

%Set A and b:
M           = 1000; 
A           = rand(M,M);
A           = real(expm(1i*(A+A.')));
b           = rand(M,1);

%Times we solve the system:
n           = 3000;

%Performing LU decomposition:
disp('Performing LU decomposition')
tic
[L,U,P]     = lu(A);
toc
fprintf('\n')

%Solving the system n times with LU decomposition:
optsL.LT    = true;   %Options for linsolve
optsU.UT    = true;
disp('Solving the system n times using LU decomposition')
tic
for ii=1:n
    x1      = linsolve(U, linsolve(L,P*b,optsL) , optsU);
end
toc
fprintf('\n')

%Computing inverse of A:
disp('Computing inverse of A')
tic
Ainv        = inv(A);
toc
fprintf('\n')

%Solving the system n times with Ainv:
disp('Solving the system n times with A inv')
tic
for ii=1:n
    x2  = Ainv*b;
end
toc
fprintf('\n')

disp('Residuals')
disp(norm(b-A*x1))
disp(norm(b-A*x2))

disp('Condition number of A')
disp(cond(A))

लगभग 450 की संख्या वाली मैट्रिक्स के लिए, अवशिष्ट दोनों मामलों में , लेकिन LU अपघटन का उपयोग करते हुए सिस्टम n को हल करने में 19 सेकंड लगते हैं, जबकि A के व्युत्क्रम का उपयोग करने में केवल 9 सेकंड लगते हैं।$O(10^{-11})$

Comments

MATLAB सहायता पृष्ठ आमंत्रण के लिए एक अच्छा उदाहरण देता है। सॉल्व लीनियर सिस्टम शीर्षक वाले सेक्शन को देखें ।

— गोहोकियाँ

btw, आपके मैट्रिक्स की स्थिति संख्या क्या है ? मेरे पास काम पर मेरे पीसी पर MATLAB नहीं है इसलिए मैं जांच नहीं कर सकता, लेकिन मुझे लगता है कि यह आपके लिए एक सटीक व्युत्क्रम पाने के लिए काफी छोटा है ...$A$

— गोहकीज

मैंने ट्रेफेथेन और बाऊ (व्यायाम 21.4) पर एक नज़र डाली, और उन्होंने इसे विशुद्ध रूप से गणना की लागत, फ्लॉप बनाम 2 के रूप में वर्णित किया ।$2n^3$फ्लॉप। यहां तक ​​कि अगर आप अवशेषों को समान पाते हैं (क्या आपने अधिक खराब हालत वाले मैट्रिस की जांच करने की कोशिश की है, जैसा कि गोहिसेस की टिप्पणी में?), अनावश्यक गणना लागत अकेले सलाह के लायक है। $\frac23 n^3$

— किरिल

इस तुलना के लिए आपका मैट्रिक्स आकार बहुत छोटा और अच्छी तरह से वातानुकूलित है। ऐसा नहीं है कि जहां आपके पास इस तरह के मैट्रीस हैं, वहां प्रासंगिक समस्याएं नहीं हैं, लेकिन प्राप्त राय है कि आपको इनवर्टर नहीं करना चाहिए, एक अलग सेटिंग के लिए है (उदाहरण के लिए, क्रिस रैकैकस ने अपने उत्तर में उल्लेख किया है)। वास्तव में, छोटे और - प्रमाणित रूप से - अच्छी तरह से वातानुकूलित मैट्रीस के लिए, उलटा गणना करना वास्तव में बेहतर विकल्प हो सकता है। एक चरम मामला 3x3 रोटेशन (या, अधिक वास्तविक, affine परिवर्तन) matrices होगा।

— क्रिश्चियन क्लैसन

यदि आपको बार-बार Ax=bउसी के साथ हल करने की आवश्यकता है Aऔर यह व्युत्क्रम को लेने के लिए काफी छोटा है, तो आप इसके बजाय एलयू-फैक्टराइजेशन को बचा सकते हैं और इसका पुन: उपयोग कर सकते हैं।

— क्रिस रैकाकस

Answer 1

आम तौर पर व्युत्क्रम का उपयोग करने के लिए एक रैखिक प्रणाली के सम्मान को हल करने के लिए कुछ प्रमुख कारण हैं। संक्षेप में:

• सशर्त संख्या के साथ समस्या (@GoHokies टिप्पणी)
• विरल मामले में समस्या (@ChrisRackauckas उत्तर)
• दक्षता (@Kirill टिप्पणी)

वैसे भी, जैसा कि @ChristianClason ने टिप्पणियों में कहा, कुछ ऐसे मामले हो सकते हैं, जहां उलटा का उपयोग एक अच्छा विकल्प है।

एलेक्स ड्रुंस्की, सिवन टोलेडो द्वारा नोट / लेख में, कैसे सटीक है (ए) * बी? इस समस्या के बारे में कुछ विचार हैं।

$x$

$$\text{inverse} \quad || x_V - x || \leq O(\kappa^2(A) \epsilon_{machine})\\ \text{ backward stable (LU, QR,...)} \quad || x_{backward-stable} - x || \leq O(\kappa(A) \epsilon_{machine})$$

$x_V$

$V$

$V$ एक अच्छा सही उलटा नहीं है, या

$V$$||x_V||$$||x||$

$b$$A$

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

सामान्य तौर पर, मेरी राय में, रैखिक प्रणाली को हल करना अधिक सुरक्षित है।

Answer 2

$\Delta u$

$$u_t = \Delta u + f(t,u) .$$

$A$

$$u_t = Au + f(t,u)$$

$A$$I-\gamma A$SpecialMatrices.jl

julia> using SpecialMatrices
julia> Strang(5)
5×5 SpecialMatrices.Strang{Float64}:
 2.0  -1.0   0.0   0.0   0.0
-1.0   2.0  -1.0   0.0   0.0
 0.0  -1.0   2.0  -1.0   0.0
 0.0   0.0  -1.0   2.0  -1.0
 0.0   0.0   0.0  -1.0   2.0

$n$$\mathcal{O}(3n)$$\mathcal{O}(1)$ !)।

हालाँकि, मान लें कि हम मैट्रिक्स को उलटना चाहते हैं।

julia> inv(collect(Strang(5)))
5×5 Array{Float64,2}:
 0.833333  0.666667  0.5  0.333333  0.166667
 0.666667  1.33333   1.0  0.666667  0.333333
 0.5       1.0       1.5  1.0       0.5
 0.333333  0.666667  1.0  1.33333   0.666667
 0.166667  0.333333  0.5  0.666667  0.833333

$\mathcal{O}(n^2)$

इसके बजाय, सीधे \और पुनरावृत्त सॉल्वर की विधियां उन जैसे किIterativeSolvers.jl हल करेंगी$Ax=b$$A^{-1}$$A$ । यह आपके द्वारा हल किए जा सकने वाले PDE के आकार का बहुत विस्तार कर सकता है।

जैसा कि दूसरों ने उल्लेख किया है, हालत संख्या और संख्यात्मक त्रुटि एक और कारण है, लेकिन यह तथ्य कि विरल मैट्रिक्स का व्युत्क्रम घना है, यह बहुत स्पष्ट है "यह एक बुरा विचार है"।