CLASSES DE MATRICES (CARRÉES) DYNAMIQUES ET SES UTILISATIONS MATHÉMATIQUES

Messages postés
127
Date d'inscription
mardi 23 août 2005
Statut
Membre
Dernière intervention
9 mai 2011
- - Dernière réponse : sinyour
Messages postés
2
Date d'inscription
samedi 8 janvier 2011
Statut
Membre
Dernière intervention
8 janvier 2011
- 8 janv. 2011 à 11:57
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.

https://codes-sources.commentcamarche.net/source/34270-classes-de-matrices-carrees-dynamiques-et-ses-utilisations-mathematiques

Afficher la suite 
sinyour
Messages postés
2
Date d'inscription
samedi 8 janvier 2011
Statut
Membre
Dernière intervention
8 janvier 2011
-
salut les qui p je besoin ton éd mon programme et compilé dans DevC++ me j'ai un problème sur la L'inverse d'une matrice.
- Division matriciel.
vois-se mon programme
#include <stdio.h> /* pour les entrer/sortie... */
#include <stdlib.h> /* pour les allocations dynamique... */
#include <string.h> /* pour les chaine de caracter */
#include <math.h> /* pour les fonction de mathimatique... */
/* Les prototypes de fonctions utilisé */
int Menu ( void );
int Sous_Menu ( int );
float** Allocate_Mat_Memory ( int, int );
void Free_Mat_Memory ( float**, int );
void Affiche_Vecteur ( float*, int );
void Affiche_Mat ( float**, int, int );
void Saisi_Mat ( float**, int, int );
void Add_Soust_Mat ( char, float**, float** , int, int );
void Multi_Mat_Nbr ( float**, int, int, int );
float** Produit_Matriciel ( float**, float**, int, int, int );
float** Sous_Mat_Det ( float**, int, int , int );
float Determinant ( float**, int);
void Comatrice ( float** , float** , int );
float** Inverse_Matrice ( float**, int );
float** Division_Matriciel( float**, float**, int, int );

void Transpose_Mat ( float**, float**, int, int );
float** Compactage ( float**, int, int );
void Trie_Mat_Croissant ( float**, int, int );
void Trie_Mat_Decroissant ( float**, int, int );
void Max_Ligne ( float**, int, int );
void Max_Colonne ( float**, int, int );
void Extraction_Sous_Mat ( float**, int, int, int, int );

/***************** Fonction Praincipale: main() *****************/

/* Le type de retour de main est un int, avec le compileteur GCC que j'utilise*/

