[C] Calcular determinante de una matriz de orden 'n'

[Kasswed]

Hola.

A ver si alguien me puede explicar algún algoritmo o darme algún pseudocódigo (por favor nada de álgebra), para calcular en C el determinante de una matriz de orden 'n'.

Muchas gracias.

[Anibal784]

Cómo que nada de álgebra si el determinante de una matriz es de álgebra. Esto es tan sencillo, es sólo cuestión de encontrar la definición, ver un método de cómo calcularla y transformar ese método en el algoritmo en el lenguaje que te gusta.

[Kasswed]

Si es muy sencillo.

Bueno comentarios tan útiles como el tuyo se agradecen, se encuentran pocos hoy en día. La verdad es que no había caído en basarme en fórmulas algebraicas para hacer el algoritmo, menos mal que lo has dicho.

Gracias por la ayuda.

[VirucKingX]

Si es muy sencillo.

Bueno comentarios tan útiles como el tuyo se agradecen, se encuentran pocos hoy en día. La verdad es que no había caído en basarme en fórmulas algebraicas para hacer el algoritmo, menos mal que lo has dicho.

Gracias por la ayuda.

yo te entiendo, hace algun tiempo tambien intente hacer esto, pero nunca encontre una formula recursiva que funcionara com matrices de orden mayor que 5

Dale una mirada a esto, segun el autor dice que funciona. Pero yo no lo e probado

 

http://www.elrincondelc.com/nuevorincon/foros/viewtopic.php?t=2837

esop


Chau

[juancaa]

Aunque llego un poco tarde creo que tengo lo que buscais:

http://foro.elhacker.net/programacion_cc/determinante_matriz_de_orden_n-t352910.0.html

[Xandrete]

Perdón, sólo quería comentar para decir que me has partido el corazón (en un sentido negativo)...

por favor nada de álgebra

Me voy a llorar, lo siento 

P.S. Que sepas que un hipopótamo ha muerto por tu culpa, xD

[BlackZeroX]

Me espere unos dias antes de soltar el codigo...

Código (c) [Seleccionar] Expandir



#include <stdlib.h>
#include <stdio.h>   //<stdio.h>

typedef
struct Matrix
{
    float **lpData;
    unsigned int uiRows;
    unsigned int uiCols;
}
MATRIX, *LPMATRIX;

LPMATRIX createMatrix(unsigned int uiRows, unsigned int uiCols)
{
    LPMATRIX lpRet = (LPMATRIX)malloc(sizeof(MATRIX));
    int i = 0;
    lpRet->uiCols = uiCols;
    lpRet->uiRows = uiRows;
    lpRet->lpData = (float**)malloc(sizeof(float*) * lpRet->uiRows);
    for (i = 0; i < lpRet->uiRows; i++)
        lpRet->lpData[i] = (float*)malloc(sizeof(float) * lpRet->uiCols);
    return lpRet;
}

void freeMatrix(LPMATRIX lpMatrix)
{
    int i = 0;
    if (!lpMatrix) return;
    for (i = 0; i < lpMatrix->uiRows; i++)
        free(lpMatrix->lpData[i]);
    free(lpMatrix->lpData);
    free(lpMatrix);
}

void showMatrix(LPMATRIX lpMatrix)
{
    int i = 0,
        j = 0;
    if (!(lpMatrix || lpMatrix->lpData)) return;
    for (i = 0; i < lpMatrix->uiRows; i++)
    {
        if (lpMatrix->lpData[i])
        {
            for (j = 0; j < lpMatrix->uiCols; j++)
                printf("\t%f", lpMatrix->lpData[i][j]);
            printf("\n");
        }
    }
}

int getDeterminant(LPMATRIX lpMatrix, float* lpOutDeterminant)
//  Retorna 0 si todo a ido bien, de lo contrario retorna un numero distinto de 0
{
    float fRet = 0.0f,
          fProduct = 0.0f;
    unsigned int i = 0,
                 j = 0;
    if (!(lpMatrix || lpMatrix->lpData) || (lpMatrix->uiRows < 2) || (lpMatrix->uiCols < 2) || (lpMatrix->uiRows != lpMatrix->uiCols)) return -1;

    if (lpMatrix->uiCols == 2)
    {
        if (!(lpMatrix->lpData[0] && lpMatrix->lpData[1])) return -1;
        fRet = lpMatrix->lpData[0][0] * lpMatrix->lpData[1][1] - lpMatrix->lpData[1][0] * lpMatrix->lpData[0][1];

    } else {
        for (i = 0; i < lpMatrix->uiRows; i++)
        {
            if (!lpMatrix->lpData[i]) return -1;
            //  Multiplicacion de valores verticales de izquierda a derecha...
            fProduct = 1.0f;
            for (j = 0; j < lpMatrix->uiCols; j++)
                fProduct *= lpMatrix->lpData[(i + j) % lpMatrix->uiCols][j];
            fRet += fProduct;

            //  Multiplicacion de valores verticales de derecha a izquierda...
            fProduct = 1.0f;
            for (j = 0; j < lpMatrix->uiCols; j++)
                fProduct *= lpMatrix->lpData[(lpMatrix->uiCols - 1) - ((i + j) % lpMatrix->uiCols)][j];
            fRet -= fProduct;
        }
    }
    if (lpOutDeterminant)
        *lpOutDeterminant = fRet;

    return 0;
}

