Hướng dẫn gauss jordan python without numpy - trăn gauss jordan không có numpy

Vì vậy, tôi đang cố gắng tìm ra nghịch đảo của một ma trận (sử dụng danh sách Python) bằng cách loại bỏ Gauss-Jordan. Nhưng tôi đang phải đối mặt với vấn đề đặc biệt này. Trong mã bên dưới, tôi áp dụng mã của mình vào ma trận đã cho và nó giảm vào ma trận danh tính như dự định.

M = [[0, 2, 1], [4, 0, 1], [-1, 2, 0]]
P = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
n = len(P)
def inverse(a):
    for k in range(n):
        if abs(a[k][k]) < 1.0e-12:
            for i in range(k+1, n):
                if abs(a[i][k]) > abs(a[k][k]):
                    for j in range(k, n):
                        a[k][j], a[i][j] = a[i][j], a[k][j]
                    break
        pivot = a[k][k]
        for j in range(k, n):
            a[k][j] /= pivot
        for i in range(n):
            if i == k or a[i][k] == 0: continue
            factor = a[i][k]
            for j in range(k, n):
                a[i][j] -= factor * a[k][j]
    return a

inverse(M)

Đầu ra là

[[1.0, 0.0, 0.0], [0, 1.0, 0.0], [0.0, 0.0, 1.0]]

Nhưng khi tôi áp dụng cùng một mã, sau khi thêm các dòng mã cho ma trận danh tính của mình (là một phần của ma trận tăng cường với ma trận đã cho), nó không cho tôi nghịch đảo chính xác khi nó nên áp dụng cùng một thao tác trên Nó như tôi đang áp dụng trên ma trận đã cho).

M = [[0, 2, 1], [4, 0, 1], [-1, 2, 0]]
P = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
n = len(P)
def inverse(a, b):
    for k in range(n):
        if abs(a[k][k]) < 1.0e-12:
            for i in range(k+1, n):
                if abs(a[i][k]) > abs(a[k][k]):
                    for j in range(k, n):
                        a[k][j], a[i][j] = a[i][j], a[k][j]
                        b[k][j], b[i][j] = b[i][j], b[k][j]
                    b[k], b[i] = b[i], b[k]
                    break
        pivot = a[k][k]
        for j in range(k, n):
            a[k][j] /= pivot
            b[k][j] /= pivot
        for i in range(n):
            if i == k or a[i][k] == 0: continue
            factor = a[i][k]
            for j in range(k, n):
                a[i][j] -= factor * a[k][j]
                b[i][j] -= factor * b[k][j]
    return a, b

inverse(M, P)

Đầu ra không phải là ma trận nghịch đảo, nhưng một cái gì đó khác (mặc dù cột cuối cùng có các mục chính xác).

([[1.0, 0.0, 0.0], [0, 1.0, 0.0], [0.0, 0.0, 1.0]],
 [[0.0, 0.25, 0.3333333333333333],
  [1, 0.0, 0.6666666666666666],
  [0.0, 0.25, -1.3333333333333333]])

Tôi đã thử sử dụng các câu lệnh in trong khi gỡ lỗi và tôi nghĩ rằng dòng nơi tôi chia các hàng cho trục, có một số vấn đề. Nó hoạt động tốt trong ma trận ban đầu nhưng không hoạt động với ma trận nhận dạng. Ngoài ra, lưu ý rằng chỉ có cột cuối cùng của ma trận nhận dạng được chuyển đổi thành các mục chính xác của ma trận nghịch đảo.

Ma trận nghịch đảo chính xác để tham khảo là

I = [[-1/3, 1/3, 1/3], [-1/6, 1/6, 2/3], [4/3, -1/3, -4/3]]

Bất kì sự trợ giúp nào đều được đánh giá cao. Cảm ơn trước!

Tìm hệ thống miễn phí của dự án phương trình trên GitHubGitHub

Kiểm tra & nbsp; IntegratedMachine Learning & AI sắp ra mắt YouTube.Integrated Machine Learning & AI coming soon to YouTube.

Giới thiệu

