Un programme résolvant cegenre de problème ayant déja été posté j'ai voulu publier mon algorithme qui est, je pense, plus optimisé.
Je peut ainsi résoudre 1000 équations à 1000 inconnues en moins d'une minute.
Pepito
Source / Exemple :
/*
Resolution de systemes a N equations et N inconnues
Date de dernière modification: 21-10-2002
Principe: Implementation du Pivot de Gauss
Afin de faciliter la résolution de certaines équations en astronomie, Karl Fiedrich Gauss (1777-1885) présenta en 1810, la méthode que l'on à dénommée méthode du pivot de Gauss
Elle consiste en la transformation du système linéaire initial en un système équivalent de forme diagonale
Une fonction pour améliorer la precision du calcul à ete ajoutee
Exemple:
// Exemple de systeme a 5 inconnues
// Ax + By + Cw + Dt + Eh = F
{{ 0.5 , 2 , 3 , 4 , 5 , 14.5 }, {{ 1 , 0 , 0 , 0 , 0 , x },
{ 1000 , 500 , 70 , - 30 , - 60 , 1480 }, { 0 , 1 , 0 , 0 , 0 , y },
{ - 20 , 30 , 60 , - 89 , - 6 , - 25 }, ==> { 0 , 0 , 1 , 0 , 0 , w },
{ 99 , 1 , - 600 , 0 , 501 , 1 }, { 0 , 0 , 0 , 1 , 0 , t },
{ 951 , - 256 , 695 , - 1389 , - 1 , 0 }}; { 0 , 0 , 0 , 0 , 1 , h }};
!! Attention !! pour souci de vitesse la matrice n'est pas diagonalisée, les 1 et 0 devront être mis à part ( si c'est nécessaire )
/* Déclarations */
// Librairies Standard
#include <iostream.h>
#include <stdlib.h>
// Structure du systeme
typedef long double* ligne;
typedef ligne* colonne;
typedef colonne systeme;
// Initialisation du système
systeme nouveausysteme ( const unsigned long int &);
// Destruction du système
void destruction ( systeme & , const unsigned long int & );
// Diagonalisation de la matrice et résolution du système
void resolution ( const systeme &, const unsigned long int &);
/* Implementations */
// Fonction principale de test
int main() {
// Variables temporaires
unsigned long int ligne;
unsigned long int colonne;
unsigned int add;
// Initialisation avec un exemple de systeme a ninconnues inconnues
unsigned long int ninconnues = 3;
systeme TEST = nouveausysteme ( ninconnues );
for ( ligne = 0; ligne < ninconnues ; ligne++ )
{
for (colonne = 0; colonne < ligne ; colonne ++ )
TEST[ligne][colonne]=0;
TEST[ligne][ligne]=2;
for (colonne = ligne+1; colonne < ninconnues ; colonne ++ )
TEST[ligne][colonne]=0;
TEST[ligne][ninconnues]=74;
}
// Diagonalisation de la matrice et impression des résultats
resolution ( TEST , ninconnues );
// Imprime les resultats
for (add=0 ; add < ninconnues ; add++)
cout << "X(" << add+1 << ") = " << TEST[add][ninconnues] << endl;
// Fin du programme
destruction ( TEST , ninconnues );
system ("PAUSE");
return 0;
}
// Initialisation du système
systeme nouveausysteme ( const unsigned long int & ninconnues )
{
systeme RETURN;
RETURN = new ligne [ ninconnues ];
for ( unsigned long int LIGNE = 0 ; LIGNE < ninconnues+1 ; LIGNE++ )
RETURN[LIGNE] = new long double [ ninconnues+1 ];
return RETURN;
}
// Destruction du systeme
void destruction ( systeme & sys , const unsigned long int & ninconnues)
{
for ( unsigned long int LIGNE = 0 ; LIGNE < ninconnues ; LIGNE++ )
delete [] sys[LIGNE];
}
// Algorythme de résolution et diagonalisation
void resolution ( const systeme & sys , const unsigned long int & ninconnues )
{
// Déclaration des variables temporelles
unsigned long int ligne;
unsigned long int bestligne;
unsigned long int colonnechangee;
unsigned long int scanligne;
unsigned long int colonne;
unsigned long int lignemodifiee;
long double cache;
// Diagonalisation
for (ligne = 0 ; ligne < ninconnues ; ligne++ )
{
// Fonction non indispensable, couteuse en temps d'elaboration qui cependant augmente sensiblement la precision des calculs
// Un sort sur la diagonale principale augmenterait la vitesse
// Si la précision n'est pas importante il suffit de mettre ici une procédure qui vérifie que sys[ligne][ligne]!=0
bestligne = ligne;
for (scanligne = ligne+1 ; scanligne < ninconnues ; scanligne++ )
if ( abs(sys[scanligne][ligne]) > abs(sys [bestligne][ligne]) )
bestligne = scanligne;
if ( bestligne != ligne )
for ( colonnechangee = ligne ; colonnechangee <= ninconnues ; colonnechangee++ )
{
cache = sys[ligne][colonnechangee];
sys[ligne][colonnechangee] = sys[bestligne][colonnechangee];
sys[bestligne][colonnechangee] = cache;
}
else
if ( sys[ligne][ligne] == 0 )
throw "LE SYSTEME ADMET UNE INFINITE OU AUCUNE SOLUTION";
// Diagonalisation de la matrice
// Positionnement des 1
for ( colonne = ligne+1 ; colonne <= ninconnues ; colonne++)
sys[ligne][colonne] = sys[ligne][colonne] / sys[ligne][ligne];
// Positionnement des 0
for ( colonne = ligne+1 ; colonne <= ninconnues ; colonne++)
{
for ( lignemodifiee = 0 ; lignemodifiee < ligne ; lignemodifiee++ )
sys[lignemodifiee][colonne] -= sys [ligne][colonne] * sys [lignemodifiee][ligne] ;
for ( lignemodifiee = ligne+1 ; lignemodifiee < ninconnues ; lignemodifiee++ )
sys[lignemodifiee][colonne] -= sys [ligne][colonne] * sys [lignemodifiee][ligne] ;
}
}
}
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.