int main(int argc, char *argv[])
{ int choixMenu, continuer = 1;
float **matrice1, **matrice2;
int N,M;

do
{
choixMenu = Menu();

switch ( choixMenu )
{
case 0:
continuer = 0; /* On quitte la boucle do{ ... }while */
break;

case 11: /* La somme de deux matrices (Addition) */
{
puts("\n Donnez les dimmantions de matrices:\n");
puts("Nombre de lignes: "); scanf("%d", &N);
puts("Nombre de colonnes: "); scanf("%d", &M);

matrice1 = Allocate_Mat_Memory( N, M );
matrice2 = Allocate_Mat_Memory( N, M );

puts("\n Saisisez les valeurs de La 1ere matrice:\n");
Saisi_Mat( matrice1, N, M );
puts("La 1ere Matrice est:\n\n");
Affiche_Mat( matrice1, N, M );

puts("\n Saisisez les valeurs de La 2eme matrice:\n");
Saisi_Mat( matrice2, N, M );
puts("La 2eme Matrice est:\n\n");
Affiche_Mat( matrice2, N, M );

Add_Soust_Mat( '+', matrice1, matrice2, N, M ); // l'additon
Affiche_Mat( matrice1, N, M );

Free_Mat_Memory( matrice1, N ); // Liberer la memoire
Free_Mat_Memory( matrice2, N );
}
break;

case 12: /* La differance de matrices (Soustraction) */
{
puts("\n Donnez les dimmantions de matrices:\n");
puts("Nombre de lignes: "); scanf("%d", &N);
puts("Nombre de colonnes: "); scanf("%d", &M);

matrice1 = Allocate_Mat_Memory( N, M );
matrice2 = Allocate_Mat_Memory( N, M );

puts("\n Saisisez les valeurs de La 1ere matrice:\n");
Saisi_Mat( matrice1, N, M );
puts("La 1ere Matrice est:\n\n");
Affiche_Mat( matrice1, N, M );

puts("\n Saisisez les valeurs de La 2eme matrice:\n");
Saisi_Mat( matrice2, N, M );
puts("La 2eme Matrice est:\n\n");
Affiche_Mat( matrice2, N, M );

Add_Soust_Mat( '-', matrice1, matrice2, N, M ); // soustraction
Affiche_Mat( matrice1, N, M );

Free_Mat_Memory( matrice1, N );
Free_Mat_Memory( matrice2, N );
}
break;

case 13: /* Mutimplier une matrice par un nombre */
{
float nombre;

puts("\n Donnez les dimmantions de la matrice:\n");
puts("Nombre de lignes: "); scanf("%d", &N);
puts("Nombre de colonnes: "); scanf("%d", &M);

matrice1 = Allocate_Mat_Memory( N, M );

puts("\n Saisisez les valeurs de La matrice:\n");
Saisi_Mat(matrice1, N, M);
puts("Voici votre Matrice initiale:\n\n");
Affiche_Mat(matrice1, N, M);

printf("\n Donnez un nombre: ");
scanf("%f", &nombre);

printf("\nLa Matrice multiplier par %f est:\n\n", nombre);
Multi_Mat_Nbr( matrice1, nombre, N, M );
Affiche_Mat( matrice1, N, M );

Free_Mat_Memory(matrice1, N);
}
break;

case 14: /* Produit matriciel */
{
int P; // => nombre de colonnes de la 2eme matrice
float **matProduit;

printf("\n Les dimmantions de la 1ere matrice:\n");
printf("Nombre de lignes: "); scanf("%d", &N);
printf("Nombre de colonnes: "); scanf("%d", &M);

matrice1 = Allocate_Mat_Memory( N, M );

printf("\n Saisisez les valeurs de La 1ere matrice:\n");
Saisi_Mat( matrice1, N, M );
printf("La 1ere Matrice est:\n\n");
Affiche_Mat( matrice1, N, M );

printf("\n Les dimmantions de la 2eme matrice:\n");
printf("Nbr de lignes = %d (obligatoirement)\n", M);
printf("Nombre de colonnes: "); scanf("%d", &P);

matrice2 = Allocate_Mat_Memory( N, M );

printf("\n Saisisez les valeurs de La 2eme matrice:\n");
Saisi_Mat( matrice2, M, P );
printf("La 2eme Matrice est:\n\n");
Affiche_Mat( matrice2, M, P );

matProduit = Produit_Matriciel( matrice1, matrice2, N, M, P );

printf("\nLe Produit matriciel est:\n\n");
Affiche_Mat( matProduit, N, P );

Free_Mat_Memory( matrice1, N );
Free_Mat_Memory( matrice2, M );
Free_Mat_Memory( matProduit, N );
}
break;

case 15: /* Inverse d'une matrice */
{
printf("\n Donnez les dimmantions de la matrice (carrée):\n");
printf("Nombre de lignes == Nombre de colonnes : ");
scanf("%d", &N);

matrice1 = Allocate_Mat_Memory(N, N);

printf("\n Saisisez les valeurs de La matrice:\n");
Saisi_Mat( matrice1, N, N );
printf("Voici votre Matrice initiale:\n\n");
Affiche_Mat( matrice1, N, N );

matrice1 = Inverse_Matrice( matrice1, N );
/* si la fonction n'a pas retourné NULL, alors notre matrice1
à été inversé, on affiche: */
if( matrice1 != NULL )
{
Affiche_Mat( matrice1, N, N );
Free_Mat_Memory( matrice1, N );
}

}
break;

case 16: /* Division de deux matrices */
{
float **matDivision;

/* (N,M) : la dimantion de la matrice 1 */
/* (M,M) : la dimansion de la matrice 2 */

printf("\n Les dimmantions de la 1ere matrice:\n");
printf("Nombre de lignes: "); scanf("%d", &N);
printf("Nombre de colonnes: "); scanf("%d", &M);

matrice1 = Allocate_Mat_Memory( N, M );

printf("\n Saisisez les valeurs de La 1ere matrice:\n");
Saisi_Mat( matrice1, N, M );
printf("La 1ere Matrice est:\n\n");
Affiche_Mat( matrice1, N, M );

/* la dimmantion de la 2eme matrice (carré) doit être égal
au nombre de colonnes de la 1ere matrice */
printf("\n Les dimmantions de la 2eme matrice sont :\n"); printf("Nbr lignes Nbr colonnes %d (matrice carré)\n", M);

matrice2 = Allocate_Mat_Memory( M, M );

printf("\n Saisisez les valeurs de La 2eme matrice:\n");
Saisi_Mat( matrice2, M, M );
printf("La 2eme Matrice est:\n\n");
Affiche_Mat( matrice2, M, M );

matDivision = Division_Matriciel( matrice1, matrice2, N, M );

if( matDivision != NULL )
{
printf("\nLa Divistion des deux matrice donne :\n\n");
Affiche_Mat( matDivision, N, M ); // De taille (N,M)

Free_Mat_Memory( matDivision, N );
Free_Mat_Memory( matrice2, M );
}
else
printf("\nImpossible de faire la division...\n");

Free_Mat_Memory( matrice1, N );
}
break;

case 21: /* Transposer d'une matrice */
{
printf("\n Donnez les dimmantions de la matrice:\n");
printf("Nombre de lignes: "); scanf("%d", &N);
printf("Nombre de colonnes: "); scanf("%d", &M);

/* Attention au dimmentions de la matrice2 (la transposée),
le nbr de colonnes devien le nbr de ligne, et vice verça: */
matrice2 = Allocate_Mat_Memory( M, N );
matrice1 = Allocate_Mat_Memory( N, M );

printf("\n Saisisez les valeurs de La matrice:\n");
Saisi_Mat(matrice1, N, M);
printf("Voici votre Matrice initiale:\n\n");
Affiche_Mat(matrice1, N, M);

Transpose_Mat( matrice1, matrice2, N, M);
printf("\nLa matrice transposee est:\n\n");
Affiche_Mat( matrice2, M, N );

Free_Mat_Memory(matrice1, N);
Free_Mat_Memory(matrice2, M);
}
break;

case 22: /* Compactage d'une matrice */
{
printf("\n Donnez la dimmantion de votre matrice:\n");
printf("Nombre de lignes: "); scanf("%d", &N);
printf("Nombre de colonnes: "); scanf("%d", &M);

matrice1 = Allocate_Mat_Memory( N, M );

printf("\n Saisisez les valeurs de La matrice:\n");
Saisi_Mat( matrice1, N, M );
printf("Voici votre Matrice initiale:\n\n");
Affiche_Mat(matrice1, N, M);

matrice1 = Compactage( matrice1, N, M);
Affiche_Mat( matrice1, N, M );

Free_Mat_Memory( matrice1, N );
}
break;

case 23: /* Trier une matrice */
{
char choixOrdre;

do
{
printf("Entrer:\n D pour le trie Decroissant, Ou\n"
" C pour l'ordre Croissant (en majuscule):\n");
scanf("%c", &choixOrdre);
/*getchar() pour prendre le \n que lesse scanf() dans le stdin*/
getchar();
}
while( choixOrdre!='D' && choixOrdre!='C' );

printf("\n Donnez la dimmantion de votre matrice:\n");
printf("Nombre de lignes: "); scanf("%d", &N);
printf("Nombre de colonnes: "); scanf("%d", &M);

matrice1 = Allocate_Mat_Memory( N, M );

printf("\n Saisisez les valeurs de La matrice:\n");
Saisi_Mat( matrice1, N, M );
printf("Voici votre Matrice non trier:\n\n");
Affiche_Mat( matrice1, N, M );

if(choixOrdre == 'D')
Trie_Mat_Decroissant( matrice1, N, M );
else
Trie_Mat_Croissant( matrice1, N, M );

Affiche_Mat( matrice1, N, M );
Free_Mat_Memory( matrice1, N );
}
break;

case 24: /* Les élements maximum des lignes */
{
printf("\n Donnez la dimmantion de votre matrice:\n");
printf("Nombre de lignes: "); scanf("%d", &N);
printf("Nombre de colonnes: "); scanf("%d", &M);

matrice1 = Allocate_Mat_Memory( N, M );

printf("\n Saisisez les valeurs de La matrice:\n");
Saisi_Mat( matrice1, N, M );
printf("Voici votre Matrice:\n\n");
Affiche_Mat( matrice1, N, M );

Max_Ligne( matrice1, N, M );

Free_Mat_Memory( matrice1, N );
}
break;

case 25: /* Les élements maximum des colonnes */
{
printf("\n Donnez la dimmantion de votre matrice:\n");
printf("Nombre de lignes: "); scanf("%d", &N);
printf("Nombre de colonnes: "); scanf("%d", &M);

matrice1 = Allocate_Mat_Memory( N, M );

printf("\n Saisisez les valeurs de La matrice:\n");
Saisi_Mat( matrice1, N, M );
printf("Voici votre Matrice:\n\n");
Affiche_Mat( matrice1, N, M );

Max_Colonne( matrice1, N, M );

Free_Mat_Memory( matrice1, N );
}
break;

case 26: /* Extraction de sous matrices */
{
int sMat_N, sMat_M;

printf("\n Donnez la dimmantion de votre matrice:\n");
printf("Nombre de lignes: "); scanf("%d", &N);
printf("Nombre de colonnes: "); scanf("%d", &M);

matrice1 = Allocate_Mat_Memory( N, M );

printf("\n Saisisez les valeurs de La matrice:\n");
Saisi_Mat( matrice1, N, M );

printf("\n Donnez la dimmantion des sous matrices a extraire:\n");
printf("Nombre de lignes: ");
scanf("%d", &sMat_N);
printf("Nombre de colonnes: ");
scanf("%d", &sMat_M);

printf("Voici votre Matrice initial:\n\n");
Affiche_Mat( matrice1, N, M );

printf("Voici touts les sous matrices possible:\n\n");
Extraction_Sous_Mat( matrice1, N, M, sMat_N, sMat_M );

Free_Mat_Memory( matrice1, N );
}
break;
}
}
while( continuer );

return 0;
}