Bài đăng này bao gồm việc giải một hệ phương trình từ toán học để hoàn thành mã, & nbsp; và nó liên quan rất chặt chẽ với bài viết đảo ngược ma trận. & NBSP; , nhưng hầu hết thời gian chúng ta chỉ cần một dung dịch x cho một hệ phương trình, & nbsp; và có một phương pháp cho phép chúng ta giải trực tiếp cho X nơi chúng ta không cần biết nghịch đảo của ma trận hệ thống.matrix inversion post. There are times that we’d want an inverse matrix of a system for repeated uses of solving for X, but most of the time we simply need a single solution of X for a system of equations, and there is a method that allows us to solve directly for X where we don’t need to know the inverse of the system matrix.

Chúng tôi sẽ sử dụng Python một lần nữa và mặc dù mã tương tự nhau, nhưng nó hơi khác một chút. & NBSP; vì vậy, có một kho lưu trữ GitHub riêng cho dự án này. Ngoài ra, chúng tôi biết rằng các mô -đun Numpy hoặc Scipy hoặc Sklearn có thể được sử dụng, nhưng chúng tôi muốn xem cách giải cho X trong một hệ phương trình mà không cần sử dụng bất kỳ phương trình nào, vì bài đăng này, giống như hầu hết các bài đăng trên trang web này, là về sự hiểu biết các nguyên tắc từ toán học để hoàn thành mã. Tuy nhiên, gần cuối bài, có một phần cho thấy cách giải cho X trong một hệ phương trình sử dụng Numpy / SCIPY. Hãy nhớ rằng, hãy cố gắng tự mình phát triển mã với sự trợ giúp của bài viết càng ít càng tốt và sử dụng bài đăng để so sánh với toán học và cách tiếp cận của bạn. Tuy nhiên, chỉ cần làm việc thông qua bài viết và đảm bảo bạn hiểu kỹ các bước cũng là một điều tuyệt vời để làm.GitHub repository for this project. Also, we know that numpy or scipy or sklearn modules could be used, but we want to see how to solve for X in a system of equations without using any of them, because this post, like most posts on this site, is about understanding the principles from math to complete code. However, near the end of the post, there is a section that shows how to solve for X in a system of equations using numpy / scipy. Remember too, try to develop the code on your own with as little help from the post as possible, and use the post to compare to your math and approach. However, just working through the post and making sure you understand the steps thoroughly is also a great thing to do.

Nền đại số tuyến tính

Đầu tiên, hãy để xem xét đại số tuyến tính minh họa một hệ phương trình. & Nbsp; xem xét AX = B, nơi chúng ta cần giải quyết cho X. & NBSP;AX=B, where we need to solve for X . 

Xem xét một hệ phương trình điển hình, chẳng hạn như:

Ax = b, \ hspace {5em} \ start & a_ {13} \ end {bmatrix} \ start } \\ b_ {31} \ end {bmatrix}

Chúng tôi muốn giải quyết cho X, vì vậy chúng tôi thực hiện các hoạt động hàng trên một điều khiển nó đến một ma trận nhận dạng. Khi chúng tôi thực hiện các bước tương tự trên B, B sẽ trở thành giá trị của X.X, so we perform row operations on A that drive it to an identity matrix. As we perform those same steps on B, B will become the values of X.

Ix = b_m, \ hspace {5em} \ Begin {bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \ end {bmatrix} \ start Bmatrix} = \ start

B đã được đổi tên thành B_M, và các yếu tố của B đã được đổi tên thành B_M, và M và M là viết tắt của Morphed, bởi vì với mỗi bước, chúng ta đang thay đổi (biến hình) các giá trị của B. has been renamed to B_M, and the elements of B have been renamed to b_m, and the M and m stand for morphed, because with each step, we are changing (morphing) the values of B.

Thực hiện các hoạt động hàng trên A để điều khiển nó đến một ma trận nhận dạng và thực hiện các hoạt động hàng tương tự trên B, & NBSP; sẽ điều khiển các yếu tố B để trở thành các yếu tố của X.A to drive it to an identity matrix, and performing those same row operations on B, will drive the elements of B to become the elements of X.

Ma trận dưới đây chỉ đơn giản được sử dụng để minh họa các bước để thực hiện thủ tục này cho bất kỳ kích thước nào của hệ thống phương trình, khi A có kích thước n \, x \, n. Xin lưu ý rằng các bước này tập trung vào phần tử được sử dụng để chia tỷ lệ trong các hoạt động hàng hiện tại. Mỗi bước liên quan đến hai hàng: một trong những hàng này đang được sử dụng để hành động trên hàng khác của hai hàng này.A has dimensions n\,x\,n. Please note that these steps focus on the element used for scaling within the current row operations. Every step involves two rows: one of these rows is being used to act on the other row of these two rows.

