begin process at 2010 03 18 16:37:49
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Maths & Algorithmes

 > RÉSOLUTION DES SYSTÈME AX=B

RÉSOLUTION DES SYSTÈME AX=B


 Information sur la source

Note :
8,5 / 10 - par 2 personnes
8,50 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Maths & Algorithmes Classé sous :gauss, jordan, lu, cramer, jacobie Niveau :Débutant Date de création :21/02/2007 Date de mise à jour :22/11/2008 18:45:23 Vu :16 439

Auteur : cresuscresus

Ecrire un message privé
Commentaire sur cette source (11)
Ajouter un commentaire et/ou une note

 Description

Ce document contient :

résolution des systèmes Ax=B par : inversion, cramer ,gauss, gauss pivot partiel, gauss pivot total, jordan et LU (croot et doolittle), Cholesky, jacobie, Gauss-Seidel.

Ecole nationale polytechnique d'alger, ENP

compilé sous Dev-C++



Source

  • /* ========================================================================== */
  • /* TP informatique SF2A G7 Khelifi Walid 2006/2007 */
  • /* Ecole nationale polytechnique, El Harrach Alger */
  • /* Description : Resolution des systèmes */
  • /* ========================================================================== */
  • /*
  • Résolution de A x = b par :
  • Cramer , Inversion , Gauss , Gauss pivot partiel ,
  • Gauss pivot total , Jordan , Décomposition LU croot ,
  • LU doolittle , Cholseky ,
  • et les methodes itératives de Jacobie et Gauss-Seidel.
  • */
  • #include <stdio.h>
  • #include <math.h>
  • void cramer(float [][],float [],int);
  • void inversion(float [][],float [],int);
  • float det(float [][],int);
  • void comatrices(float [][],float [][],int,int,int);
  • void gauss(float [][],float [],int);
  • void gauss_pivot_partiel(float [][],float [],int);
  • void gauss_pivot_total(float [][],float [],int);
  • void jordan(float [][],float [],int);
  • void LU_doolittle(float [][],float [],int);
  • void LU_crout(float [][],float [],int);
  • void cholesky(float [][],float [],int);
  • void jacobie(float [][],float [],int);
  • void gauss_seidel(float [][],float [],int);
  • float norme(float [],int);
  • void remplissage(float [][],float [],int);
  • void aff_syst(float [][],float [],int);
  • void aff_mat(float [][],int);
  • void zero(float [][],float [],int);
  • main()
  • {
  • float a[19][19],b[19];int n,i,j; char valider;
  • // choix de la methode
  • printf("\n *******************************************************\n");
  • printf(" * *\n");
  • printf(" * Resolution de A x = B *\n");
  • printf(" * *\n");
  • printf(" *******************************************************\n");
  • printf(" * *\n");
  • printf(" * Choix de la methode : *\n");
  • printf(" * *\n");
  • printf(" * A => Cramer *\n");
  • printf(" * B => Inversion *\n");
  • printf(" * C => Gauss *\n");
  • printf(" * D => Gauss pivot partiel *\n");
  • printf(" * E => Gauss pivot total *\n");
  • printf(" * F => Jordan *\n");
  • printf(" * G => LU Doolittle *\n");
  • printf(" * H => LU Crout *\n");
  • printf(" * I => Cholesky *\n");
  • printf(" * J => Jacobie *\n");
  • printf(" * K => Gauss-Seidel *\n");
  • printf(" * *\n");
  • printf(" *******************************************************\n");
  • printf(" * *\n");
  • printf(" * X => E X I T *\n");
  • printf(" * *\n");
  • printf(" *******************************************************\n\n");
  • reprendre_choix:
  • printf("------ => donner votre choix ------ : ");
  • scanf("%s",&valider);
  • void remplir()
  • {
  • printf("\n\n * Nombre d'equation-inconues : \n\n * N = ");
  • scanf("%d",&n);
  • remplissage(a,b,n);
  • printf("\n\n * Le systeme est : ");
  • aff_syst(a,b,n);
  • }
  • switch(valider)
  • {
  • case 'A' : remplir();cramer(a,b,n); break;
  • case 'B' : remplir();inversion(a,b,n); break;
  • case 'C' : remplir();gauss(a,b,n); break;
  • case 'D' : remplir();gauss_pivot_partiel(a,b,n); break;
  • case 'E' : remplir();gauss_pivot_total(a,b,n); break;
  • case 'F' : remplir();jordan(a,b,n); break;
  • case 'G' : remplir();LU_doolittle(a,b,n); break;
  • case 'H' : remplir();LU_crout(a,b,n); break;
  • case 'I' : remplir();cholesky(a,b,n); break;
  • case 'J' : remplir();jacobie(a,b,n); break;
  • case 'K' : remplir();gauss_seidel(a,b,n); break;
  • case 'X' : printf("\nProgramme interompu par l'utilisateur.......\n\n");
  • system("PAUSE");exit(0); break;
  • default : goto reprendre_choix;
  • }
  • printf("\n");
  • system("PAUSE");
  • main();
  • }
  • // -------------------------------------------------------------
  • // Fonctions utiles pour la résolution par Cramer et inversion
  • // -------------------------------------------------------------
  • // calcul du determinant
  • float det(float a[19][19],int n)
  • {
  • int k,j;float c[19][19],s;
  • k=n-1;
  • if(n==0) return(1);
  • s=0;
  • for(j=0;j<n;j++)
  • {
  • comatrices(a,c,k,j,n);
  • s=s+pow(-1,k+j)*a[k][j]*det(c,k);
  • }
  • return(s);
  • }
  • // calcul des comatrices
  • void comatrices(float a[19][19],float c[19][19],int i,int j,int n)
  • {
  • int l,k;
  • for(l=0;l<n;l++) for(k=0;k<n;k++)
  • {
  • if ((l<i)&&(k<j)) c[l][k]=a[l][k];
  • if ((l>i)&&(k<j)) c[l-1][k]=a[l][k];
  • if ((l<i)&&(k>j)) c[l][k-1]=a[l][k];
  • if ((l>i)&&(k>j)) c[l-1][k-1]=a[l][k];
  • }
  • }
  • // -------------------------------------------------------------
  • // Résolution Par Cramer
  • // -------------------------------------------------------------
  • void cramer(float a[19][19],float b[19],int n)
  • {
  • float A[19][19],x[19],deter;int i,j,k;
  • deter=det(a,n);
  • if (deter==0)
  • {
  • printf("\n => Determinant nul, pas de solutions \n\n");
  • system("PAUSE");main();
  • }
  • for(j=0;j<n;j++)
  • {
  • for(k=0;k<n;k++)
  • {
  • if (k==j) for(i=0;i<n;i++) A[i][k]=b[i];
  • else for(i=0;i<n;i++) A[i][k]=a[i][k];
  • }
  • x[j]=det(A,n)/deter;
  • }
  • printf("\n-------------- Cramer -------------\n");
  • printf("\n * Le determiant du systeme : %f \n",deter);
  • printf("\n * La resolution donne :\n\n");
  • for (i=0;i<n;i++) printf(" X_%d = %f ;\n",i+1,x[i]);
  • }
  • // -------------------------------------------------------------
  • // Résolution Par Inversion
  • // -------------------------------------------------------------
  • void inversion(float a[19][19],float b[19],int n)
  • {
  • float c[19][19],comat[19][19],a_1[19][19],x[19],deter,s;int i,j;
  • deter=det(a,n);
  • if (deter==0)
  • {
  • printf("\n => Matrice non inversible, pas de solutions \n\n");
  • system("PAUSE");main();
  • }
  • for(i=0;i<n;i++) for(j=0;j<n;j++)
  • {
  • comatrices(a,c,i,j,n);
  • comat[i][j]=(pow(-1,i+j)/deter)*(det(c,n-1));
  • }
  • // transposée
  • for(i=0;i<n;i++) for(j=0;j<n;j++)
  • a_1[i][j]=comat[j][i];
  • //résolution
  • for(i=0;i<n;i++)
  • {s=0;
  • for(j=0;j<n;j++) s=s+a_1[i][j]*b[j];
  • x[i]=s;
  • }
  • printf("\n-------------- Inversion -------------\n");
  • printf("\n * La matrice inverse A^-1 :");
  • aff_mat(a_1,n);
  • printf("\n * La resolution donne :\n\n");
  • for (i=0;i<n;i++) printf(" X_%d = %f ;\n",i+1,x[i]);
  • }
  • // -------------------------------------------------------------
  • // Résolution Par Gauss
  • // -------------------------------------------------------------
  • void gauss(float a[19][19],float b[19],int n)
  • {
  • float x[19],p,s;int i,j,k;
  • for(k=0;k<n-1;k++)
  • {
  • if (a[k][k]==0)
  • {
  • printf("\n\n * Un pivot nul ! => methode de Gauss non applicable\n\n");
  • system("PAUSE");main();
  • }
  • //réduction
  • for(i=k+1;i<n;i++)
  • {
  • p=a[i][k]/a[k][k];
  • for (j=k;j<n;j++) a[i][j]=a[i][j]-p*a[k][j];
  • b[i]=b[i]-p*b[k];
  • }
  • }
  • //Résolution
  • for(i=n-1;i>=0;i--)
  • {
  • s=0;
  • for(j=i+1;j<n;j++)s=s+a[i][j]*x[j];
  • x[i]=(b[i]-s)/a[i][i];
  • }
  • zero(a,b,n);
  • printf("\n-------------- Gauss -------------\n");
  • printf("\n * La matrice reduite :");
  • aff_syst(a,b,n);
  • printf("\n * La resolution donne :\n\n");
  • for (i=0;i<n;i++) printf(" X_%d = %f ;\n",i+1,x[i]);
  • }
  • // -------------------------------------------------------------
  • // Résolution Par Gauss pivot pariel
  • // -------------------------------------------------------------
  • void gauss_pivot_partiel(float a[19][19],float b[19],int n)
  • {
  • float x[19],p,s,ref,temp;int i,j,k,ligne;
  • for(k=0;k<n-1;k++)
  • {
  • // max pour le pivot partiel
  • ref=0;
  • for(i=k;i<n;i++) if(fabs(a[i][k])>ref) {ref=fabs(a[i][k]);ligne=i;}
  • // pivotations
  • for(j=k;j<n;j++)
  • {temp=a[k][j]; a[k][j]=a[ligne][j] ;a[ligne][j]=temp;}
  • temp=b[k]; b[k]=b[ligne]; b[ligne]=temp;
  • if (a[k][k]==0)
  • {
  • printf("\n\n* Un pivot nul ! => methode de Gauss pivot partiel non applicable\n\n");
  • system("PAUSE");main();
  • }
  • //réduction
  • for(i=k+1;i<n;i++)
  • {
  • p=a[i][k]/a[k][k];
  • for (j=k;j<n;j++) a[i][j]=a[i][j]-p*a[k][j];
  • b[i]=b[i]-p*b[k];
  • }
  • }
  • //Résolution
  • for(i=n-1;i>=0;i--)
  • {
  • s=0;
  • for(j=i+1;j<n;j++) s=s+a[i][j]*x[j];
  • x[i]=(b[i]-s)/a[i][i];
  • }
  • zero(a,b,n);
  • printf("\n-------- Gauss avec pivot partiel --------\n");
  • printf("\n * La matrice reduite :");
  • aff_syst(a,b,n);
  • printf("\n * La resolution donne :\n\n");
  • for (i=0;i<n;i++) printf(" X_%d = %f ;\n",i+1,x[i]);
  • printf("\n");
  • }
  • // -------------------------------------------------------------
  • // Résolution Par Gauss pivot total
  • // -------------------------------------------------------------
  • void gauss_pivot_total(float a[19][19],float b[19],int n)
  • {
  • float x[19],p,s,ref,temp;int i,j,k,ligne,colonne,pivot_sol[19],temps;
  • // vecteur de pivotation des solutions
  • for(i=0;i<n;i++) pivot_sol[i]=i;
  • for(k=0;k<n-1;k++)
  • {
  • // max pour le pivot total
  • ref=0;
  • for(i=k;i<n;i++) for (j=k;j<n;j++)
  • if(fabs(a[i][j])>ref) {ref=fabs(a[i][j]);ligne=i;colonne=j;}
  • // pivotations
  • for(j=k;j<n;j++) {temp=a[k][j]; a[k][j]=a[ligne][j] ;a[ligne][j]=temp;}
  • temp=b[k]; b[k]=b[ligne]; b[ligne]=temp;
  • for(i=0;i<n;i++) {temp=a[i][k]; a[i][k]=a[i][colonne] ;a[i][colonne]=temp;}
  • // remplissage du vecteur accordé aux pivotations
  • temps=pivot_sol[k];
  • pivot_sol[k]=pivot_sol[colonne];
  • pivot_sol[colonne]=temps;
  • if (a[k][k]==0)
  • {
  • printf("\n\n * Un pivot nul ! => methode de Gauss pivot total non applicable\n\n");
  • system("PAUSE");main();
  • }
  • //réduction
  • for(i=k+1;i<n;i++)
  • {
  • p=a[i][k]/a[k][k];
  • for (j=k;j<n;j++) a[i][j]=a[i][j]-p*a[k][j];
  • b[i]=b[i]-p*b[k];
  • }
  • }
  • // Résolution
  • for(i=n-1;i>=0;i--)
  • {
  • s=0;
  • for(j=i+1;j<n;j++)s=s+a[i][j]*b[j];
  • b[i]=(b[i]-s)/a[i][i];
  • }
  • // pivotation des solutions
  • for(i=0;i<n;i++) x[pivot_sol[i]]=b[i];
  • zero(a,b,n);
  • printf("\n--------- Gauss avec pivot total ---------\n");
  • printf("\n * La matrice reduite :");
  • aff_syst(a,b,n);
  • printf("\n * La resolution donne :\n\n");
  • for (i=0;i<n;i++) printf(" X_%d = %f ;\n",i+1,x[i]);
  • printf("\n");
  • }
  • // -------------------------------------------------------------
  • // Résolution Par Jordan
  • // -------------------------------------------------------------
  • void jordan(float a[19][19],float b[19],int n)
  • {
  • float p;int i,j,k;
  • for(k=0;k<n;k++)
  • {
  • if (a[k][k]==0)
  • {
  • printf("\n\n * Un pivot nul ! => methode de Jordan non applicable\n\n");
  • system("PAUSE");main();
  • }
  • p=a[k][k];
  • //normalisation
  • for (j=k;j<n;j++) a[k][j]=a[k][j]/p;
  • b[k]=b[k]/p;
  • //réduction
  • for(i=0;i<n;i++)
  • {
  • if (i!=k)
  • {
  • p=a[i][k];
  • for (j=k;j<n;j++) a[i][j]=a[i][j]-p*a[k][j];
  • b[i]=b[i]-p*b[k];
  • }
  • }
  • }
  • zero(a,b,n);
  • printf("\n-------------- Jordan -------------\n");
  • printf("\n * La matrice reduite :");
  • aff_syst(a,b,n);
  • printf("\n * La resolution donne :\n\n");
  • for(i=0;i<n;i++) printf(" X_%d = %f ;\n",i+1,b[i]);
  • printf("\n");
  • }
  • // -------------------------------------------------------------
  • // Résolution Par décomposition LU Doolittle
  • // -------------------------------------------------------------
  • void LU_doolittle(float a[19][19],float b[19],int n)
  • {
  • float L[19][19],U[19][19],x[19],y[19],s;int i,j,k,m;
  • for (i=0;i<n;i++) for (j=0;j<n;j++)
  • {
  • if(i==j) L[i][j]=1; else L[i][j]=0;
  • U[i][j]=0;
  • }
  • for (m=0;m<n;m++)
  • {
  • for (j=m;j<n;j++)
  • {
  • s=0;
  • for (k=0;k<m;k++) s=s+L[m][k]*U[k][j];
  • U[m][j]=a[m][j]-s;
  • }
  • if (U[k][k]==0)
  • {
  • printf("\n\n * Un mineur nul ! => methode de LU non applicable\n\n");
  • system("PAUSE");main();
  • }
  • for (i=m+1;i<n;i++)
  • {
  • s=0;
  • for (k=0;k<m;k++) s=s+L[i][k]*U[k][m];
  • L[i][m]=(a[i][m]-s)/U[m][m];
  • }
  • }
  • // resolution
  • for(i=0;i<n;i++)
  • {
  • s=0;
  • for(j=0;j<i;j++) s=s+L[i][j]*y[j];
  • y[i]=(b[i]-s)/L[i][i];
  • }
  • for(i=n-1;i>=0;i--)
  • {
  • s=0;
  • for(j=i+1;j<n;j++)s=s+U[i][j]*x[j];
  • x[i]=(y[i]-s)/U[i][i];
  • }
  • printf("\n------------ LU Doolittle -----------\n");
  • printf("\n * A = L * U \n");
  • printf("\n * La matrice L :");
  • aff_mat(L,n);
  • printf("\n * La matrice U :");
  • aff_mat(U,n);
  • printf("\n * La resolution donne :\n\n");
  • for (i=0;i<n;i++) printf(" X_%d = %f ;\n",i+1,x[i]);
  • }
  • // -------------------------------------------------------------
  • // Résolution Par décomposition LU Crout
  • // -------------------------------------------------------------
  • void LU_crout(float a[19][19],float b[19],int n)
  • {
  • float L[19][19],U[19][19],x[19],y[19],s;int i,j,k,m;
  • for (i=0;i<n;i++) for (j=0;j<n;j++)
  • {
  • if(i==j) U[i][j]=1; else U[i][j]=0;
  • L[i][j]=0;
  • }
  • for (m=0;m<n;m++)
  • {
  • for (i=m;i<n;i++)
  • {
  • s=0;
  • for (k=0;k<m;k++) s=s+L[i][k]*U[k][m];
  • L[i][m]=a[i][m]-s;
  • }
  • if (L[k][k]==0)
  • {
  • printf("\n\n* Un mineur nul ! => methode de LU non applicable\n\n");
  • system("PAUSE");main();
  • }
  • for (j=m+1;j<n;j++)
  • {
  • s=0;
  • for (k=0;k<m;k++) s=s+L[m][k]*U[k][j];
  • U[m][j]=(a[m][j]-s)/L[m][m];
  • }
  • }
  • // resolution
  • for(i=0;i<n;i++)
  • {
  • s=0;
  • for(j=0;j<i;j++) s=s+L[i][j]*y[j];
  • y[i]=(b[i]-s)/L[i][i];
  • }
  • for(i=n-1;i>=0;i--)
  • {
  • s=0;
  • for(j=i+1;j<n;j++)s=s+U[i][j]*x[j];
  • x[i]=(y[i]-s)/U[i][i];
  • }
  • printf("\n-------------- LU Crout -------------\n");
  • printf("\n * A = L * U \n");
  • printf("\n * La matrice L :");
  • aff_mat(L,n);
  • printf("\n * La matrice U :");
  • aff_mat(U,n);
  • printf("\n * La resolution donne :\n\n");
  • for (i=0;i<n;i++) printf(" X_%d = %f ;\n",i+1,x[i]);
  • }
  • // -------------------------------------------------------------
  • // Résolution Par décomposition Cholesky
  • // -------------------------------------------------------------
  • void cholesky(float a[19][19],float b[19],int n)
  • {
  • float L[19][19],Lt[19][19],x[19],y[19],s,p;int i,j,k;
  • // vérification de le symétrie
  • for (i=0;i<n;i++) for (j=0;j<n;j++)
  • if (a[i][j]!=a[j][i])
  • {
  • printf("\n\n * Non symetrique => methode de Cholesky non applicable\n\n");
  • system("PAUSE");main();
  • }
  • for (i=0;i<n;i++) for (j=0;j<n;j++) L[i][j]=0;
  • for (i=0;i<n;i++)
  • {
  • s=0;
  • for (k=0;k<i;k++) s=s+pow(L[i][k],2);
  • p=a[i][i]-s;
  • if (p<=0)
  • {
  • printf("\n\n * Non definie positive => methode de Cholesky non applicable\n\n");
  • system("PAUSE");main();
  • }
  • L[i][i]=sqrt(p);
  • for(j=i+1;j<n;j++)
  • {
  • s=0;
  • for (k=0;k<i;k++) s=s+L[i][k]*L[j][k];
  • L[j][i]=(a[j][i]-s)/L[i][i];
  • }
  • }
  • for (i=0;i<n;i++) for (j=0;j<n;j++) Lt[i][j]=L[j][i];
  • // resolution
  • for(i=0;i<n;i++)
  • {
  • s=0;
  • for(j=0;j<i;j++) s=s+L[i][j]*y[j];
  • y[i]=(b[i]-s)/L[i][i];
  • }
  • for(i=n-1;i>=0;i--)
  • {
  • s=0;
  • for(j=i+1;j<n;j++) s=s+Lt[i][j]*x[j];
  • x[i]=(y[i]-s)/Lt[i][i];
  • }
  • printf("\n--------------- Cholesky --------------\n");
  • printf("\n * A = L * Lt \n");
  • printf("\n * La matrice L :");
  • aff_mat(L,n);
  • printf("\n * La matrice Lt :");
  • aff_mat(Lt,n);
  • printf("\n * La resolution donne :\n\n");
  • for (i=0;i<n;i++) printf(" X_%d = %f ;\n",i+1,x[i]);
  • }
  • // -------------------------------------------------------------
  • // Résolution Par Jacobie
  • // -------------------------------------------------------------
  • void jacobie(float a[19][19],float b[19],int n)
  • {
  • float x[19],x1[19],x2[19],s,eps=1e-4;int i,j,k,iter=0;
  • //initialisation du vecteur
  • printf("\n * Veuillez initialisez le vecteur solution : \n\n");
  • for (i=0;i<n;i++) {printf(" X(0)[%d]= ",i+1);scanf("%f",&x1[i]);}
  • do
  • {
  • for(i=0;i<n;i++)
  • {
  • s=0;
  • for (j=0;j<n;j++) if (i!=j) s=s+a[i][j]*x1[j];
  • x2[i]=(b[i]-s)/a[i][i];
  • }
  • for (k=0;k<n;k++) {x[k]=fabs(x1[k]-x2[k]);x1[k]=x2[k];}
  • iter++;
  • }
  • while (norme(x,n)>eps) ;
  • printf("\n-------------- Jacobie -------------\n");
  • printf("\n * La resolution donne :\n\n");
  • for (i=0;i<n;i++) printf(" X_%d = %f ;\n",i+1,x2[i]);
  • printf("\n * Apres %d iteration, precision 10^-4. \n",iter);
  • }
  • // -------------------------------------------------------------
  • // Résolution Par Gauss-Seidel
  • // -------------------------------------------------------------
  • void gauss_seidel(float a[19][19],float b[19],int n)
  • {
  • float x[19],x1[19],x2[19],s,p,eps=1e-4;int i,j,k,iter=0;
  • //initialisation du vecteur
  • printf("\n * Veuillez initialisez le vecteur solution : \n\n");
  • for (i=0;i<n;i++) {printf(" X(0)[%d]= ",i+1);scanf("%f",&x1[i]);}
  • do
  • {
  • for(i=0;i<n;i++)
  • {
  • s=0;
  • p=0;
  • for (j=i+1;j<n;j++) s=s+a[i][j]*x1[j];
  • for (j=0;j<i;j++) p=p+a[i][j]*x2[j];
  • x2[i]=(b[i]-s-p)/a[i][i];
  • }
  • for (k=0;k<n;k++) {x[k]=fabs(x1[k]-x2[k]);x1[k]=x2[k];}
  • iter++;
  • }
  • while (norme(x,n)>eps) ;
  • printf("\n-------------- Gauss-Saidel -------------\n");
  • printf("\n * La resolution donne :\n\n");
  • for (i=0;i<n;i++) printf(" X_%d = %f ;\n",i+1,x2[i]);
  • printf("\n * Apres %d iteration, precision 10^-4. \n",iter);
  • }
  • // Calcul norme vecteur
  • float norme(float x[19],int n)
  • {
  • float ref;int i;
  • ref=0;
  • for(i=0;i<n;i++) if (x[i]>ref) ref=x[i];
  • return(ref);
  • }
  • // fonction de remplissage
  • void remplissage(float a[19][19],float b[19],int n)
  • {
  • int i,j;
  • printf("\n * La matrice A:\n\n");
  • for (i=0;i<n;i++)
  • {
  • printf(" | ");
  • for (j=0;j<n;j++) scanf("%f",&a[i][j]);
  • }
  • printf("\n * Le vecteur B:\n\n");
  • for(i=0;i<n;i++)
  • {
  • printf(" | ");
  • scanf("%f",&b[i]);
  • }
  • }
  • // fonction d'affichage système
  • void aff_syst(float a[19][19],float b[19],int n)
  • {
  • int i,j;
  • printf("\n\n");
  • for (i=0;i<n;i++)
  • {
  • printf(" [");
  • for (j=0;j<n;j++)
  • {
  • printf(" %.4f ",a[i][j]);
  • }
  • printf("] [ %.4f ]",b[i]);
  • printf("\n");
  • }
  • }
  • // fonction d'affichage matrice
  • void aff_mat(float a[19][19],int n)
  • {
  • int i,j;
  • printf("\n\n");
  • for (i=0;i<n;i++)
  • {
  • printf(" [");
  • for (j=0;j<n;j++)
  • {
  • printf(" %.4f ",a[i][j]);
  • }
  • printf("]\n");
  • }
  • }
  • // Mettre à Zero les elements qui doivent etre des zéro
  • void zero(float a[19][19],float b[19],int n)
  • {
  • int i,j;float eps=1e-4;
  • for(i=0;i<n;i++)
  • {
  • for (j=0;j<n;j++) if (fabs(a[i][j])<eps) a[i][j]=0;
  • if (fabs(b[i])<eps) b[i]=0;
  • }
  • }