/*********************** Les Fonctions : ***********************/

/* Cette fonction propose un menu tout simple */
int Menu(void)
{
int choix;

printf("\n*** MENU: ***\n 1. Operations arithmetiques\n"
" 2. Autres operations\n 3. Quitter\n");

do
{
printf("Choisissez 1 ou 2 ou 3 : ");
scanf("%d", &choix);
}
while( (choix!=1) && (choix!=2) && (choix!=3) );

/* si le choix est 3 on quitte la fonction en retournant 0 */
if ( choix == 3 )
return 0;
else
return ( Sous_Menu(choix) );

}

/* Propose un sous menu correspendant au choix du menu principale */
int Sous_Menu(int choix)
{
int sousChoix;

/* si le choix est 1, on affiche le 1er sous menu */
if( choix == 1 )
{
printf("\n 1. Somme de deux matrices\n 2. Difference de deux matrices\n"
" 3. Multiplication d'une matrice par un nombre\n"
" 4. Produit de deux matrices\n 5. Inverse d'une matrice\n"
" 6. Division de deux matrices\n");

/* on fait un petit controle de saisie */
do
{
printf("Choisissez un numero entre 1 et 6 du menu : ");
scanf("%d", &sousChoix);
}
while( (sousChoix!=1) && (sousChoix!=2) && (sousChoix!=3)
&& (sousChoix!=4) && (sousChoix!=5) && (sousChoix!=6) );

switch (sousChoix)
{
case 1: return 11; break; /* Menu 1.1 */
case 2: return 12; break; /* Menu 1.2 */
case 3: return 13; break; /* Menu 1.3 */
case 4: return 14; break; /* Menu 1.4 */
case 5: return 15; break; /* Menu 1.5 */
case 6: return 16; break; /* Menu 1.6 */
}
}

/* sinon, le choix est forcément 2, car on a obligé l'utilisateur a ne
saisir que 1 ou 2 ou 3 dans la fonction Menu */
else
{
printf("\n 1. Transposee d'une matrice\n 2. Compactage d'une matrices\n"
" 3. Tri d'une matrice\n 4. Calcul du vecteur Maxligne\n"
" 5. Calcule du vecteur Maxcolonne\n"
" 6. Extraction de Sous-Matrice\n");

do
{
printf("Choisissez un numero entre 1 et 6 du menu : ");
scanf("%d", &sousChoix);
}
while( (sousChoix!=1) && (sousChoix!=2) && (sousChoix!=3)
&& (sousChoix!=4) && (sousChoix!=5) && (sousChoix!=6) );

switch (sousChoix)
{
case 1: return 21; break; /* Menu 2.1 */
case 2: return 22; break; /* Menu 2.2 */
case 3: return 23; break; /* Menu 2.3 */
case 4: return 24; break; /* Menu 2.4 */
case 5: return 25; break; /* Menu 2.5 */
case 6: return 26; break; /* Menu 2.6 */
}
}

return 0; /* pas obligatoire de retourne ici */
}

