3.3.1 Gauss – Determinante

Determinante calculado de la forma triangular de la matriz, multiplicando todos los coeficientes de la diagonal.

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

calculando el determinante se llega al resultado de:

determinante de A: 
210.353

Primero se pivotea la fila, se obtiene la forma LU de la matriz, usando solo la triangular superior, se multiplican todos los coeficientes de la diagonal, con lo que se obtiene el determinante.

# determinante de A
# Referencia: Rodriguez 4.3.9 p.129
import numpy as np

def determinante(A):
    tamano = np.shape(A)
    n = tamano[0]
    m = tamano[1]
    C = np.copy(A)
    C, cuenta = pivoteafila(C, contar=1)
    C_LU = triang_LU(C)
    U = C_LU[1]
    detA = 1
    for i in range(0,n,1):
        detA = detA*U[i,i]
    detA = detA*((-1)**cuenta) 
    return(detA)

# se modifica el pivoteo para que cuente los cambios de fila.
def pivoteafila(A, contar = 0):
    # Si contar=1, cuenta los cambios de fila
    tamano = np.shape(A)
    n = tamano[0]
    m = tamano[1]
    C = np.copy(A)
    cambio =0
    # mayor en diagonal
    for i in range(0,n-1,1):
        imax = np.argmax(np.abs(C[i:,i]))
        # intercambia si imax no es la diagonal
        if ((imax+i)!= i):
            # copia a temporal para intercambiar fila
            temporal = np.copy(C[i,:])
            C[i,:] = C[imax+i,:]
            C[imax+i,:] = temporal
            cambio = cambio+1
    if (contar==1):
        C=[C,cambio]
    return(C)

# Triangulares de una matriz
def triang_LU(A, casicero = 1e-15):
    # Triangulares de una matriz A=L.U
    # Triangular inferior L = LU[0]
    # Triangular superior U = LU[1]
    tamano = np.shape(A)
    n = tamano[0]
    m = tamano[1]

    U = np.copy(A)
    L = np.identity(n,dtype=float)

    # Gauss elimina hacia adelante
    # tarea: verificar términos cero
    for i in range(0,n,1):
        pivote = U[i,i]
        adelante = i+1 
        for k in range(adelante,n,1):
            if (np.abs(pivote)>=casicero):
                factor = U[k,i]/pivote
                U[k,:] = U[k,:] - factor*U[i,:]
                L[k,i] = factor

    LU = np.array([L,U])
    return(LU)

# Programa de prueba #######
# INGRESO
A = np.array([[3,-0.1,-0.2],
              [0.1,7,-0.3],
              [0.3,-0.2,10]])


# PROCEDIMIENTO
detA = determinante(A)

# SALIDA
print('determinante de A: ')
print(detA)

verifique usando la función de numpy:

>>> np.linalg.det(A)
210.35299999999989