/* ========================================================================== */
/*   TP informatique SF2A G7 Khelifi Walid 2006/2007                                                 */
/*   Ecole nationale polytechnique, El Harrach Alger                          */
/*   Description : Resolution des systèmes                                    */
/* ========================================================================== */

/*
Résolution de A x = b par :
           
    Cramer , Inversion , Gauss , Gauss pivot partiel , 
    Gauss pivot total , Jordan , Décomposition LU croot , 
    LU doolittle , Cholseky , 
    et les methodes itératives de Jacobie et Gauss-Seidel.
*/

#include <stdio.h>
#include <math.h>

void cramer(float [][],float [],int);
void inversion(float [][],float [],int);
float det(float [][],int);
void comatrices(float [][],float [][],int,int,int);
void gauss(float [][],float [],int);

void gauss_pivot_partiel(float [][],float [],int);
void gauss_pivot_total(float [][],float [],int);
void jordan(float [][],float [],int);
void LU_doolittle(float [][],float [],int);

void LU_crout(float [][],float [],int);
void cholesky(float [][],float [],int);
void jacobie(float [][],float [],int);

void gauss_seidel(float [][],float [],int);
float norme(float [],int);

void remplissage(float [][],float [],int);
void aff_syst(float [][],float [],int);
void aff_mat(float [][],int);
void zero(float [][],float [],int);