S = \ Begin {Bmatrix} S_ {11} & \ Dots & \ Dots & S_ {K2} & \ Dots & \ Dots & S_ {N2} \ \\\ vdots & & & \ vdots & & & \ vdots \\ s_ {1K} & \ Dots & \ Dots & S_ {K1} & \ Dots & \ Dots & S_ {nk} \ S_ {1 N-1} & \ Dots & \ Dots & S_ {K N-1} & \ Dots & \ Dots & S_ {N N-1} \\ S_ {1n} & \ Dots & \ Dots & S_ & S_ {n1} \\\ end {bmatrix}

Nhìn vào ở trên, hãy nghĩ về phương thức giải pháp như một tập hợp các bước, s, cho mỗi cột và mỗi cột có một phần tử chéo trong đó. Chúng tôi làm việc với các cột từ trái sang phải và làm việc để thay đổi từng phần tử của mỗi cột thành 1 nếu nó trên đường chéo và 0 nếu nó không nằm trên đường chéo. Chúng tôi sẽ gọi phần tử đường chéo hiện tại là phần tử chéo tiêu điểm hoặc viết tắt là FD.S, for each column, and each column has one diagonal element in it. We work with columns from left to right, and work to change each element of each column to a 1 if it’s on the diagonal, and to 0 if it’s not on the diagonal. We’ll call the current diagonal element the focus diagonal element or fd for short.

Bước đầu tiên cho mỗi cột là mở rộng quy mô hàng có FD trong đó 1/FD. Sau đó chúng tôi hoạt động trên các hàng còn lại, các hàng không có FD trong đó, như sau:fd in it by 1/fd. We then operate on the remaining rows, the ones without fd in them, as follows:

1. Sử dụng phần tử mà trong cùng một cột với FD và biến nó thành một máy đo;fd and make it a scaler;
2. Thay thế hàng bằng kết quả của [hàng hiện tại] - scale * [hàng có fd];fd];
3. Điều này sẽ để lại số 0 trong cột được chia sẻ bởi FD.fd.

Chúng tôi làm điều này cho các cột từ trái sang phải trong cả hai ma trận A và B. Khi hoàn thành, A là ma trận nhận dạng và B đã trở thành giải pháp cho X.A and B matrices. When this is complete, A is an identity matrix, and B has become the solution for X.

Các bước này về cơ bản giống hệt với các bước được trình bày trong bài đảo ngược ma trận. Đây là một tổng quan về khái niệm. & NBSP; Tổng quan chi tiết với các số sẽ được thực hiện sớm. & NBSP; Phương thức giải pháp là một tập hợp các bước, s, tập trung vào một cột tại một thời điểm. Mỗi cột có một phần tử chéo trong đó, & nbsp; và chúng được hiển thị dưới dạng các phần tử chéo S_ {KJ}. yếu tố. & nbsp; Chúng tôi chia tỷ lệ hàng với FD trong đó lên 1/FD. Sau đó, với mỗi hàng không có FD trong đó, chúng tôi:matrix inversion post. This is a conceptual overview. A detailed overview with numbers will be performed soon. The solution method is a set of steps, S, focusing on one column at a time. Each column has a diagonal element in it, of course, and these are shown as the S_{kj} diagonal elements. Start from the left column and moving right, we name the current diagonal element the focus diagonal (fd) element.  We scale the row with fd in it to 1/fd. Then, for each row without fd in them, we:

1. làm cho phần tử trong dòng cột với fd & nbsp; một máy đo;fd a scaler;
2. Cập nhật hàng đó với [[hàng hiện tại] - scale * [hàng với fd];fd];
3. Một số 0 bây giờ sẽ nằm trong vị trí cột FD cho hàng đó.fd column-location for that row.

Chúng tôi thực hiện các bước đó cho mỗi hàng không có đường chéo lấy nét trong đó để điều khiển tất cả các phần tử trong cột hiện tại đến 0 không nằm trong hàng với đường chéo lấy nét trong đó. Khi một phần tử chéo trở thành 1 và tất cả các phần tử khác trong cột với nó là 0, phần tử chéo đó là một vị trí trục, và cột đó là một cột trục. & NBSP; các hoạt động này tiếp tục từ trái sang phải trên ma trận A và B . & nbsp; vào cuối thủ tục, A bằng một ma trận nhận dạng và B đã trở thành giải pháp cho B.0 that are NOT in the row with the focus diagonal in it. Once a diagonal element becomes 1 and all other elements in-column with it are 0’s, that diagonal element is a pivot-position, and that column is a pivot-column. These operations continue from left to right on matrices A and B. At the end of the procedure, A equals an identity matrix, and B has become the solution for B.

