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



In [1]:

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




In [2]:

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. ]]




In [3]:

B = eliminacion_atras(A)
print(B)




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




In [4]:

np.tril(B)




Out[4]:

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




In [5]:

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.]]




In [6]:

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.        ]]




In [7]:

np.tril(B)




Out[7]:

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