main()
{
float a[19][19],b[19];int n,i,j; char valider;

// choix de la methode 
printf("\n *******************************************************\n");    
printf(" *                                                     *\n");      
printf(" *           Resolution de A x = B                     *\n");    
printf(" *                                                     *\n");      
printf(" *******************************************************\n");    
printf(" *                                                     *\n");      
printf(" *   Choix de la methode  :                            *\n"); 
printf(" *                                                     *\n");      
printf(" *      A => Cramer                                    *\n");
printf(" *      B => Inversion                                 *\n");
printf(" *      C => Gauss                                     *\n");
printf(" *      D => Gauss pivot partiel                       *\n");
printf(" *      E => Gauss pivot total                         *\n");
printf(" *      F => Jordan                                    *\n");
printf(" *      G => LU Doolittle                              *\n");
printf(" *      H => LU Crout                                  *\n");
printf(" *      I => Cholesky                                  *\n");
printf(" *      J => Jacobie                                   *\n");
printf(" *      K => Gauss-Seidel                              *\n");
printf(" *                                                     *\n");    
printf(" *******************************************************\n");                  
printf(" *                                                     *\n");    
printf(" *    X => E X I T                                     *\n");
printf(" *                                                     *\n");    
printf(" *******************************************************\n\n");                  

reprendre_choix:

printf("------ => donner votre choix ------ : ");
scanf("%s",&valider);

void remplir()
{
printf("\n\n * Nombre d'equation-inconues : \n\n * N = ");
scanf("%d",&n);  
remplissage(a,b,n);
printf("\n\n * Le systeme est : ");
aff_syst(a,b,n);
}

switch(valider)
{
case 'A'  : remplir();cramer(a,b,n);                break;
case 'B'  : remplir();inversion(a,b,n);             break;
case 'C'  : remplir();gauss(a,b,n);                 break;
case 'D'  : remplir();gauss_pivot_partiel(a,b,n);   break;
case 'E'  : remplir();gauss_pivot_total(a,b,n);     break;
case 'F'  : remplir();jordan(a,b,n);                break;
case 'G'  : remplir();LU_doolittle(a,b,n);          break; 
case 'H'  : remplir();LU_crout(a,b,n);              break; 
case 'I'  : remplir();cholesky(a,b,n);              break;
case 'J'  : remplir();jacobie(a,b,n);               break;
case 'K'  : remplir();gauss_seidel(a,b,n);          break;
case 'X'  : printf("\nProgramme interompu par l'utilisateur.......\n\n"); 
            system("PAUSE");exit(0);                break; 
default   : goto reprendre_choix;
}
printf("\n");
system("PAUSE");
main();
}

