Classes de matrices (carrées) dynamiques et ses utilisations mathématiques

Soyez le premier à donner votre avis sur cette source.

Vue 15 703 fois - Téléchargée 1 215 fois

Description

Classe complète pour l'utilisation de matrices réelles dynamiques.

Source / Exemple :


//voir dans le zip ^_^

Conclusion :


Beaucoup de grammaire.
Il y a quelques algorithmes interessants, qui méritent que je les commente un peu plus à l'occasion...

Je dois encore ajouter la recherche des valeurs propres.
Je pense aussi ajouter une classe héritée "SystemeLineaire".

Je ne pense pas qu'il y ait des bug à proprement parler, mais j'ai remodifier quelques fonctions sans les tester...
Si vous voyez des problèmes, dite-le moi !

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

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
159
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
908
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.

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.