Eliminación hacia atrás revisitado

Los cálculos innecesarios se eliminarán para aumentar la velocidad $$ \begin{equation*} \begin{array}{llll} a_{11} = a'''_{11} & & & \\ a_{21} = a''_{21} & a_{22} = a''_{22} & & \\ a_{31} = a'_{31} & a_{32} = a'_{32} & a_{33} = a'_{33} & \\ a_{41} = a_{41} & a_{42} = a_{42} & a_{43} = a_{43} & a_{44} = a_{44} \end{array} \end{equation*} $$

Fórmula matemática

$$ \begin{align*} k &= m, \dots, 2 \\ & \quad i = k-1, \dots, 1 \\ & \quad \quad j = k-1, \dots, 1 \\ & \quad \quad \quad a_{ij} = a_{ij} - \frac{a_{ik}}{a_{kk}} a_{kj} \end{align*} $$

Seudocódigo

function eliminacion_atras(a)
    m, n = tamaño(a)
    for k=m to 2 do
        for i=k-1 to 1 do
            for j=k-1 to 1 do
                a(i,j) = a(i,j) - a(i,k)*a(k,j)/a(k,k)
            end for
        end for
    end for
end function

otra alternativa para reducir tiempo de cálculo

function eliminacion_atras(a)
    m, n = tamaño(a)
    for k=m to 2 do
        for i=k-1 to 1 do
            factor = a(i,k)/a(k,k)
            for j=k-1 to 1 do
                a(i,j) = a(i,j) - a(i,k)*a(k,j)/a(k,k)
            end for
        end for
    end for
end function

Implementación eliminación hacia atrás

import numpy as np

def eliminacion_atras(A):
    a = np.copy(A)
    m, n = a.shape
    for k in range(m-1,-1,-1):
        for i in range(k-1,-1,-1):
            factor = a[i,k]/a[k,k]
            for j in range(k-1,-1,-1):
                a[i,j] = a[i,j] - factor*a[k,j]
    return a

A = np.array([[3,-0.1,-0.2],
              [0.1,7,-0.3],
              [0.3,-0.2,10]])
print(A)

    [[  3.   -0.1  -0.2]
     [  0.1   7.   -0.3]
     [  0.3  -0.2  10. ]]

B = eliminacion_atras(A)
print(B)

    [[  3.00762082  -0.104       -0.2       ]
     [  0.109        6.994       -0.3       ]
     [  0.3         -0.2         10.        ]]

np.tril(B)

    array([[  3.00762082,   0.        ,   0.        ],
           [  0.109     ,   6.994     ,   0.        ],
           [  0.3       ,  -0.2       ,  10.        ]])

A = np.array([[1,1,2,3],
              [2,1,-1,1],
              [3,-1,-1,2],
              [-1,2,3,-1]],float)
print(A)

    [[ 1.  1.  2.  3.]
     [ 2.  1. -1.  1.]
     [ 3. -1. -1.  2.]
     [-1.  2.  3. -1.]]

B = eliminacion_atras(A)
print(B)

    [[ -4.33333333   0.4         11.           3.        ]
     [  0.6          1.8          2.           1.        ]
     [  1.           3.           5.           2.        ]
     [ -1.           2.           3.          -1.        ]]

np.tril(B)

    array([[-4.33333333,  0.        ,  0.        ,  0.        ],
           [ 0.6       ,  1.8       ,  0.        ,  0.        ],
           [ 1.        ,  3.        ,  5.        ,  0.        ],
           [-1.        ,  2.        ,  3.        , -1.        ]])