Giải pháp rõ ràng nhanh cho , , số điều kiện thấp

Tôi đang tìm kiếm một giải pháp rõ ràng (dám nói là tối ưu?), Vấn đề thực tuyến tính 3x3, , . Một ∈ R 3 × 3 , b ∈ R $\mathbf{A}\mathbf{x} = \mathbf{b}$$\mathbf{A} \in \mathbf{R}^{3 \times 3}, \mathbf{b} \in \mathbf{R}^{3}$

Ma trận là chung, nhưng gần với ma trận danh tính có số điều kiện gần bằng 1. Vì thực sự là các phép đo cảm biến với độ chính xác khoảng 5 chữ số, tôi không ngại mất vài chữ số do số các vấn đề.$\mathbf{A}$$\mathbf{b}$

Tất nhiên, không khó để đưa ra một giải pháp rõ ràng dựa trên bất kỳ phương pháp nào, nhưng nếu có một phương pháp nào đó được chứng minh là tối ưu về mặt số lượng FLOPS, thì đó sẽ là lý tưởng (sau tất cả, toàn bộ vấn đề sẽ có khả năng phù hợp với các thanh ghi FP!).

(Vâng, thói quen này được gọi thường xuyên . Tôi đã thoát khỏi trái cây treo thấp và đây là danh sách tiếp theo trong danh sách hồ sơ của tôi ...)

Bạn không thể đánh bại một công thức rõ ràng. Bạn có thể viết ra các công thức cho giải pháp trên một tờ giấy. Hãy để trình biên dịch tối ưu hóa mọi thứ cho bạn. Bất kỳ phương thức nào khác gần như chắc chắn sẽ có các câu lệnh hoặc vòng lặp (ví dụ, đối với các phương thức lặp) sẽ làm cho mã của bạn chậm hơn bất kỳ mã đường thẳng nào.$x=A^{-1}b$iffor

Vì ma trận rất gần với danh tính, chuỗi Neumann sau đây sẽ hội tụ rất nhanh:

Tùy thuộc vào độ chính xác cần thiết, nó thậm chí có thể đủ tốt để cắt ngắn sau 2 điều khoản:

Điều này có thể nhanh hơn một chút so với công thức trực tiếp (như được đề xuất trong câu trả lời của Wolfgang Bangerth), mặc dù với độ chính xác thấp hơn nhiều.

Bạn có thể có được độ chính xác cao hơn với 3 thuật ngữ:

nhưng nếu bạn viết ra công thức nhập theo mục nhập cho , bạn đang xem một số lượng tương đương các phép toán dấu phẩy động như công thức nghịch đảo ma trận 3x3 trực tiếp (bạn không phải làm một bộ phận mặc dù, giúp một chút).$(3I - 3A + A^2)b$

Số lượng FLOPS dựa trên các gợi ý ở trên:

• LU, không xoay vòng:

  • Mul = 11, Div / Recip = 6, Thêm / Sub = 11, Tổng = 28; hoặc là
  • Mul = 16, Div / Recip = 3, Thêm / Sub = 11, Tổng = 30

• Loại bỏ Gaussian với sự thay thế trở lại, không xoay vòng:

  • Mul = 11, Div / Recip = 6, Thêm / Sub = 11, Tổng = 28; hoặc là
  • Mul = 16, Div / Recip = 3, Thêm / Sub = 11, Tổng = 30

• Quy tắc của Cramer thông qua việc mở rộng đồng yếu tố

  • Mul = 24, Div = 3, Thêm / Sub = 15, Tổng = 42; hoặc là
  • Mul = 27, Div = 1, Thêm / Sub = 15, Tổng = 43

• Rõ ràng nghịch đảo sau đó nhân lên:

  • Mul = 30, Div = 3, Thêm / Sub = 17, Tổng = 50; hoặc là
  • Mul = 33, Div = 1, Thêm / Sub = 17, Tổng = 51

Bằng chứng về khái niệm MATLAB:

Quy tắc của Cramer thông qua việc mở rộng Cofactor :

function k = CramersRule(A, m)
%
% FLOPS:
%
% Multiplications:        24
% Subtractions/Additions: 15
% Divisions:               3
%
% Total:                  42

a = A(1,1);
b = A(1,2);
c = A(1,3);

d = A(2,1);
e = A(2,2);
f = A(2,3);

g = A(3,1);
h = A(3,2);
i = A(3,3);

x = m(1);
y = m(2);
z = m(3);

ei = e*i;
fh = f*h;

di = d*i;
fg = f*g;

dh = d*h;
eg = e*g;

ei_m_fh = ei - fh;
di_m_fg = di - fg;
dh_m_eg = dh - eg;

yi = y*i;
fz = f*z;

yh = y*h;
ez = e*z;

yi_m_fz = yi - fz;
yh_m_ez = yh - ez;

dz = d*z;
yg = y*g;

dz_m_yg = dz - yg;
ez_m_yh = ez - yh;


det_a = a*ei_m_fh - b*di_m_fg + c*dh_m_eg;
det_1 = x*ei_m_fh - b*yi_m_fz + c*yh_m_ez;
det_2 = a*yi_m_fz - x*di_m_fg + c*dz_m_yg;
det_3 = a*ez_m_yh - b*dz_m_yg + x*dh_m_eg;