// -------------------------------------------------------------
//  Fonctions utiles pour la résolution par Cramer et inversion
// -------------------------------------------------------------

// calcul du determinant

float det(float a[19][19],int n)
{
int k,j;float c[19][19],s;

k=n-1;

if(n==0) return(1);

s=0;
for(j=0;j<n;j++)
{
comatrices(a,c,k,j,n);
s=s+pow(-1,k+j)*a[k][j]*det(c,k);
}
return(s);
}

// calcul des comatrices

void comatrices(float a[19][19],float c[19][19],int i,int j,int n)
{
int l,k;
for(l=0;l<n;l++) for(k=0;k<n;k++)
{
if ((l<i)&&(k<j)) c[l][k]=a[l][k];
if ((l>i)&&(k<j)) c[l-1][k]=a[l][k];
if ((l<i)&&(k>j)) c[l][k-1]=a[l][k];
if ((l>i)&&(k>j)) c[l-1][k-1]=a[l][k];
}
}

// -------------------------------------------------------------
//                  Résolution Par Cramer
// -------------------------------------------------------------

void cramer(float a[19][19],float b[19],int n)
{
float A[19][19],x[19],deter;int i,j,k;

deter=det(a,n);

if (deter==0) 
{
printf("\n => Determinant nul, pas de solutions \n\n");
system("PAUSE");main(); 
}

for(j=0;j<n;j++) 
{
for(k=0;k<n;k++) 
{
if (k==j) for(i=0;i<n;i++) A[i][k]=b[i];
else for(i=0;i<n;i++) A[i][k]=a[i][k];
}                  
x[j]=det(A,n)/deter;
}
printf("\n-------------- Cramer -------------\n");
printf("\n * Le determiant du systeme : %f \n",deter);
printf("\n * La resolution donne :\n\n");
for (i=0;i<n;i++) printf(" X_%d =  %f  ;\n",i+1,x[i]);
}