/* Cette fonction permet d'allouer de la memoire pour une matrice qulquonque */
float** Allocate_Mat_Memory(int N, int M)
{
int i;
float **A = NULL;

/* On fait l'allocation de memoire pour un vecteur de N cases,
C'est un vecteur de pointeurs */
A = (float**) malloc( sizeof(float*) * N );

/* Si l'allocation à réussi, On fait une allocation de M cases
pour chaque ligne */
if( A != NULL )
for( i=0; i<N; i++ )
A[i] = (float*) malloc( sizeof(float) * M );

return A;

}

/* cette fonction fait la désallocation d'une matrice (liberer la memoire)*/
void Free_Mat_Memory( float **A, int N )
{
int i;
/* librer chaque ligne: */
for( i=0; i<N; i++ )
free( A[i] );

free( A );
}

/* Affichage des eélements d'un simple vecteur d'entiers */
void Affiche_Vecteur( float *vector, int taille )
{
int i;

for( i=0; i<taille; i++ )
printf("%f\t", vector[i]);
}

/* Affichage des élement de la matrice */
void Affiche_Mat( float **A, int N, int M )
{
int i, j;

for(i=0; i<N; i++)
{
for(j=0; j<M; j++)
printf("%f\t", A[i][j]);

printf("\n");
}
}

/* Saisir les élément de la matrice */
void Saisi_Mat( float **A, int N, int M )
{
int i, j;

for( i=0; i<N; i++ )
for( j=0; j<M; j++ )
{
printf("matrice(%d,%d) : ", i, j);
scanf("%f", &A[i][j]);
}
}

/* Fonction Addition/Soustraction , de deux matrice */
void Add_Soust_Mat( char operateur, float **mat1, float **mat2, int N, int M )
{
int i, j;

/* Pour ne pas perdre du temps, je ne vais pas crée une troisième matrice
mat3 pour contenire le résultat de l'addition ou de la soustraction.
Je vais dirrectement affecter le resultat à mat1 */

if( operateur == '+' )
{
printf("\nLa Somme des deux Matrice est:\n\n");

for( i=0; i<N; i++ )
for( j=0; j<M; j++ )
mat1[i][j] += mat2[i][j];
}

/* Si on veut faire une soustraction alore c'est meme chose avec un - */
else if( operateur == '-' )
{
printf("\nLa Differance entre les deux Matrice est:\n\n");

for( i=0; i<N; i++ )
for( j=0; j<M; j++ )
mat1[i][j] -= mat2[i][j];
}
}

/* Multiplication d'une matrice par un nombre */
void Multi_Mat_Nbr( float **mat, int nbr, int N, int M )
{
int i, j;

for( i=0; i<N; i++ )
for( j=0; j<M; j++ )
mat[i][j] *= nbr;
}

