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

Soyez le premier à donner votre avis sur cette source.

Vue 8 396 fois - Téléchargée 444 fois

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 !!

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
14
Date d'inscription
dimanche 27 décembre 2009
Statut
Membre
Dernière intervention
23 janvier 2010

Cette ligne sert a déclarer dans quel package ma classe se trouve. Si tu veux que sa fonctionne il faut que tu change "pkCrameGenerale" par le nom du package dans lequel tu as placé ma source !
Messages postés
1
Date d'inscription
dimanche 23 janvier 2011
Statut
Membre
Dernière intervention
23 janvier 2011

Salut, c'est cool d'avoir fait ce programme, je suis encore newbe je me demamdais a quoi servait ta premiere ligne '# package pkCramerGenerale; ' et comment la modifier pour que le programme tourne sur ma machine, je te remerci.
Messages postés
14
Date d'inscription
dimanche 27 décembre 2009
Statut
Membre
Dernière intervention
23 janvier 2010

Merci Julien?!, en effet lorsque j'ai écrit ce programme je n'avais encore aucune connaissance de la programmation-objet. Le but de ce programme était de réaliser les algorithmes?! Bref, maintenant je commence à avoir de bonne connaissance en objet et mes énergies sont plus utilisées pour la programmation d'un jeu de billard. Soyez à l'affut, car le code se retrouvera très probablement sur ce site?!
Messages postés
6413
Date d'inscription
mardi 8 mars 2005
Statut
Modérateur
Dernière intervention
17 mai 2018
286
à vrai dire à rien :) mais je regarde toujours les codes en lien avec les mathématiques.

Je pense que tu ne connais pas le langage objet, et pourtant, tu manipules les matrice, un objet aurait pu être plus efficace. Surtout en java qui a été conçu pour le langage objet.

En plus je ne suis pas certain que les tableaux soient les meilleurs conteneurs pour ce genre de programme.

Je critique beaucoup mais je ne voudrais pas te décourager, je pense que tu débutes en java, et c'est un programme tout à fait correct.

Sinon, pour calculer les déterminants, tu utilises des règles de calcul qui sont pratiques à utiliser quand on effectue le calcul à la main, mais qui ne sont pas valables pour tout les dérerminants (pour la méthode de Sarrus). En fait le plus simple est e revenir à la définition, la somme pour toutes les permutations ... enfin cette formule http://pagesperso-orange.fr/dubois.gilles/algebre_lineaire/detsysvec.html

Tu devrais peut etre essayer de regarder des livres sur le langage objet, tu y gagnerais beaucoup.

Bonne continuation

Julien
Messages postés
14
Date d'inscription
dimanche 27 décembre 2009
Statut
Membre
Dernière intervention
23 janvier 2010

Bienvenue !, et par curiosité, a quoi t'a servi ma source ? :)
Afficher les 8 commentaires

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.