Bây giờ, hãy để thực hiện các bước đó trên ma trận 3 x 3 bằng số. Ma trận bắt đầu của chúng tôi, A và B, được sao chép, mã khôn ngoan, thành A_M và B_M để bảo tồn A và B để sử dụng sau.A and B, are copied, code wise, to A_M and B_M to preserve A and B for later use.

A = \ BẮT ĐẦU

Ma trận khởi đầu của chúng tôi là:

A_M = \ BẮT ĐẦU {BMATRIX} 5 & 3 & 1 \\ 3 & 9 & 4 \\ 1 & 3 & 5 \ end {bmatrix}, \ hspace {4em} b_m = \ start

Sử dụng các bước được minh họa trong ma trận S ở trên, hãy để bắt đầu di chuyển qua các bước để giải cho X.S matrix above, let’s start moving through the steps to solve for X.

1. 1/5.0 * (Hàng 1 của A_M) & NBSP; & nbsp; và & nbsp; & nbsp; 1/5.0 * (hàng 1 của b_m)A_M)   and   1/5.0 * (row 1 of B_M)

A_M = \ BẮT ĐẦU {BMATRIX} 1 & 0.6 & 0.2 \\ 3 & 9 & 4 \\ 1 & 3 & 5 \ end {bmatrix}, \ hspace {4em} b_m = \ start

2. (Hàng 2 của A_M) & NBSP; - & nbsp; 3.0 * (Hàng 1 của A_M) & NBSP; & nbsp; (Hàng 2 của B_M) & NBSP; - & nbsp; 3.0 * (Hàng 1 của B_M)A_M)  –  3.0 * (row 1 of A_M)
    (row 2 of B_M)  –  3.0 * (row 1 of B_M)

A_M = \ BẮT ĐẦU {BMATRIX} 1 & 0.6 & 0.2 \\ 0 & 7.2 & 3,4 \ 1 & 3 & 5 & 5 \ end {bmatrix}, \ hspace {4em} b_m = \ Begin Bmatrix}

3. (Hàng 3 của A_M) & NBSP; - & nbsp; 1.0 * (Hàng 1 của A_M) & NBSP; & nbsp; (Hàng 3 của B_M) & NBSP; - & nbsp; 1.0 * (Hàng 1 của B_M)A_M)  –  1.0 * (row 1 of A_M)
    (row 3 of B_M)  –  1.0 * (row 1 of B_M)

A_M = \ BẮT ĐẦU {BMATRIX} 1 & 0.6 & 0.2 \\ 0 & 7.2 & 3,4 \\ 0 & 2.4 & 4.8 \ end {bmatrix}, \ hspace {4em} b_m = \ bearn {bmatrix} 1.8 \ 10.6 7.2 \ end {bmatrix}

4. 1/7.2 * (Hàng 2 của A_M) & NBSP; & nbsp; và & nbsp; & nbsp; 1/7.2 * (hàng 2 của b_m)A_M)   and   1/7.2 * (row 2 of B_M)

A_M = \ BẮT ĐẦU {BMATRIX} 1 & 0.6 & 0.2 \\ 0 & 1 & 0.472 \\ 0 & 2.4 & 4,8 \ end {bmatrix}, \ hspace {4em} b_m = \ start kết thúc {bmatrix}

5. (Hàng 1 của A_M) & NBSP; - & nbsp; 0,6 * (Hàng 2 của A_M) & NBSP; & nbsp; (Hàng 1 của BM) & NBSP; - & nbsp; 0,6 * (Hàng 2 của B_M)A_M)  –  0.6 * (row 2 of A_M)
    (row 1 of BM)  –  0.6 * (row 2 of B_M)

A_M = \ BẮT ĐẦU {BMATRIX} 1 & 0 & -0.083 \\ 0 & 1 & 0.472 \\ 0 & 2.4 & 4.8 \ end {bmatrix}, \ hspace {4em} b_m = \ start Bmatrix}

