[Java] determinante di una matrice quadrata qualsiasi

[boulayo]

salve a tutti,
vorrei chiedervi, come posso scrivere un metodo che calcola il determinante di una matrice quadrata di ordine qualsiasi?

//COMPLEMENTO ALGEBRICO
	public static int complementoAlgebrico(int[][]m,int riga,int colonna){
		int a= (int) Math.pow(-1, riga + colonna);
		return a;
	}

//Minore complementare
	public static int[][] minore(int m[][],int riga,int colonna){
		int[][]n = new int[m.length-1][m[0].length-1];
		n = eliminaRiga(eliminaColonna(m,colonna),riga);
		return n;
	}

//Determinante di una matrice
	public static int determinante(int[][] m){
		int determinante = 0;
		int temporaneo = 0;
		if (m.length!=m[0].length)
			System.out.println("La matrice non e' quadrata, non ha senso calcolarne il determinante");
		else if (m.length==1)
			determinante+=m[0][0];
		else{
			//COSA DEVO SCRIVERE QUI?
			}
		}
		return determinante;
	}

in pratica voglio calcolarlo usando la regola di Laplace. quindi vorrei ridurre tutto a matrici di ordine 2 e calcolare il determinante in base a quelle.
i primi tre sono i metodi che dovrebbero servire per il metodo del determinante, ma chi mi aiuta a implementarlo?
grazie

[LeleFT]

Io l'ho realizzato in passato. Devi creare un metodo ricorsivo che prenda come argomento la matrice (che di volta in volta verrà ridotta, eliminando la riga e la colonna interessata dal calcolo).

Se riesco a recuperare il codice lo posto.

... Eccolo:

    private long det(int ai[][], int i)
    {
        long l = 0L;
        if(i == 1)
            l = ai[0][0];
        else
        if(i == 2)
        {
            l = ai[0][0] * ai[1][1] - ai[0][1] * ai[1][0];
        } else
        {
            int ai1[][] = new int[i - 1][i - 1];
            for(int k = 0; k < i; k++)
            {
                for(int i1 = 1; i1 < i; i1++)
                {
                    int j = 0;
                    for(int j1 = 0; j1 < i; j1++)
                        if(j1 != k)
                        {
                            ai1[i1 - 1][j] = ai[i1][j1];
                            j++;
                        }

                }

                if(k % 2 == 0)
                    l += (long)ai[0][k] * det(ai1, i - 1);
                else
                    l -= (long)ai[0][k] * det(ai1, i - 1);
            }

        }
        return l;
    }

Ovviamente è migliorabile e il parametro dell'ordine può essere trascurato, utilizzando la proprietà length degli array (all'epoca non ero molto esperto di Java... )


Ciao.