// -------------------------------------------------------------
//                  Résolution Par Inversion
// -------------------------------------------------------------

void inversion(float a[19][19],float b[19],int n)
{
float c[19][19],comat[19][19],a_1[19][19],x[19],deter,s;int i,j;

deter=det(a,n);

if (deter==0) 
{
printf("\n => Matrice non inversible, pas de solutions \n\n");
system("PAUSE");main(); 
}

for(i=0;i<n;i++) for(j=0;j<n;j++)
{
comatrices(a,c,i,j,n);
comat[i][j]=(pow(-1,i+j)/deter)*(det(c,n-1));
}

// transposée
for(i=0;i<n;i++) for(j=0;j<n;j++)
a_1[i][j]=comat[j][i];

//résolution
for(i=0;i<n;i++) 
{s=0;
for(j=0;j<n;j++) s=s+a_1[i][j]*b[j];
x[i]=s;
}

printf("\n-------------- Inversion -------------\n");
printf("\n * La matrice inverse A^-1 :");
aff_mat(a_1,n);
printf("\n * La resolution donne :\n\n");
for (i=0;i<n;i++) printf(" X_%d =  %f  ;\n",i+1,x[i]);
}

// -------------------------------------------------------------
//                  Résolution Par Gauss
// -------------------------------------------------------------

void gauss(float a[19][19],float b[19],int n)

{
float x[19],p,s;int i,j,k;

for(k=0;k<n-1;k++)
{
if (a[k][k]==0) 
{
printf("\n\n * Un pivot nul ! => methode de Gauss non applicable\n\n");
system("PAUSE");main();
}                 

//réduction
for(i=k+1;i<n;i++)
{
 p=a[i][k]/a[k][k];
 for (j=k;j<n;j++) a[i][j]=a[i][j]-p*a[k][j];
 b[i]=b[i]-p*b[k];
}
}

//Résolution
for(i=n-1;i>=0;i--)
{
s=0;   
for(j=i+1;j<n;j++)s=s+a[i][j]*x[j];                    
x[i]=(b[i]-s)/a[i][i];
}
zero(a,b,n);
printf("\n-------------- Gauss -------------\n");
printf("\n * La matrice reduite :");
aff_syst(a,b,n);
printf("\n * La resolution donne :\n\n");
for (i=0;i<n;i++) printf(" X_%d =  %f  ;\n",i+1,x[i]);
}

// -------------------------------------------------------------
//              Résolution Par Gauss pivot pariel
// -------------------------------------------------------------