6. (Hàng 3 của A_M) & NBSP; - & nbsp; 2.4 * (Hàng 2 của A_M) & NBSP; & nbsp; (Hàng 3 của B_M) & NBSP; - & nbsp; 2.4 * (Hàng 2 của B_M)A_M)  –  2.4 * (row 2 of A_M)
    (row 3 of B_M)  –  2.4 * (row 2 of B_M)

A_M = \ BẮT ĐẦU {BMATRIX} 1 & 0 & -0.083 \\ 0 & 1 & 0.472 \\ 0 & 0 & 3.667 \ end {bmatrix}, \ hspace {4em} b_m = \ start

7. 1/3.667 * (Hàng 3 của A_M) & NBSP; & nbsp; và & nbsp; & nbsp; 1/3.667 * (hàng 3 của b_m)A_M)   and   1/3.667 * (row 3 of B_M)

A_m = \ Begin {Bmatrix} 1 & 0 & -0.083 \\ 0 & 1 & 0.472 \\ 0 & 0 & 1 \ end {bmatrix}, \ hspace {4em} b_m = \

8. (Hàng 1 của A_M) & NBSP; - & nbsp; -0.083 * (Hàng 3 của A_M) & NBSP; & nbsp; (Hàng 1 của B_M) & NBSP; - & nbsp; -0.083 * (Hàng 3 của B_M)A_M)  –  -0.083 * (row 3 of A_M)
    (row 1 of B_M)  –  -0.083 * (row 3 of B_M)

A_M = \ BEGIN {BMATRIX} 1 & 0 & 0 \\ 0 & 1 & 0.472 \\ 0 & 0 & 1 \ end {bmatrix}, \ hspace {4em} b_m = \ start

9. (Hàng 2 của A_M) & NBSP; - & nbsp; 0,472 * (hàng 3 của a_m) & nbsp; & nbsp; (Hàng 2 của B_M) & NBSP; - & nbsp; 0,472 * (hàng 3 của B_M)A_M)  –  0.472 * (row 3 of A_M)
    (row 2 of B_M)  –  0.472 * (row 3 of B_M)

A_m = \ start

Trông chính xác. Hãy để kiểm tra.

A \ cdot b_m = a \ cdot x = b = \ started {bmatrix} 9 \\ 16 \\ 9 \ end {bmatrix}, \ hspace {4em} Có!

A \ cdot b_m nên là B và nó là! Do đó, B_M đã biến thành X. Xin đánh giá cao rằng tôi hoàn toàn chiếm được các con số, để chúng tôi đưa ra một X của tất cả 1 1. should be B and it is! Therefore, B_M morphed into X. Please appreciate that I completely contrived the numbers, so that we’d come up with an X of all 1’s.

Mã trong Python sử dụng các phương thức này được hiển thị trong một máy tính xách tay Jupyter có tên SystemoFequationsStepbyStep.Ipynb & nbsp; trong repo. Có những máy tính xách tay Jupyter khác trong kho lưu trữ GitHub mà tôi tin rằng bạn sẽ muốn xem và thử. & NBSP; Người ta tạo văn bản cho các bố cục toán học được hiển thị ở trên Nếu bạn không sử dụng Jupyter.SystemOfEquationsStepByStep.ipynb in the repo. There are other Jupyter notebooks in the GitHub repository that I believe you will want to look at and try out. One creates the text for the mathematical layouts shown above using LibreOffice math coding. There are complementary .py files of each notebook if you don’t use Jupyter.

Lập trình (tài liệu xuất bản thêm của các bước đã bị xóa) nằm trong khối bên dưới. & NBSP;

AM = copy_matrix(A)
n = len(A)
BM = copy_matrix(B)

indices = list(range(n)) # allow flexible row referencing ***
for fd in range(n): # fd stands for focus diagonal
    fdScaler = 1.0 / AM[fd][fd]
    # FIRST: scale fd row with fd inverse. 
    for j in range(n): # Use j to indicate column looping.
        AM[fd][j] *= fdScaler
    BM[fd][0] *= fdScaler
    
    # SECOND: operate on all rows except fd row.
    for i in indices[0:fd] + indices[fd+1:]: # skip fd row.
        crScaler = AM[i][fd] # cr stands for current row
        for j in range(n): # cr - crScaler * fdRow.
            AM[i][j] = AM[i][j] - crScaler * AM[fd][j]
        BM[i][0] = BM[i][0] - crScaler * BM[fd][0]

