Résolution d'équation grâce au calcul des déterminants

Télécharger le projet
Commenter

Description

Résous des équations de type Ax + By +Cz = D grâce au calcul de déterminant. Le calcul de déterminant est réalisé grâce a la méthode "générale" de manière récursive

Source / Exemple : 


package pkCramerGenerale;

import javax.swing.*;

public class cramer {
	
	static int ctr;
	
	public static void main(String[] args) {
		int nbrInconnu = Integer.parseInt(JOptionPane.showInputDialog(null, "Combien avez-vous d'inconnu ?" ));
		double matrice[][] = new double [nbrInconnu + 1][nbrInconnu + 1];
		double matriceresult[] = new double [nbrInconnu + 1];
		double buffer[] = new double [nbrInconnu + 1];
		double determinantA;
		double determinantH;
		double inconnu;
		String reponse = "";
		String reponse2 = "";
		String alphabet[] = {"","A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};
		

		
		for (int boucle = 1; boucle <= nbrInconnu; boucle++){
			for (int boucle1 = 1; boucle1 <= nbrInconnu; boucle1++){
				matrice[boucle][boucle1] = Double.parseDouble(JOptionPane.showInputDialog(null, "Entrer le paramètre " + boucle + "," + boucle1 + " de la matrice des paramètres"));
				reponse += matrice[boucle][boucle1] + alphabet[boucle1] + " + ";
			}
			
			matriceresult[boucle] = Double.parseDouble(JOptionPane.showInputDialog(null, "Entrer le paramètre " + boucle + ",1 de la matrice des résultats"));
			reponse += " = " + matriceresult[boucle] + "\n";
		}
		
		determinantA = generaleRecursive(matrice);
		
		for(int boucle = 1; boucle <= nbrInconnu; boucle++){
			
			for(int boucle1 = 1; boucle1 <= nbrInconnu; boucle1++){
				buffer[boucle1] = matrice[boucle1][boucle];
				matrice[boucle1][boucle] = matriceresult[boucle1];
			}
						
			determinantH = generaleRecursive(matrice);
			inconnu = determinantH/determinantA;
			reponse2 += alphabet[boucle] + " = " + inconnu + " \n";
			
			for(int boucle1 = 1; boucle1 <= nbrInconnu; boucle1++)
				matrice[boucle1][boucle] = buffer[boucle1];
		}
		
		JOptionPane.showMessageDialog(null, reponse + " \n" + reponse2 + " \n" + "Sarrus a été executé " + ctr + " fois.");
			
		System.exit(0);
	}

	//méthode génerale
	public static double generaleRecursive(double matrice[][]){
		int valeur;
		double determinant = 0;
		double matricerecur[][] = new double[matrice.length - 1][matrice.length - 1];
		for(int boucle = 1; boucle <= matrice.length - 1; boucle++){
				
			if ((boucle + 1) % 2 == 0)
				valeur = 1;
			else
				valeur = -1;
			
			//enlève la bonne ligne et la bonne colonne ds la nouvelle matrice			
			for(int boucle2 = 1; boucle2 <= matricerecur.length - 1; boucle2++){
				for(int boucle1 = 1; boucle1 < boucle; boucle1++)
					matricerecur[boucle1][boucle2] = matrice[boucle1][boucle2 + 1];
				
				for(int boucle1 = boucle + 1; boucle1 <= matricerecur.length; boucle1++)
					matricerecur[boucle1-1][boucle2] = matrice[boucle1][boucle2 + 1];	
			}
			
			//applique la formule
			if (matricerecur.length - 1 != 3)
				determinant += (valeur * matrice[boucle][1]) * generaleRecursive(matricerecur);
			else
				determinant += (valeur * matrice[boucle][1]) * sarrus(matricerecur);
		}	
		return determinant;
	}
		
	
	//calcul d'un déterminant 3X3 avec la méhode de sarrus (les diagonales)
	 static double sarrus(double matrice[][]) {
		double produit = 1;
		double determinantsarrus = 0;
		double matriceSarrus[][] = new double[4][6];
		
		ctr++;
		
		for(int boucle = 1; boucle <= 3; boucle ++)
			for(int boucle1 = 1; boucle1 <= 3; boucle1 ++)
				matriceSarrus[boucle][boucle1] = matrice[boucle][boucle1];
		
		for (int boucle = 1; boucle <= 3; boucle++)
			for (int boucle1 = 4; boucle1 <= 5; boucle1++)
				matriceSarrus[boucle][boucle1] = matriceSarrus[boucle][boucle1 - 3];
			
		for (int boucle1 = 0; boucle1 <= 2; boucle1++){
			for (int boucle = 1; 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;
	}

}

Conclusion :


Peu être utiliser pour de multiple application, mais malheureusement, mes connaisances en mathémathiques de me permettent pas de m'étendre sur ce sujet ;) j'attends vos commentaires !!
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (frankladen11)