void gauss_pivot_partiel(float a[19][19],float b[19],int n)

{
float x[19],p,s,ref,temp;int i,j,k,ligne;     

for(k=0;k<n-1;k++)
{
// max pour le pivot partiel                
ref=0;
for(i=k;i<n;i++) if(fabs(a[i][k])>ref) {ref=fabs(a[i][k]);ligne=i;}

// pivotations
for(j=k;j<n;j++) 
{temp=a[k][j]; a[k][j]=a[ligne][j] ;a[ligne][j]=temp;}

temp=b[k]; b[k]=b[ligne]; b[ligne]=temp;

if (a[k][k]==0) 
{
printf("\n\n* Un pivot nul ! => methode de Gauss pivot partiel non applicable\n\n");
system("PAUSE");main();
}                 


//réduction                
for(i=k+1;i<n;i++)
{
 p=a[i][k]/a[k][k];
 for (j=k;j<n;j++) a[i][j]=a[i][j]-p*a[k][j];
 b[i]=b[i]-p*b[k];
}
}

//Résolution
for(i=n-1;i>=0;i--)
{
s=0;   
for(j=i+1;j<n;j++) s=s+a[i][j]*x[j];                    
x[i]=(b[i]-s)/a[i][i];
}
zero(a,b,n);
printf("\n-------- Gauss avec pivot partiel --------\n");
printf("\n * La matrice reduite :");
aff_syst(a,b,n);
printf("\n * La resolution donne :\n\n");
for (i=0;i<n;i++) printf(" X_%d =  %f  ;\n",i+1,x[i]);
printf("\n");
}

// -------------------------------------------------------------
//              Résolution Par Gauss pivot total
// -------------------------------------------------------------

void gauss_pivot_total(float a[19][19],float b[19],int n)

{
float x[19],p,s,ref,temp;int i,j,k,ligne,colonne,pivot_sol[19],temps;

// vecteur de pivotation des solutions
for(i=0;i<n;i++) pivot_sol[i]=i;

for(k=0;k<n-1;k++)
{                  
// max pour le pivot total                
ref=0;
for(i=k;i<n;i++) for (j=k;j<n;j++)
if(fabs(a[i][j])>ref) {ref=fabs(a[i][j]);ligne=i;colonne=j;}

// pivotations
for(j=k;j<n;j++) {temp=a[k][j]; a[k][j]=a[ligne][j] ;a[ligne][j]=temp;}

temp=b[k]; b[k]=b[ligne]; b[ligne]=temp;

for(i=0;i<n;i++) {temp=a[i][k]; a[i][k]=a[i][colonne] ;a[i][colonne]=temp;}

// remplissage du vecteur accordé aux pivotations 
temps=pivot_sol[k];
pivot_sol[k]=pivot_sol[colonne];
pivot_sol[colonne]=temps;

if (a[k][k]==0) 
{
printf("\n\n * Un pivot nul ! => methode de Gauss pivot total non applicable\n\n");
system("PAUSE");main();
}                 

//réduction                
for(i=k+1;i<n;i++)
{
 p=a[i][k]/a[k][k];
 for (j=k;j<n;j++) a[i][j]=a[i][j]-p*a[k][j];
 b[i]=b[i]-p*b[k];
}
}

// Résolution
for(i=n-1;i>=0;i--)
{   
s=0;    
for(j=i+1;j<n;j++)s=s+a[i][j]*b[j];                    
b[i]=(b[i]-s)/a[i][i];
}

// pivotation des solutions
for(i=0;i<n;i++) x[pivot_sol[i]]=b[i];

zero(a,b,n);
printf("\n--------- Gauss avec pivot total ---------\n");
printf("\n * La matrice reduite :");
aff_syst(a,b,n);
printf("\n * La resolution donne :\n\n");
for (i=0;i<n;i++) printf(" X_%d =  %f  ;\n",i+1,x[i]);
printf("\n");
}

// -------------------------------------------------------------
//                  Résolution Par Jordan
// -------------------------------------------------------------

void jordan(float a[19][19],float b[19],int n)

{
float p;int i,j,k;

for(k=0;k<n;k++)
{
if (a[k][k]==0)
{
printf("\n\n * Un pivot nul ! => methode de Jordan non applicable\n\n");
system("PAUSE");main();
}                 

p=a[k][k]; 

//normalisation               
for (j=k;j<n;j++) a[k][j]=a[k][j]/p;
b[k]=b[k]/p;

//réduction                
for(i=0;i<n;i++)
{
 if (i!=k)
 {
  p=a[i][k];                
  for (j=k;j<n;j++) a[i][j]=a[i][j]-p*a[k][j];
  b[i]=b[i]-p*b[k];
 }
}
}
zero(a,b,n);
printf("\n-------------- Jordan -------------\n");
printf("\n * La matrice reduite :");
aff_syst(a,b,n);
printf("\n * La resolution donne :\n\n");
for(i=0;i<n;i++) printf(" X_%d =  %f  ;\n",i+1,b[i]);
printf("\n");
}

// -------------------------------------------------------------
//       Résolution Par décomposition LU Doolittle
// -------------------------------------------------------------

void LU_doolittle(float a[19][19],float b[19],int n)

{
float L[19][19],U[19][19],x[19],y[19],s;int i,j,k,m;

for (i=0;i<n;i++) for (j=0;j<n;j++) 
{
if(i==j) L[i][j]=1; else L[i][j]=0;
U[i][j]=0;
}

for (m=0;m<n;m++)
{       
for (j=m;j<n;j++)   
{
s=0;     
for (k=0;k<m;k++) s=s+L[m][k]*U[k][j];     
U[m][j]=a[m][j]-s;
}
if (U[k][k]==0) 
{
printf("\n\n * Un mineur nul ! => methode de LU non applicable\n\n");
system("PAUSE");main();
}                 

for (i=m+1;i<n;i++) 
{
s=0;   
for (k=0;k<m;k++) s=s+L[i][k]*U[k][m];    
L[i][m]=(a[i][m]-s)/U[m][m];
}
}

// resolution
for(i=0;i<n;i++)
{
s=0;                      
for(j=0;j<i;j++) s=s+L[i][j]*y[j];                    
y[i]=(b[i]-s)/L[i][i];
}

for(i=n-1;i>=0;i--)
{
s=0;                      
for(j=i+1;j<n;j++)s=s+U[i][j]*x[j];                    
x[i]=(y[i]-s)/U[i][i];
}

printf("\n------------ LU Doolittle -----------\n");
printf("\n * A = L * U \n");
printf("\n * La matrice L :");
aff_mat(L,n);
printf("\n * La matrice U :");
aff_mat(U,n);
printf("\n * La resolution donne :\n\n");
for (i=0;i<n;i++) printf(" X_%d =  %f  ;\n",i+1,x[i]);
}

// -------------------------------------------------------------
//       Résolution Par décomposition LU Crout
// -------------------------------------------------------------