/* Multiplication de deux matrices */
float** Produit_Matriciel( float **mat1, float **mat2, int N, int M, int P )
{
int i, k, j;
float **mat3 = NULL;

mat3 = Allocate_Mat_Memory(N, P);

/* produit matriciele : */
for( i=0; i<N; i++ )
for( j=0; j dim-2 )
{
c = 0;
l++;
}
}
}

return sousMat;

}

float Determinant( float **mat, int N )
{
int c, signe = 1;
float det = 0.0;

if( N == 1 )
return mat[0][0];

for( c=0; c<N; c++ )
{
det += signe * mat[0][c] * Determinant(Sous_Mat_Det(mat,N,0,c), N-1);
signe *= (-1);
}

return det;
}

/* Fonction qui calcule la CoMatrice d'une matrice donné,
pour l'utiliser dans le calcule de l'inverce */
void Comatrice( float** mat, float** comat, int dim )
{
int i, j;

for( i=0; i<dim; i++ )
for( j=0; j<dim; j++ )
comat[i][j] = Determinant( Sous_Mat_Det( mat, dim, i, j ), dim-1 );
}

/* Fonction qui calcule l'inverce d'une matrice donné, et retourne NULL si la
matrice est non inversible ( det == 0 ) */
float** Inverse_Matrice( float **matrice, int dim )
{
float det = Determinant( matrice, dim );
float **comatrice, **comatTransposed;

if( det == 0 )
{
printf("\nLe determinant est null, cet matrice est non inversible\n\n");
return NULL;
}

comatrice = Allocate_Mat_Memory( dim, dim );
comatTransposed = Allocate_Mat_Memory( dim, dim );

/* calculer la comatrice de la matrice */
Comatrice( matrice, comatrice, dim );

/* calculer la comatrice transposer */
Transpose_Mat( comatrice, comatTransposed ,dim, dim );

/* calculer la matrice inverse selon la relation suivante:
l'inverce d'un matrice = (1 / det) * comatriceTranspoed */
Multi_Mat_Nbr( comatTransposed, (1.0/det), dim, dim );

return comatTransposed;

}

/* Division de deux matrices */
float** Division_Matriciel( float **mat1, float **mat2, int N, int M )
{
/* On inverse la mat2, et on fait une simple multiplication matriciel,
donc: ( mat1 * inverce_de_mat2 ) */

float **matDivision = Allocate_Mat_Memory( N, M );

mat2 = Inverse_Matrice( mat2, M );

if( mat2 == NULL ) // Si l'inverse n'a pas reussi alors
{
Free_Mat_Memory( matDivision, N );
/* On quite en retournant NULL, car mat2 n'est pas inversible */
return NULL;
}

/* on fait le produit matriciel */
matDivision = Produit_Matriciel( mat1, mat2, N, M, M );

return matDivision;
}

/* Le transposé d'une matrice */
void Transpose_Mat( float **mat1, float **mat2 ,int N, int M )
{
int i,j;

for( i=0; i<N; i++ )
for( j=0; j<M; j++ )
mat2[j][i] = mat1[i][j];
}

/* Fonction qui met tout les element null d'une matrice à la
fin de la matrice */
float** Compactage( float **mat, int N, int M )
{
int i, j, L=0, C=0, cptNull = 0;
float **t;

t = Allocate_Mat_Memory( N, M);

printf("\nCompactage :\n\n");

for( i=0; i<N; i++ )
for( j=0; j<M; j++ )
{
if( mat[i][j] != 0 )
{
t[L][C] = mat[i][j];
C++;
if( C == M )
{
C = 0;
L++;
}
}
else
{
cptNull++; // on compte.
}
}

/* On met les cptNull derniers element de la matrice à 0 */
for( i=N-1; i>=0; i-- )
for( j=M-1; j>=0; j-- )
if( cptNull!=0 )
{
t[i][j]=0;
cptNull--;
}

return t;
}

/* Trier la matrice selon l'ordre Decroissant (Trie par selection) */
void Trie_Mat_Decroissant( float **mat, int N, int M )
{
int i, j, L, C, posColonMin, posLignMin;
float tmp;

printf("\nLa matrice Trie selon l'ordre decroissant est:\n\n");

for ( i=0; i<N; i++ )
for ( j=0; j<N; j++ )
{
/* Recherche du maximum aprés A[i][j] */
posLignMin = i;
posColonMin = j;

C = j;

for ( L=i; L<N; L++ )
{
if( L != i )
C=0;
for ( ; C<M; C++ )
if ( mat[L][C] > mat[posLignMin][posColonMin] )
{
posLignMin = L;
posColonMin = C;
}

}

/* Echange de A[I] avec le maximum */
tmp = mat[i][j];
mat[i][j] = mat[posLignMin][posColonMin];
mat[posLignMin][posColonMin] = tmp;
}
}

