Determinante de una matriz NxN

Buenas tardes a todos.

Necesito hacer el determinante de una matriz 6x6, y a pesar de tener la biblioteca MatrixMath.h, con la cual podemos realizar la mayoría de cálculos matriciales, no hay ninguna función especifica para hacer el determinante.

Tras buscar por Internet bastante, encontré este código que es el que se suele usar prácticamente en todos sitios, pero al pasarlo a mi Arduino no funciona.

Os pongo aquí el código para ver si le podéis echar un vistazo y ayudarme a depurarlo. El problema es que la variable aux no incrementa como debería hacerlo, y no sé porque está ocurriendo esto.

int i, j;
int n = 6;

double result;

double **m=NULL;

double ma[6][6] = {
	{ 1,2,1,1,2,7 },
{ 7,3,6,3,9,2 },
{ 6,6,6,3,1,2 },
{ 2,2,2,7,1,2 },
{ 1,6,6,7,2,1 },
{ 5,3,7,9,9,2 } };

void setup() {
	Serial.begin(9600);
	delay(500);
	Serial.println("###########################");
	Serial.println("COMUNICACION SERIE HABILITADA.");
	Serial.println("###########################");

}// end setup

void loop() {

	Serial.println("###########################");
	Serial.println("LOOP.");
	Serial.println("###########################");

        m = (double **)malloc(sizeof(double)*n);
        for(int i=0; i<n; i++) m[i]=(double *)malloc(sizeof(double)*n);

	for (i = 0; i<n; i++)
	{

		for (j = 0; j<n; j++)
		{
                        m[i][j]=ma[i][j];
			Serial.print(m[i][j]);
			Serial.print("    ");
		}
		Serial.println("    ");
	}

	Serial.print("Calculamos determinante: ");
	Serial.println("    ");

	result = det(m, 6);

	Serial.print("Determinante: ");
	Serial.print(result);
	Serial.println("    ");



	Serial.println("###########################");
	Serial.println("Fin funcion determinante.");
	Serial.println("###########################");

}


double det(double **m, int b) {

	double determinante = 0, aux = 0;

	int c;

        for (int q=0; q<b;q++)
        {
          for(int w=0;w<b;w++)
          {
            Serial.print(m[q][w]);
	    Serial.print("    ");
          }
        Serial.println("    ");        
        }

	for (int j = 0; j<b; j++) {


		double **menor = (double **)malloc(sizeof(double)*(b - 1));

		for (int h = 0; h<(b - 1); h++) menor[h] = (double *)malloc(sizeof(double)*(b - 1));

		for (int k = 1; k<b; k++) {

			c = 0;

			for (int l = 0; l<b; l++) {

				if (l != j) {

					menor[k - 1][c] = m[k][l];
				
					c++;

				}
			}
		}

		aux = pow(-1, (2 + j))*m[0][j] * det(menor, (b - 1));

                Serial.print("  aux  ");
                Serial.print(aux);
	        Serial.println("    ");

		determinante += aux;
                Serial.print("  Determinante  ");
                Serial.print(determinante);
	        Serial.println("    ");

		for (int q = 0; q<(b - 1); q++)

			{free(menor[q]);}

		free(menor);

	}
	return determinante;


}

Muchas gracias de antemano.

Un saludo.

No es tan fácil cuando pasas de una matriz de orden 3 o 4, a partir de ahí se complican los cálculos

Por cierto, no se puede usar Sarrus en matrices de orden mayor a 3... para que lo corrijas de tus apuntes de clase.

Un saludo y gracias de nuevo.

Bueno creo que hiciste mucho copy & paste y poco análisis

Partí de ver el resultado con una matriz conocida de 3x3 y luego observé las fallas del código.

El resultado

EDITADO hasta ver que le has dicho a @ArduMyth por privado

Tu código tiene varios errores. Trate de no cambiartelo mucho para que logres comparar. Esta adaptado para funcionar en NxN y deje varios ejemplos comentados al principio para probar.

//Matriz nxn a calcular
/*Ejemplo 1
const long ma[2][2] = {
	{ 1,2 },
	{ 7,3 }
};*/
/*Ejemplo 2
const long ma[3][3] = {
	{ 1,2,1 },
	{ 7,3,6 },
	{ 6,6,6 }
};*/
/*Ejemplo 3
const long ma[4][4] = {
	{ 1,2,1,1 },
	{ 7,3,6,3 },
	{ 6,6,6,3 },
	{ 2,2,2,7 }
};*/
/*Ejemplo 4
const long ma[5][5] = {
	{ 1,2,1,1,2 },
	{ 7,3,6,3,9 },
	{ 6,6,6,3,1 },
	{ 2,2,2,7,1 },
	{ 1,6,6,7,2 }
};*/
//Ejemplo 5
const long ma[6][6] = {
	{ 1,2,1,1,2,7 },
	{ 7,3,6,3,9,2 },
	{ 6,6,6,3,1,2 },
	{ 2,2,2,7,1,2 },
	{ 1,6,6,7,2,1 },
	{ 5,3,7,9,9,2 } 
};

byte n = sqrt(sizeof(ma)/sizeof(ma[0][0]));
long result;
long** m = NULL;

void setup() {
	Serial.begin(115200);
	delay(100);
	Serial.println("#############################");
	Serial.println("COMUNICACION SERIE HABILITADA");
	Serial.println("#############################");
}

void loop(){
	m = (long **)malloc(sizeof(long)*n);
	for (byte i=0; i<n; i++){
		m[i]=(long *)malloc(sizeof(long)*n);
	}
	for (byte i=0; i<n; i++){
		for (byte j=0; j<n; j++){
			m[i][j]=ma[i][j];
			Serial.print(m[i][j]);
			Serial.print("  ");
            delay(20);
		}
		Serial.println();
	}
	Serial.println("\nCalculamos determinante:");

	result = det(m, n);     //Llama función

	Serial.print("Determinante: ");
	Serial.print(result);
	Serial.println();

	Serial.println("\n########################");
	Serial.println("Fin función determinante");
	Serial.println("########################");
	while(1){;}
}

long det(long **m, byte b){
	long determinante=0, aux=0;
	if (b==2){
		determinante = m[0][0]*m[1][1] - m[1][0]*m[0][1];
	}else{
		for (byte i=0; i<b; i++){
			long **menor = (long **)malloc(sizeof(long)*(b-1));
			for (byte j=0; j<(b-1); j++){
				menor[j] = (long *)malloc(sizeof(long)*(b-1));
			}
			for (byte j=1; j<b; j++){
				byte c = 0;
				for (byte k=0; k<b; k++){
					if (k!=i){
						menor[j-1][c] = m[j][k];
						c++;
					}
				}
			}
			aux = pow(-1, i+2)*m[0][i]*det(menor, b-1);
			determinante += aux;
			for (byte j=0; j<(b-1); j++){
				free(menor[j]);
			}
			free(menor);
		}
					  
	}
	return determinante;
}

El codigo esta comprobado.