Ở phần trên cùng của mã, các bản sao của & nbsp; a và b được lưu để sử dụng sau và chúng tôi lưu kích thước vuông của một lần sử dụng sau này. Sau đó, chúng tôi lưu một danh sách các chỉ số & nbsp; fd vì lý do được giải thích sau. Tiếp theo, chúng tôi nhập vòng lặp cho FD. Ở đầu vòng lặp này, chúng tôi tỷ lệ & nbsp; hàng fd sử dụng 1/fd. Lần đầu tiên được lồng cho Loop hoạt động trên tất cả các hàng của một bên cạnh cái nắm giữ & nbsp; fd. Cái lồng tiếp theo cho vòng lặp tính toán (hàng hiện tại) - (hàng có fd) * (phần tử trong hàng hiện tại và cột của FD) cho ma trận & nbsp; a & nbsp; và & nbsp; b & nbsp ;.A and B are saved for later use, and we save A‘s square dimension for later use. Then we save a list of the fd indices for reasons explained later. Next we enter the for loop for the fd‘s. At the top of this loop, we scale fd rows using 1/fd. The first nested for loop works on all the rows of A besides the one holding fd. The next nested for loop calculates (current row) – (row with fd) * (element in current row and column of fd) for matrices A and B .

Vui lòng sao chép mã & nbsp; trong kho lưu trữ và thử nghiệm với nó và viết lại theo phong cách của riêng bạn. Một tệp có tên Linearalgebrapurepython.py & nbsp; chứa mọi thứ cần thiết để làm tất cả những điều này trong Python.code in the repository and experiment with it and rewrite it in your own style. A file named LinearAlgebraPurePython.py contains everything needed to do all of this in pure python. LinearAlgebraPurePython.py is imported by LinearAlgebraPractice.py. 

Công việc này có thể được thực hiện trong ít nhất 10 - 12 dòng Python. & NBSP; Một phiên bản như vậy được hiển thị trong quá trình rút ngắn.py. Các dòng mã ít nhất hiếm khi là mã tốt. & NBSP; Tuy nhiên, đó là một bằng chứng cho Python rằng việc giải một hệ phương trình có thể được thực hiện với rất ít mã.ShortImplementation.py. I wouldn’t use it. The fewest lines of code are rarely good code. However, it’s a testimony to python that solving a system of equations could be done with so little code.

Giải quyết một hệ phương trình với Numpy / Scipy

Với một dòng mã Python đơn giản, các dòng sau để nhập Numpy và xác định ma trận của chúng tôi, chúng tôi có thể nhận được giải pháp cho X. Tài liệu cho Numpy.Linalg.Solve (đó là giải quyết đại số tuyến tính của Numpy) ở đây. Mã bên dưới được lưu trữ trong repo dưới dạng System_of_eqns_with_numpy-scipy.py.X. The documentation for numpy.linalg.solve (that’s the linear algebra solver of numpy) is HERE. the code below is stored in the repo as System_of_Eqns_WITH_Numpy-Scipy.py.

import numpy as np

a = np.array([[5, 3, 1],[3, 9, 4],[1, 3, 5]])
b = np.array([[9],[16],[9]])

x = np.linalg.solve(a, b)

print(x)

Tôi hy vọng bạn sẽ chạy mã để thực hành và kiểm tra xem bạn có đầu ra giống như tôi không, đó là các yếu tố của X là tất cả 1.X being all 1’s.

Đóng cửa

Tôi hy vọng rằng bạn đã tìm thấy bài đăng này sâu sắc và hữu ích. Nếu bạn tự mình làm tất cả các công việc sau khi đọc mô tả cấp cao của các bước toán học, xin chúc mừng! Nếu không, don cảm thấy tồi tệ. Nếu bạn đã học và hiểu, bạn đang trên đường để có thể làm những việc như vậy từ đầu một khi bạn đã học toán học cho các thuật toán trong tương lai.

Trong tương lai, đôi khi chúng tôi sẽ sử dụng tài liệu này như một điểm khởi chạy cho các bài viết học máy khác. & NBSP;

Làm thế nào để bạn giải quyết phương pháp Gauss Jordan trong Python?

Cách dễ nhất để làm Gauss là gì

Làm thế nào để bạn viết sự loại bỏ Gaussian trong Python?

Là Gauss