/* Trier la matrice selon l'ordre Croissant (Trie par selection) */
void Trie_Mat_Croissant( float **mat, int N, int M )
{
int i, j, L, C, posColonMin, posLignMin;
float tmp;

printf("\nLa matrice Trie selon l'ordre croissant est:\n\n");

for ( i=0; i<N; i++ )
for ( j=0; j<N; j++ )
{
/* Recherche du maximum aprés A[i][j] */
posLignMin = i;
posColonMin = j;
C = j;

for ( L=i; L<N; L++ )
{
if( L != i )
C = 0;
for (; C<M; C++)
if ( mat[L][C] < mat[posLignMin][posColonMin] )
{
posLignMin = L;
posColonMin = C;
}

}

/* Echange de A[I] avec le maximum */
tmp = mat[i][j];
mat[i][j] = mat[posLignMin][posColonMin];
mat[posLignMin][posColonMin] = tmp;
}
}

/* Les elements maximume des lignes */
void Max_Ligne( float **mat, int N, int M )
{
int i, j;
float *maxLigne, Max;
printf("\nLe vecteur des elements maximum des lignes est:\n\n");

maxLigne = (float*) malloc( N * sizeof(float) );

for(i=0; i<N; i++)
{
/* initialiser avec le 1er element de la ligne */
Max = mat[i][0];

for(j=0; j<M; j++)
if( Max < mat[i][j] )
Max = mat[i][j];

maxLigne[i] = Max;
}

Affiche_Vecteur( maxLigne, N );
}

/* Les élements maximume des colonnes */
void Max_Colonne( float **mat, int N, int M )
{
int i, j;
float *maxColonne, Max;
printf("\nLe vecteur des elements maximum des colonne est:\n\n");

maxColonne = (float*) malloc( M * sizeof(float) );

for(j=0; j<M; j++)
{
/* initialiser avec le 1er element de la colonne */
Max = mat[0][j];

for( i=0; i<N; i++ )
if( Max < mat[i][j] )
Max = mat[i][j];

maxColonne[j] = Max;
}

Affiche_Vecteur( maxColonne, M );
}

/* Extarcation des sous matrice s_mat de taille s_N et s_M à partir de la
matrice mat de dimentions N et M */
void Extraction_Sous_Mat( float **mat, int N, int M, int s_N, int s_M )
{
int i, j, L=0, C=0;
float **s_mat;

/* L est l'indice de debut de lignes d'une suite de sous matrice
On appel une etage une suite de s_N lignes commençant à la ligne L.
C est l'indice de debut de colones de chaque sous matrice */

/* tantqu'on à pas encor tréter les sous matrices
de la derniere etage de la matrice */
while( L <= N-s_N )
{
/* allocation de la sous matrice */
s_mat = Allocate_Mat_Memory( s_N, s_M);

/* remplissage de la sous matrice */
for( i=0; i<s_N; i++ )
for( j=0; j<s_M; j++ )
s_mat[i][j] = mat[i+L][j+C];

/* si on à pas encor tréter la derniere sous matrices de cette etage */
if( C < M-s_M )
C++;
else
{
C = 0;
L++;
}

/* affichage de la sous matrice */
Affiche_Mat(s_mat, s_N, s_M);

Free_Mat_Memory(s_mat, s_N);
}


system("PAUSE");
return 0;
}
le_duche
Messages postés
164
Date d'inscription
lundi 13 juin 2005
Statut
Membre
Dernière intervention
26 février 2009
-
Je rajoute juste un p'tit comm pour que vous soyez averti par mail...
cs_JCDjcd
Messages postés
1138
Date d'inscription
mardi 10 juin 2003
Statut
Membre
Dernière intervention
25 janvier 2009
2 -
Je ne parle pas de diagonaliser, mais de trigonaliser, c'est a dire de trouver une matrice semblable a une matrice triangulaire superieur dont le determinant est le produit des coefficients diagonaux.
Une condition necessaire et suffisante pour d'une matrice soit trigonalisable est que son polynome minimal soit scinde, donc dans les complexes c'est toujours le cas grace au theoreme de Alembert.
Remarque : si son polynome caracteristique est scinde, alors comme le minimal divise le caracterisitque, le mininal est aussi scinde, donc la matrice est trigonalisable.
cs_Alain Proviste
Messages postés
910
Date d'inscription
jeudi 26 juillet 2001
Statut
Modérateur
Dernière intervention
1 février 2015
1 -
pour que A soit diagonalisable il faut que les sous espaces propres associées à lamba ( engendré par les valeurs x tel que (A-lamba*Id)*x = 0 ) ait la même dimension que la multiplicité des lambas dans le déterminant det(A-lamba*Id)

<:
Galmiza
Messages postés
573
Date d'inscription
samedi 16 novembre 2002
Statut
Membre
Dernière intervention
9 avril 2008
-
Si mes souvenirs sont bons, la résolution de det(A-lambda*Id)=0 donne les valeurs propres lambda.
Les vecteurs propres sont obtenus par résolution de (A-lambda*Id)*x = 0.

"Pour diagonaliser, il faut que le déterminant soit non nul il me semble..."
Non car une matrice diagonale peut avoir un déterminant nul.
Une matrice diagonale n'est pas forcement bijective.
le_duche
Messages postés
164
Date d'inscription
lundi 13 juin 2005
Statut
Membre
Dernière intervention
26 février 2009
-
non je comptais trouver les vecteurs propres avec le polynome caractéristique...
Pour le déterminant, je me suis contenté de la définition algébrique. Je compte faire toutes mes fonctions et optimiser après ! Comme ca je sais ou je vais...