p = det_1 / det_a;
q = det_2 / det_a;
r = det_3 / det_a;

k = [p;q;r];

LU (không xoay vòng) và thay thế trở lại:

function [x, y, L, U] = LUSolve(A, b)
% Total FLOPS count:     (w/ Mods)
%
% Multiplications:  11    16
% Divisions/Recip:   6     3
% Add/Subtractions: 11    11
% Total =           28    30
%

A11 = A(1,1);
A12 = A(1,2);
A13 = A(1,3);

A21 = A(2,1);
A22 = A(2,2);
A23 = A(2,3);

A31 = A(3,1);
A32 = A(3,2);
A33 = A(3,3);

b1 = b(1);
b2 = b(2);
b3 = b(3);

L11 = 1;
L22 = 1;
L33 = 1;

U11 = A11;
U12 = A12;
U13 = A13;

L21 = A21 / U11;
L31 = A31 / U11;

U22 = (A22 - L21*U12);
L32 = (A32 - L31*U12) / U22;

U23 = (A23 - L21*U13);

U33 = (A33 - L31*U13 - L32*U23);

y1 = b1;
y2 = b2 - L21*y1;
y3 = b3 - L31*y1 - L32*y2;

x3 = (y3                  ) / U33;
x2 = (y2 -          U23*x3) / U22;
x1 = (y1 - U12*x2 - U13*x3) / U11;

L = [ ...
    L11,   0,   0;
    L21, L22,   0;
    L31, L32, L33];

U = [ ...
    U11, U12, U13;
      0, U22, U23;
      0,   0, U33];

x = [x1;x2;x3];
y = [y1;y2;y3];

Rõ ràng nghịch đảo sau đó nhân:

function x = ExplicitInverseMultiply(A, m)
%
% FLOPS count:                  Alternative
%
% Multiplications:        30            33
% Divisions:               3             1
% Additions/Subtractions: 17            17
% Total:                  50            51


a = A(1,1);
b = A(1,2);
c = A(1,3);

d = A(2,1);
e = A(2,2);
f = A(2,3);

g = A(3,1);
h = A(3,2);
i = A(3,3);

ae = a*e;
af = a*f;
ah = a*h;
ai = a*i;

bd = b*d;
bf = b*f;
bg = b*g;
bi = b*i;

cd = c*d;
ce = c*e;
cg = c*g;
ch = c*h;

dh = d*h;
di = d*i;

eg = e*g;
ei = e*i;

fg = f*g;
fh = f*h;

dh_m_eg = (dh - eg);
ei_m_fh = (ei - fh);
fg_m_di = (fg - di);

A = ei_m_fh;
B = fg_m_di;
C = dh_m_eg;
D = (ch - bi);
E = (ai - cg);
F = (bg - ah);
G = (bf - ce);
H = (cd - af);
I = (ae - bd);

det_A = a*ei_m_fh + b*fg_m_di + c*dh_m_eg;

x1 =  (A*m(1) + D*m(2) + G*m(3)) / det_A;
x2 =  (B*m(1) + E*m(2) + H*m(3)) / det_A;
x3 =  (C*m(1) + F*m(2) + I*m(3)) / det_A;

x = [x1;x2;x3];

Phép loại trừ Gaussian:

function x = GaussianEliminationSolve(A, m)
%
% FLOPS Count:      Min   Alternate
%
% Multiplications:  11    16
% Divisions:         6     3
% Add/Subtractions: 11    11
% Total:            28    30
%

a = A(1,1);
b = A(1,2);
c = A(1,3);

d = A(2,1);
e = A(2,2);
f = A(2,3);

g = A(3,1);
h = A(3,2);
i = A(3,3);

b1 = m(1);
b2 = m(2);
b3 = m(3);

% Get to echelon form

op1 = d/a;

e_dash  = e  - op1*b;
f_dash  = f  - op1*c;
b2_dash = b2 - op1*b1;

op2 = g/a;

h_dash  = h  - op2*b;
i_dash  = i  - op2*c;
b3_dash = b3 - op2*b1; 

op3 = h_dash / e_dash;

i_dash2  = i_dash  - op3*f_dash;
b3_dash2 = b3_dash - op3*b2_dash;

% Back substitution

x3 = (b3_dash2                  ) / i_dash2;
x2 = (b2_dash        - f_dash*x3) / e_dash;
x1 = (b1      - b*x2 -      c*x3) / a;

x = [x1 ; x2 ; x3];

Lưu ý: Xin vui lòng thêm phương pháp của riêng bạn và tính vào bài đăng này.

Có lẽ là quy tắc của Cramer. Nếu bạn có thể tránh xoay vòng, có thể nhân tố LU; đó là ma trận 3x3, vì vậy việc hủy các vòng lặp theo cách thủ công sẽ dễ dàng. Bất cứ điều gì khác có thể sẽ liên quan đến việc phân nhánh và tôi nghi ngờ rằng một phương thức không gian con Krylov sẽ hội tụ thường xuyên đủ trong 1 hoặc 2 lần lặp để nó có giá trị.