void LU_crout(float a[19][19],float b[19],int n)

{
float L[19][19],U[19][19],x[19],y[19],s;int i,j,k,m;

for (i=0;i<n;i++) for (j=0;j<n;j++) 
{
if(i==j) U[i][j]=1; else U[i][j]=0;
L[i][j]=0;
}

for (m=0;m<n;m++)
{    
for (i=m;i<n;i++) 
{
s=0;    
for (k=0;k<m;k++) s=s+L[i][k]*U[k][m];    
L[i][m]=a[i][m]-s;
}

if (L[k][k]==0) 
{
printf("\n\n* Un mineur nul ! => methode de LU non applicable\n\n");
system("PAUSE");main();
}                 

for (j=m+1;j<n;j++)   
{
s=0;    
for (k=0;k<m;k++) s=s+L[m][k]*U[k][j];     
U[m][j]=(a[m][j]-s)/L[m][m];
}
}

// resolution
for(i=0;i<n;i++)
{
s=0;                      
for(j=0;j<i;j++) s=s+L[i][j]*y[j];                    
y[i]=(b[i]-s)/L[i][i];
}

for(i=n-1;i>=0;i--)
{
s=0;                      
for(j=i+1;j<n;j++)s=s+U[i][j]*x[j];                    
x[i]=(y[i]-s)/U[i][i];
}

printf("\n-------------- LU Crout -------------\n");
printf("\n * A = L * U \n");
printf("\n * La matrice L :");
aff_mat(L,n);
printf("\n * La matrice U :");
aff_mat(U,n);
printf("\n * La resolution donne :\n\n");
for (i=0;i<n;i++) printf(" X_%d =  %f  ;\n",i+1,x[i]);
}

// -------------------------------------------------------------
//       Résolution Par décomposition Cholesky
// -------------------------------------------------------------

void cholesky(float a[19][19],float b[19],int n)
{
float L[19][19],Lt[19][19],x[19],y[19],s,p;int i,j,k;

// vérification de le symétrie
for (i=0;i<n;i++) for (j=0;j<n;j++) 
if (a[i][j]!=a[j][i])
{
printf("\n\n * Non symetrique => methode de Cholesky non applicable\n\n");
system("PAUSE");main();
}

for (i=0;i<n;i++) for (j=0;j<n;j++) L[i][j]=0;

for (i=0;i<n;i++) 
{
s=0;
for (k=0;k<i;k++) s=s+pow(L[i][k],2);
p=a[i][i]-s;

if (p<=0)
{
printf("\n\n * Non definie positive => methode de Cholesky non applicable\n\n");
system("PAUSE");main();
}

L[i][i]=sqrt(p);

for(j=i+1;j<n;j++)
{
s=0;
for (k=0;k<i;k++) s=s+L[i][k]*L[j][k];
L[j][i]=(a[j][i]-s)/L[i][i];
}
}

for (i=0;i<n;i++) for (j=0;j<n;j++) Lt[i][j]=L[j][i];

// resolution
for(i=0;i<n;i++)
{
s=0;                      
for(j=0;j<i;j++) s=s+L[i][j]*y[j];                    
y[i]=(b[i]-s)/L[i][i];
}

for(i=n-1;i>=0;i--)
{
s=0;                      
for(j=i+1;j<n;j++) s=s+Lt[i][j]*x[j];                    
x[i]=(y[i]-s)/Lt[i][i];
}

printf("\n--------------- Cholesky --------------\n");
printf("\n * A = L * Lt \n");
printf("\n * La matrice L :");
aff_mat(L,n);
printf("\n * La matrice Lt :");
aff_mat(Lt,n);
printf("\n * La resolution donne :\n\n");
for (i=0;i<n;i++) printf(" X_%d =  %f  ;\n",i+1,x[i]);
}

// -------------------------------------------------------------
//         Résolution Par Jacobie
// -------------------------------------------------------------

void jacobie(float a[19][19],float b[19],int n)
{
float x[19],x1[19],x2[19],s,eps=1e-4;int i,j,k,iter=0;     

//initialisation du vecteur
printf("\n * Veuillez initialisez le vecteur solution : \n\n");
for (i=0;i<n;i++) {printf(" X(0)[%d]= ",i+1);scanf("%f",&x1[i]);} 

do
{      
for(i=0;i<n;i++)
{
s=0;
for (j=0;j<n;j++) if (i!=j) s=s+a[i][j]*x1[j];
x2[i]=(b[i]-s)/a[i][i];
}
for (k=0;k<n;k++) {x[k]=fabs(x1[k]-x2[k]);x1[k]=x2[k];}  
 
iter++;
}
while (norme(x,n)>eps) ;

printf("\n-------------- Jacobie -------------\n");
printf("\n * La resolution donne :\n\n");
for (i=0;i<n;i++) printf(" X_%d =  %f  ;\n",i+1,x2[i]);
printf("\n * Apres %d iteration, precision 10^-4.  \n",iter);
}

// -------------------------------------------------------------
//        Résolution Par Gauss-Seidel
// -------------------------------------------------------------

void gauss_seidel(float a[19][19],float b[19],int n)
{
float x[19],x1[19],x2[19],s,p,eps=1e-4;int i,j,k,iter=0;     

//initialisation du vecteur
printf("\n * Veuillez initialisez le vecteur solution : \n\n");
for (i=0;i<n;i++) {printf(" X(0)[%d]= ",i+1);scanf("%f",&x1[i]);} 

do
{  
for(i=0;i<n;i++)
{
s=0;
p=0;
for (j=i+1;j<n;j++) s=s+a[i][j]*x1[j];
for (j=0;j<i;j++) p=p+a[i][j]*x2[j];
x2[i]=(b[i]-s-p)/a[i][i];
}
for (k=0;k<n;k++) {x[k]=fabs(x1[k]-x2[k]);x1[k]=x2[k];}  

iter++;
}
while (norme(x,n)>eps) ;

printf("\n-------------- Gauss-Saidel -------------\n");
printf("\n * La resolution donne :\n\n");
for (i=0;i<n;i++) printf(" X_%d =  %f  ;\n",i+1,x2[i]);
printf("\n * Apres %d iteration, precision 10^-4.  \n",iter);
}

// Calcul norme vecteur

float norme(float x[19],int n)
{
float ref;int i;
ref=0;
for(i=0;i<n;i++) if (x[i]>ref) ref=x[i];
return(ref);
}

// fonction de remplissage

void remplissage(float a[19][19],float b[19],int n)
{
int i,j;     
printf("\n * La matrice A:\n\n");
for (i=0;i<n;i++) 
{
printf(" | ");
for (j=0;j<n;j++) scanf("%f",&a[i][j]);
}
printf("\n * Le vecteur B:\n\n");
for(i=0;i<n;i++) 
{
printf(" | ");
scanf("%f",&b[i]);
}
}

// fonction d'affichage système