JCDjcd le problème c'est que pour diagonaliser, il faut que le déterminant soit non nul il me semble...
Galmiza
Messages postés
573
Date d'inscription
samedi 16 novembre 2002
Statut
Membre
Dernière intervention
9 avril 2008
-
Attention, si des vecteurs propres sont colinéaires, ta matrice n'est plus diagonalisable !

En parlant de vecteurs propres, tu vas être obligé de résoudre des systemes du type A*x=b pour les trouver.

PS: je parle, je parle mais les classes prépas sont loin derrière maintenant, il se peut que je raconte des conneries.
cs_JCDjcd
Messages postés
1138
Date d'inscription
mardi 10 juin 2003
Statut
Membre
Dernière intervention
25 janvier 2009
2 -
* pour resoudre A.x=B, tu peux utiliser la methode des moindres carres de Gauss, qui minimise l'erreur quadratique moyenne : il suffit de resoudre (At.A).x=At.B avec At la transposee de A (remarque : se systeme est carre...)

* pour le calcul du determinant : ton algorithme est en n!, ce qui est trop grand, en plus du point de vu stabilite numerique ... bof bof. Une methode moins couteuse consiste a ce mettre dans la cloture algebrique de ton corps choisi (i.e. pour les reels les complexes), puis tu trigonalises ta matrice, et le determinant est le produit des coefficients diagonaux.
Galmiza
Messages postés
573
Date d'inscription
samedi 16 novembre 2002
Statut
Membre
Dernière intervention
9 avril 2008
-
Les méthodes de Jacobi, Gauss-Seidel et de relaxation sont des algorithmes recursifs pour estimer x dans A*x = b.


Jacobi:
Tu décompose ta matrice carré en somme d'une matrice diagonale D, une matrice triangulaire supérieure à diagonale nulle -F et une matrice triangulaire inférieure à diagonale nulle -E.

D'ou A = D-(E+F)
A*x = b
D*x = (E+F)*x + b
x = inv(D)*(E+F)*x + inv(D)*b // recursif
L'inverse de D est facile à obtenir compte tenu de la nature de D.

Gauss-Seidel:
Presque idem en plus rapide avec A = (D-E)-F

Relaxation:
A = (D/w - E) - [(1-w)/w * D + F] // Gauss-Seidel si w==1
// convergence si w dans ]0,2[


rayonSpectral(A) = max( | valeurPropre(A) | )

Il y a plusieurs norme possibles (qui satisfont la définition), en voici quelques unes:
norme1(A) = max_j(Sum_i(|a_ij|))
norme2(A) = sqrt(rayonSpectral(A*transpose(A)))
normeInfinie = max_i(Sum_j(|a_ij|))

avec sum_i = somme sur i
max_i = maximum sur i


En espérant t'avoir appris des trucs, bon appétit.
le_duche
Messages postés
164
Date d'inscription
lundi 13 juin 2005
Statut
Membre
Dernière intervention
26 février 2009
-
pour l'indentation c'est pas ma faute ! Mon code à moi est tout à fait normal, mais là je sais pas ce qui s'est passé... je crois que c'est à cause de Linux... en fait j'ai Windows (je travaille sous dev) chez moi et je passe pas la fac où il y a Linux, puis je fait un copié-collé (qui lui n'avait pas ces lignes vides...); c'est peut-être pour ca...

Alain Proviste, le déterminant et l'inverse c'est fait (ouvre tes yeux ;) ligne 959 et 989. c'est dans la classe matrice_carree, car on ne peut pas calculer le detéreminant d'une matrice qui n'est pas carrée...), le rang se fera beaucoup plus facilement quand j'aurai fait la fonction de triangularisation... (calcul immédiat...)

Emsien, la méthode du pivot je l'ai déjà fait mais en Pascal, et j'ai un peu la flemme de faire la traduction...

Galmiza, Résoudre AX+b=0 n'est pas dans l'optique ce cette classe mais plutot des utilisation que l'on peut en faire par la suite... (note que ca pourrait peut etre servir pour certaines application que je devrai faire...)
Qu'est-ce que la méthode de Gauss-Seidel ?
Qu'est-ce que la méthode de Jacobi ?
Qu'est-ce que la méthode de relaxation ? (mdr le nom)
C'est quoi le rayon spectral ?
La norme de la matrice c'est bien le maximum des normes des éléments de cette matrice ? (ca c'est déjà fait)

J'ai aussi déjà fait l'exponentielle de matrice, la trace (somme des éléments de la diagonale)
Je ferai aussi un générateur de matrice de Jordan de paramètre donné, de matrice diagonale à partir d'un vecteur donné,...
mais faut me laisser un peu de temps :D

