Matrice déterminant java

Ta conception de code est un peu bizarre, exemple dans les premières lignes :

mat matricenouvelle;
matricenouvelle = new mat();
matricenouvelle.T = new int[matrice.row - 1][matrice.row - 1];

Il faut que tu codes des méthodes et des constructeurs pour décomposer tes traitements, c'est plus simple ensuite à trouver les erreurs et à les corriger.

Tu devrais donc avoir un début de code comme ceci :

public Matrice // une classe commence par une majuscule 
{ 
    private final int row;
    private final int col;
    private final int tab[][]; // T est une mauvaise idée comme nom de variable, ce n'est pas suffisamment explicite, et de plus les majuscules désignent les constantes.

    public Matrice(int row,int col) // c'est au constructeur d'initialiser les données
    {
        this.row=row;
        this.col=col;
        tab = new int[row][col];
    }
}

Comme cela tu peux remplacer ton code précédent par celui-ci :

Matrice nouvelleMatrice = new Matrice(matrice.getRow()-1,matrice.getCol()-1);

Evidemment tout cela ne résout pas (encore) ton problème, mais il y a des erreurs un peu partout, et la bonne lisibilité de ton code t'aidera à en résoudre la plupart tout seul. Donc améliore ton code en le découpant en méthodes, pour y voir plus clair, et reviens si des erreurs persistent.

J'entends bien mais le problème est que ce code est celui d'un projet d'algorithmique que je dois rendre, et le langage objet n'est pas accepté car pas encore vu :s (donc this.row ou col, getRow ou getCol, c'est interdit).

De même tout ce qui est private je ne dois pas utiliser, je n'ai que le droit d'utiliser des fonctions ou procédure avec "Public static" et des structures avec Public class. En effet en objet ce serait bien plus simple mais les exigences de mon projet impliquent que j'utilise une façon de coder assez Bizarre comme tu dis, ce qui, bien sur, ne me simplifie pas la tâche.

En revanche je te suis pour tout ce qui est choix des noms et majuscules pour Constantes, c'est quelque chose que je dois faire et que je corrigerai d'ailleurs une fois mon code fini.

Concernant les erreurs un peu partout, je les situe vraiment mal et je te serai fort reconnaissant si tu pouvais me dire le type d'erreurs que je fait qui nuisent au bon fonctionnement de mon code.

C'est surtout des problèmes au niveau des indices de boucle que j'ai vu.

Exemple, dans cofacteur :

int cofacteur[][] = new int[matrice.row - 1][matrice.row - 1];

Ce tableau t'autorise à utiliser cofacteur[i][j] avec i et j entre 0 et row-2, or tu fais :

for(boucle = 1; boucle < matrice.row; boucle ++ ) 
for(boucle1 = 1; boucle1 < matrice.col; boucle1++)
    cofacteur[boucle][boucle1] = ...

Tes indices vont ici de 1 à row-1, ils sont donc décalés par rapport à ce que tu dois avoir, et ça va te donner des ArrayOutOfBoundsException...

Remarque : si ton code ne doit pas être objet, tu ne devrais pas avoir new mat();

J'ai recodé en suivant ton conseil, et en effet je n'ai plus de ArrayOutOfBoundsException, seulement maintenant ma fonction déterminant me retourne toujours déterminant = 0 !

Saurais-tu pourquoi ? Voici le code :

public static int determinant(mat matrice)
{
int determinant = 0;
mat matricenouvelle;
matricenouvelle = new mat();
matricenouvelle.T = new int[11][11];

for(int boucle = 1; boucle <= matrice.row - 1; boucle++){
//calcule le cofacteur pour la première coordonnée de toute les lignes
matricenouvelle.T= cofacteur(matrice.T,boucle,1);

//calcul le déterminant de la nouvelle matrice crée, lorsque que la matrice atteint une dimension de 3X3
//La méthode de sarrus est utilisée autrement on continue avec la méthode des cofacteurs.
if (matricenouvelle.row - 1 != 3)
determinant += (Math.pow(-1, boucle+1) * matrice.T[boucle][1]) * determinant(matricenouvelle);
else
determinant += (Math.pow(-1, boucle+1) * matrice.T[boucle][1]) * sarrus(matricenouvelle);
}
return determinant;
}

public static int sarrus(mat matrice)
{
int produit = 1;
int determinantsarrus = 0;
int matriceSarrus[][] = new int[2][4];

for(int boucle = 0; boucle < 3; boucle ++)
for(int boucle1 = 0; boucle1 < 3; boucle1 ++)
matriceSarrus[boucle][boucle1] = matrice.T[boucle][boucle1];

for (int boucle = 0; boucle < 3; boucle++)
for (int boucle1 = 0; boucle1 < 2; boucle1++)
matriceSarrus[boucle][boucle1] = matriceSarrus[boucle][boucle1 +3];

for (int boucle1 = 0; boucle1 < 3; boucle1++)
{
for (int boucle = 0; boucle < 3; boucle ++)
produit *= matriceSarrus[boucle][boucle + boucle1];
determinantsarrus += produit;
produit = 1;
}


for (int boucle1 = 0; boucle1 <= 2; boucle1++){
for (int boucle = 5, boucle2 = 1; boucle >= 3; boucle --, boucle2 ++)
produit *= matriceSarrus[boucle2][boucle - boucle1];
determinantsarrus -= produit;
produit = 1;
}

return determinantsarrus;
}

public static int[][] cofacteur(int matrice[][], int ligne, int colonne)
{
int cofacteur[][] = new int[ligne-1][colonne-1];
int boucle1;
int boucle;


for(boucle = 0; boucle < ligne-1; boucle ++ ){
for(boucle1 = 0; boucle1 < colonne-1; boucle1++)
cofacteur[boucle][boucle1] = matrice[boucle][boucle1];

for(boucle1 = 0; boucle1 < cofacteur.length-2 ; boucle1++)
cofacteur[boucle][boucle1] = matrice[boucle][boucle1+1];
}

for(boucle = 0; boucle < cofacteur.length-2 ; boucle ++ ){
for(boucle1 = 0; boucle1 < colonne-1; boucle1++)
cofacteur[boucle][boucle1] = matrice[boucle + 1][boucle1];

for(boucle1 = 0; boucle1 < cofacteur.length-2 ; boucle1++)
cofacteur[boucle][boucle1] = matrice[boucle + 1][boucle1+1];
}

return cofacteur;
}