int main()
{
    LPMATRIX lpMatrix = createMatrix(3,3);
    float fDeterminant = 0.0;
    int i = 0,
        j = 0;
    for (i = 0; i < lpMatrix->uiRows; i++)
    {
        for (j = 0; j < lpMatrix->uiCols; j++)
        {
            printf("[%d][%d] = ",i, j); fflush(stdout);
            scanf("%f", &lpMatrix->lpData[i][j]);
        }
    }
    fflush(stdout);
    showMatrix(lpMatrix);
    if (getDeterminant(lpMatrix, &fDeterminant) == 0)
        printf("Determinante = %f\n", fDeterminant);
    freeMatrix(lpMatrix);

    getchar();

    return EXIT_SUCCESS;
}



Temibles Lunas!¡.

[do-while]

¡Buenas!

Un metodo sencillo (aunque intuyo que no el mas eficiente) seria diagonailzar la matriz por Gauss y multiplicar los elementos de la diagonal.

Tambien puedes hacer ceros por ejemplo en la primera columna y aplicar la definicion. Te hara falta un algoritmo recursivo que repita el proceso para matrices de menor orden que la dada (hasta llegar a matrices 1x1):

|A| = Suma(desde i = 1 hasta n)(-1)^i+j·a_ij·|A_ij|

Donde i es el indice de la fila, j el de una columna prefijada y A_ij es la matriz resultante de eliminar de A la fila i y columna j.

La definicion basica de determinanta se realiza ulilizando sumas de productos de permutaciones de los elementos de las filas multiplicando en cada suma por la signatura de la permutacion, pero esto ya es mas complicado de implementar, y el hecho de tener que estar calculando permutaciones hara que el algoritmo sea muy poco eficiente.

Te recomiendo cualquiera de los dos primeros algoritmos. El primero es iterativo y el segundo recursivo.

¡Saludos!

[Crowsnest]

Hola Amigos:

Aunque no este en C++, es facil de traducir.

Aqui os dejo un codigo mio en VB.NET para resolver determinantes de orden n x n

Declaracion de la clase desde programa en VB.NET
Dim clase As SolDet = New SolDet()


LLAMADAS A LA CLASE SolDet (renombrada "clase" en el ejemplo):
       clase.resuelve(test,n, n), ejecuta calculo Matricial
       clase.Calcula(n, n), Devuelve valor determinante

Donde Det es la matriz a calcular yn,n son las dimensiones de la Matriz.
La matriz esta ordenada por filas, ejpl. {{1,2,3,4},{2,1,4,7},.........}


       clase.ver_datos(), devuelve matriz diagonalizada.



Public Class SolDet

   'by  jmlv-Crowsnest
   Public paso(1, 1) As Double


   Public Sub resuelve(ByVal det, ByVal ylim, ByVal xlim)

       If xlim <> ylim Then
           MsgBox("Only squared matrixes allowed")
           Exit Sub
       End If


       ReDim paso(ylim - 1, xlim - 1) ' row-col Number
       Dim x, y As Integer
       Dim f, referencia, operador As Double
       Dim acarreo As Integer

       'det() Reference Matrix
       'paso() Result Matrix

       Array.Copy(det, paso, det.length) 'Build initial result matrix

       For acarreo = 0 To xlim - 2 ' Move row selection pointer for zero making

           referencia = -det(acarreo, acarreo) 'Diagonal reference value

           For y = acarreo + 1 To ylim - 1 'Move along row of column y

               operador = det(y, acarreo) 'Matrix element at the same column than reference

               f = operador / referencia 'Multiplication factor for row Y

               For x = 0 To xlim - 1 'Move and apply f along row

                   paso(y, x) = det(acarreo, x) * f + det(y, x)

               Next

           Next

           'Rebuild reference Matrix.
           Array.Copy(paso, det, paso.Length)
           Array.Copy(det, paso, det.length)

       Next



   End Sub

   Public Function ver_datos() As Array

       Return paso
   End Function

   Public Function Calcula(ByVal ylim, ByVal xlim) As Double
       Dim y As Integer
       Dim prod As Double

       prod = 1

       For y = 0 To ylim - 1

           prod = prod * paso(y, y)

       Next

       Return prod

   End Function


End Class

NOTAS:
Metodo de Gauss, admite cualquier orden n.

Un saludo

[flony]

yo se que hay ganas de ayudar y eso ...pero alguien se fijo la fecha 

Publicado en: Enero 11, 2009, 04:53:58

de todas formas en el transcurso de los días respondo es un lindo desafió