Je suis sur deux autres projets (un scrabble qui me pose pas mal de problème d'interface...) et une classe de fonctions mathématique
Galmiza
Messages postés
573
Date d'inscription
samedi 16 novembre 2002
Statut
Membre
Dernière intervention
9 avril 2008
-
Tu pourrais aussi trouver des approximations de vecteurs x avec A*x = b, avec A et b connu.
Méthodes de Gauss-Seidel, de Jacobi, de relaxation, calculer le rayon spectral, des normes... allez allez au boulot :D.

Bravo, bon début !

PS: en CP, on devait sauter des lignes pour que la maitresse écrive la correction sous la ligne fausse, mais là c'est pas la peine :-D !
EMSIEN
Messages postés
194
Date d'inscription
lundi 26 juillet 2004
Statut
Membre
Dernière intervention
11 juin 2009
-
moi aussi je travaille sur les matrices carré,je dois réaliser les algo des methodes de GAUSS (simple,pivot partiel et pivot total) dès que possible je vais t'envoyer la source pour que tu l'ajoute sur ta source,seul bémol est que je n'utilise pas les classes, juste le type float mat[][];
http://ntic.blogspirit.com
cs_Alain Proviste
Messages postés
910
Date d'inscription
jeudi 26 juillet 2001
Statut
Modérateur
Dernière intervention
1 février 2015
1 -
tu pourrais calculer le rang, le determinant, l'inverse...
le_duche
Messages postés
164
Date d'inscription
lundi 13 juin 2005
Statut
Membre
Dernière intervention
26 février 2009
-
Merci pour les liens cosmobob, ca a l'air interessant
(meme au sens mathématique, puis que je suis un vrai matheux ;) )
le_duche
Messages postés
164
Date d'inscription
lundi 13 juin 2005
Statut
Membre
Dernière intervention
26 février 2009
-
Luthor, le produit extérieur y est: lignes 93 et 651...
je prend bonne note de vos remarques, de toutes facon c'est loin d'être un produit fini ;)
cosmobob
Messages postés
706
Date d'inscription
mardi 30 décembre 2003
Statut
Membre
Dernière intervention
27 janvier 2009
3 -
salut,
si tu cherches comment faire pour trouver les racines d'un polynomes de degré quelconque: http://www.library.cornell.edu/nr/bookcpdf/c9-5.pdf (algo en C)
ya plein d'autres choses sur l'algebre lineaire: http://www.library.cornell.edu/nr/bookcpdf.html

numerical recipes est une bible pour le calcul mathématiques en C (et donc en C++ ca se traduit assez facilement) !!

a+ ;)
luhtor
Messages postés
2023
Date d'inscription
mardi 24 septembre 2002
Statut
Membre
Dernière intervention
28 juillet 2008
4 -
Hm j'ai oublié des choses:
- le produit extérieur il est ou ? donc pas de "4 * m" possible.
- pour les fonctions de comparaison de matrice "==" et "!=", tu peux utiliser "memcmp"
ca donnerait un truc du genre: (au passage, perso, je préfère l'opérateur "==" en fonction membre)

bool operator == (const matrice & _which)
{
// on vérifie qu'elles sont de meme taille.
return !memcmp(this->p, _which.p, this->NbrL * this->NbrC * sizeof(double));
// j'ai un doute si c'est return memcmp... ou return !memcmp, faudrait voir la fonction
}

bon ca y est, la j'ai fini.
luhtor
Messages postés
2023
Date d'inscription
mardi 24 septembre 2002
Statut
Membre
Dernière intervention
28 juillet 2008
4 -
Trois remarques:
1) ne mélange jamais prototype et définition de fonction.
Imagine, que deux de tes fichiers .cpp ou .h déclare:
#include "matrice.h"

Tu auras comme erreur, "redefinition of etc...", donc incompilable.

2) tu devrais rendre ta classe générique, comme ca, on pourrait choisir le type de donnée que contient la matrice: ex:
matrice matrice_d_entier;
matrice<float> matrice_de_float;

et dans ce cas, tout les définitions de fonctions sont dans le .h, on ne peut pas les séparer quand on utilise du générique.

3)tu écris ca:
"friend void operator += (matrice& a,const matrice& b);"

l'opérateur "+=" n'est pas symétrique comme le serait "+", (d'après ce que j'ai lu) c'est plus logique que l'opérateur "+=" soit une fonction membre, donc:
void operator += (const matrice& b);

mais en fait, l'opérateur doit retourner une référence de la matrice, donc ca devient:
matrice & operator += (const matrice& b);
et donc a la fin de ta fonction, t'as ca: "return *this;"

et enfin l'opérateur = doit aussi retourner une référence sinon tu peux pas faire:
matrice m;
if ((m a*b) c);
donc:
matrice & operator = (const matrice & _which);

Bon voila les remarques qui feraient que personnellement, je n'utiliserais pas ta class :) de toute facon, un peu comme tout le monde, je l'ai deja faite.

Bon aller ++
dark_naruto25
Messages postés
127
Date d'inscription
mardi 23 août 2005
Statut
Membre
Dernière intervention
9 mai 2011
-
Hypercool.
L'idée est super bien et surtout tombe à pic étant donnée que je dois aussi faire ma lib pour les cours lol.
Sinon le code est bien, y a du vécu dans le C++ !!!!
8/10 --> je ne l'ai pas tester encore