void aff_syst(float a[19][19],float b[19],int n)
{
int i,j;     
printf("\n\n");
for (i=0;i<n;i++)
{
printf(" [");
for (j=0;j<n;j++)
{
printf("  %.4f  ",a[i][j]);
}
printf("] [  %.4f  ]",b[i]);
printf("\n");
}
}

// fonction d'affichage matrice

void aff_mat(float a[19][19],int n)
{
int i,j;     
printf("\n\n");
for (i=0;i<n;i++)
{
printf(" [");
for (j=0;j<n;j++)
{
printf("  %.4f  ",a[i][j]);
}
printf("]\n");
}
}

// Mettre à Zero les elements qui doivent etre des zéro

void zero(float a[19][19],float b[19],int n)
{
int i,j;float eps=1e-4;
for(i=0;i<n;i++)
{
for (j=0;j<n;j++) if (fabs(a[i][j])<eps) a[i][j]=0;      
if (fabs(b[i])<eps) b[i]=0;
}
}



 Historique

23 février 2007 10:20:15 :
.
24 février 2007 18:17:19 :
.
26 février 2007 23:49:30 :
+ Décomposition LU
26 février 2007 23:54:14 :
.
01 mars 2007 21:45:27 :
.
07 mars 2007 19:03:08 :
.
08 mars 2007 17:45:59 :
.
08 mars 2007 22:26:16 :
.
23 mars 2007 19:29:28 :
.
05 juillet 2007 22:02:39 :
revue
22 novembre 2008 18:45:23 :
,

 Sources de la même categorie

Source avec Zip TRANSFORMER UN ENTIER EN DEUX NOMBRES COMPOSÉ DES MEMES CHIF... par thebroyeur
CALCULE LOG(X) par tagtog
Source avec Zip Source avec une capture ALGORITHME DE TRI D'UN TABLEAU PAR ORDRE CROISSANT OU DÉCROI... par Thuzhen
Source avec une capture CALCUL DE VARIANCE par Minilogus
Source avec une capture GÉNÉRATEUR DE CLÉS SUR 26 DIGITS AU FORMAT HEXADÉCIMAL par besilent

 Sources en rapport avec celle ci

INVERSION, CRAMER ,GAUSS, GAUSS PIVOT PARTIEL, GAUSS PIVOT T... par ahmedkolsi
Source avec Zip Source avec une capture QUADRIQUES ET REDUCTION DE GAUSS par JCDjcd
Source avec Zip Source avec une capture UTILITAIRE DE RESOLUTION DES SYSTEMES LINEAIRES par karamimed
GAUSS-JORDAN SUR DES MATRICES CARRÉS par Maxou95
ALGORITHME DE GAUSS-JORDAN par hasnaoui_karim

Commentaires et avis

Commentaire de Arnaud16022 le 26/02/2007 18:04:35

Pas de source ....

Commentaire de tou77 le 21/04/2007 11:53:44

je suis un nouveau ds la prog.dev c++  
svp comment je peut telecharger cette source

Commentaire de mpo007 le 19/11/2007 00:01:02

salut en fait en ce qui concerne cholesky les deux parties de
1) la verification que la matrice est symetrique
2) qu'elle est positif
ces deux teste que t'as fait dans ta source ne sont pas juste c'est Faut,même si l'utilisatateur n'entre pas une matrice clairement symetrique.tu dois tester si tr(tr(A)*A)=C en posant C=Tr(A)*A.
à part ça le code est ni au moins bien je donnerai 6/10

Commentaire de SARRASINS le 01/12/2007 16:09:55

c' est impecable

Commentaire de theg56 le 15/12/2007 23:00:39 7/10

il me semble qu'il y est des erreurs de mémoire notamment dans la fonction gauss

Commentaire de theg56 le 15/12/2007 23:57:52

autan pour moi, je travaillais avec des size_t
bon boulot !!

Commentaire de hissou le 28/01/2008 23:35:02

est ce que c possible de me donner la solution d'un systeme d'eqautions lineaires AX=B a l'aide de la methode de Gauss seulement en C. c'est urgent  

Commentaire de theg56 le 29/01/2008 12:01:28

c'est déja du c

Commentaire de zizou23 le 14/03/2008 02:57:43

merci pour cette idée pour m'aider a engager en Tp mais c tu veux ,je veux la solution avec c++builder,....j'attend ta reponse,MERCI

Commentaire de Uarel le 14/12/2008 14:30:57 10/10

Merci grandement ça m'a énormément aidé !!

Commentaire de cresuscresus le 14/12/2008 19:06:33

Pas de quoi, heureux d'avoir pu t'être utile

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

algorithme de gauss et decomposition LU [ par speedamine ] bonjour a tous.je voudrai avoir des algorithmes ,ecrits en borland pascal,suivants:methode de gauss ordinaire pour la resolution d'un systeme .la deco Est ce que quelqun a lu le manuel de reférence visual C++ .net [ par Poolman ] Voila, j'aimerais accéder aux fichiers sourcesde cet ouvrage sans l'acheter, c'est pourquoi, si quelqun a le MANUEL DE RÉFÉRENCE MICROSOFT VISUAL C++ un tableau lu par tout les fichier [ par Adeon ] Salut !Je suis en train de fabriquer un jeu.Dans ce jeu, un tablau 2 dimention defini chaque case de la map par une valeur int. Cela s'appelle une mat importer une librairie [ par touny23 ] bon alors voila , notre cher prof d info nous a demander d utiliser&nbsp;la librairie qu il nous a fournit.en l occurence libmat.a ou libmat.h cette l import librairie (bis) [ par touny23 ] bon j arrive a importer une librairie en C++ en faisan dans le fichier .h: #ifndef _MY_FILE#define _MY_FILE#ifdef __cplusplusextern "C" {#endifvoid __ [.net c++] writefile et readfile [ par stgi02 ] bonsoir,je prog sur visual studio.net c++quand on utilise readfile ou WriteFile en mode overllaped j'ai lu dans MSDN que l'operation peux retourner av Activer une tabulation [ par julien_boss ] Bonjour, je sais que la question a déjà été posée mais la réponse n'était pas présente ^_^. Donc je la repose : j'ai créé des boutons de classe "edit" besion d' aide [ par ccfacile ] j'ai  fais un programme sur devc++ pour resoudre l'equation matricielle : A*X=B ,  je vois pas ou est elle euruer ? est ce que vous pouvez aidez SVP, Classique code : conversion decimale=>binaire [ par darkwhite ] salut à tous,Comme un nombre incalculable de gens je dois faire le desormais classique code : convertir du binaire en decimale. Pour ma part je l'ai e gauss en pascal "Tres Urgent " [ par islem2007 ] Svp je voudrais ecrire en pascal le programme correspondant a la methode de gauss pour la matrice suivante :On considere la matrice An=(ai,j)&lt;=i,j&


Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Mars 2010
LMMJVSD
1234567
891011121314
15161718192021
22232425262728
293031    

Consulter la suite du CalendriCode

Photothèque

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,780 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales