Determinante de uma matriz de ordem n

Programação Java
#1

Ser a matriz não for de ordem 3 vai ter problema.

Tem como fazer algo para identificar as diags Prin e Sec?

Estava pensando em um for.

=============================================================

import java.util.Scanner;

public class DetMatriz {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); // Preparando o console para leitura
double det = 0;
double diagPrin1, diagPrin2, diagPrin3, diagSec1, diagSec2, diagSec3; // Variaveis para cálculo das diagonais
double mat[][] = new double [3][3]; // Declarando e alocando matriz
for (int i=0; i<mat.length; i++) {
for (int c=0; c<mat[i].length; c++) {
System.out.printf("Informe %do valor da %da linha : ", c+1, i+1);
mat[i][c] = sc.nextDouble();
}
}
// Diagonais principais
diagPrin1 = mat[0][0] * mat[1][1] * mat[2][2];
diagPrin2 = mat[0][1] * mat[1][2] * mat[2][0];
diagPrin3 = mat[0][2] * mat[1][0] * mat[2][1];
// Diagonais Secundárias
diagSec1 = mat[2][0] * mat[1][1] * mat[0][2];
diagSec2 = mat[2][1] * mat[1][2] * mat[0][0];
diagSec3 = mat[2][2] * mat[1][0] * mat[0][1];
// Determinante
det = -(diagSec1 + diagSec2 + diagSec3) + (diagPrin1 + diagPrin2 + diagPrin3);
System.out.println("O determinante da matriz eh : " + det);
sc.close();
}
}

#2

Olá,

Você está utilizando a Regra de Sarrus, correto?
Essa regra só funciona com matrizes 3x3. Para funcionar com diferentes tamanhos é necessário fazer algumas alterações. Utilizei Laplace para calcular.
Fiz alguns testes para as matrizes e funcionou corretamente:
1 0 0 0
1 1 1 1
2 3 4 9
2 4 10 28

e

1 0 0
1 1 1
2 3 5

private int DET;
public static void main(String[] args) {
	new Teste().executar();
}

private void executar() {
	Scanner sc = new Scanner(System.in); // Preparando o console para leitura
	double mat[][] = new double[4][4]; // Declarando e alocando matriz
	for (int i = 0; i < mat.length; i++) {
		for (int c = 0; c < mat[i].length; c++) {
			System.out.printf("Informe %do valor da %da linha : ", c + 1, i + 1);
			mat[i][c] = sc.nextDouble();
		}
	}
	sc.close();
	System.out.println("Determinante: " + calcularMatrizDeterminante(mat, mat.length));
}


public double calcularMatrizDeterminante(double matriz[][], int ordem) {
	if (ordem == 1)
		return (matriz[0][0]);
	if (ordem == 2)
		return (matriz[0][0] * matriz[1][1] - matriz[1][0] * matriz[0][1]);
	else {
		double[][] matrizAuxiliar = new double[ordem - 1][ordem - 1];
		int colunaAuxiliar = 0;
		for (int controle = 0; controle < ordem; controle++) {
			for (int linha = 1; linha < ordem; linha++) {
				for (int coluna = 0; coluna < ordem; coluna++)
					if (controle != coluna)
						matrizAuxiliar[linha - 1][colunaAuxiliar++] = (int) matriz[linha][coluna];
				colunaAuxiliar = 0;
			}
			if (matriz[0][controle] != 0)
				this.DET += (int) Math.pow((-1), controle) * matriz[0][controle] * calcularMatrizDeterminante(matrizAuxiliar, ordem - 1);
		}
	}
	return (this.DET);
}
#3

Não entendi esse código.

Como Calcular?

Para calcular os determinantes, devemos seguir os seguintes passos:

**Selecionar uma linha ou uma coluna. Lembrando que na presença de zeros, a escolha da linha ou da coluna que contenha a maior quantidade de elementos igual a zero torna os cálculos mais simples;**

Somar os números constantes da linha selecionada e multiplicá-los pelos seus respectivos cofatores, ou seja, Σ = aij * Aij.

====================================================================

ordem seria o tamanho da matriz original?

matrizAuxiliar = new double[ordem - 1][ordem - 1]

Na matriz auxiliar vai ter problema com 5x5 ou nxn …

Ex:

Matriz 5x5

matrizAuxiliar = new double[ordem - 1][ordem - 1]

matrizAuxiliar = new double[5 - 1][5 - 1]

matrizAuxiliar = new double[4][4]

Matriz 6x6

matrizAuxiliar = new double[ordem - 1][ordem - 1]

matrizAuxiliar = new double[6 - 1][6 - 1]

matrizAuxiliar = new double[5][5]

…

matrizAuxiliar deveria ser uma matriz de ordem 3x3 (Regra de Sarrus).

Fontes: