Bibliothèque de gestion de matrices en c

Soyez le premier à donner votre avis sur cette source.

Vue 15 099 fois - Téléchargée 1 016 fois

Description

Il s'agit d'une bibliothèque (deux en fait) permettant de gérer des matrices.

La bibliothèque de gestion de matrices (matrice.h/matrice.c) proprement dite contient les opérations élémentaires sur les matrices ainsi que des fonctions de construction de matrices particulières.

Comme indiqué dans les commentaires du code, la fonction d'allocation de la matrice doit être invoquée impérativement après une déclaration.

La bibliothèque d'entrée/sortie (matrice_io.h/matrice_io.c) permet l'entrée d'une matrice au clavier et l'affichage d'une matrice.

Un petit main.c teste toutes les fonctions.

Source / Exemple :


matrice.h :

#ifndef _matrice_h_
#define _matrice_h_

/*---------------- STRUCTURE DE MATRICE.C ------------------------------------*/

/*
  Structure :
  Nom  :  matrice
  Fct  :  structure definissant une matrice

  • /
typedef struct matrice { int n; /*---nombre de lignes---*/ int m; /*---nombre de colonnes---*/ double * M; /*---pointeur sur le premier element---*/ } matrice_t; /*---------------- FONCTIONS DE MATRICE.C ------------------------------------*/ /*----------------------------------------------------------------------------*/ /* */ /* Fonctions de gestion de la structure */ /* */ /*----------------------------------------------------------------------------*/ /* Nom : m_alloc (a utiliser systematiquement apres declaration ou allocation d'une matrice) Fct : alloue une matrice Entree : n nombre de lignes m nombre de colonnes (A) adresse de la matrice
  • /
void m_alloc(const int n, const int m, matrice_t * const A); /* Nom : m_elem Fct : retourne l'adresse de l'element d'une matrice Entree : (A) adresse de la matrice i indice de la ligne j indice de la colonne Sortie : adresse de l'element correspondant
  • /
double * m_elem(const matrice_t * const A, const int i, const int j); /* Nom : m_free Fct : libere l'espace memoire occupe par une matrice Entree : (A) adresse de la matrice
  • /
void m_free(matrice_t * const A); /*----------------------------------------------------------------------------*/ /* */ /* Fonctions basiques */ /* */ /*----------------------------------------------------------------------------*/ /* Nom : m_copy Fct : retourne l'adresse de l'element d'une matrice Entree : (A) adresse de la matrice a copier (B) adresse de la matrice resultat
  • /
void m_copy(const matrice_t * const A, matrice_t * const B); /* Nom : m_somme Fct : effectue la somme de deux matrices Entree : (A) et (B) adresses matrices a additionner (C) adresse de la matrice resultat
  • /
void m_somme(const matrice_t * const A, const matrice_t * const B, matrice_t * const C); /* Nom : m_somme_pond Fct : effectue une combinaison lineaire de deux matrices Entree : a et b coefficients de ponderation (A) et (B) adresses des matrices a additionner (C) adresse de la matrice resultat
  • /
void m_somme_pond(const double a, const double b, const matrice_t * const A, const matrice_t * const B, matrice_t * const C); /* Nom : m_ligne Fct : extrait une ligne d'une matrice Entree : (A) adresse de la matrice dont on souhaite extraire une ligne l indice de la ligne a extraire (C) adresse de la matrice resultat
  • /
void m_ligne(const matrice_t * const A, const int l, matrice_t * const C); /* Nom : m_colonne Fct : extrait une colonne d'une matrice Entree : (A) adresse de la matrice dont on souhaite extraire une colonne c indice de la colonne a extraire (C) adresse de la matrice resultat
  • /
void m_colonne(const matrice_t * const A, const int c, matrice_t * const C); /* Nom : m_produit_scal Fct : renvoie le produit scalaire entre un vecteur ligne et un vecteur colonne Entree : (A) adresse d'une matrice ligne (B) adresse d'une matrice colonne Sortie : produit scalaire
  • /
double m_produit_scal(const matrice_t * const A, const matrice_t * const B); /* Nom : m_produit Fct : renvoie le produit de deux matrices Entree : (A) et (B) adresses des matrices a multiplier (C) adresse de la matrice resultat
  • /
void m_produit(const matrice_t * const A, const matrice_t * const B, matrice_t * const C); /* Nom : m_reshape Fct : renvoie une matrice remplie par colonne avec les valeurs d'un vecteur Entree : n nombre de lignes m nombre de colonnes (V) vecteur fournissant les valeurs (C) adresse de la matrice resultat
  • /
void m_reshape(const int n, const int m, const double * const V, matrice_t * const C); /*----------------------------------------------------------------------------*/ /* */ /* Fonctions de construction de matrices particulières */ /* */ /*----------------------------------------------------------------------------*/ /* Nom : m_unite Fct : renvoie une matrice unite Entree : k taille de la matrice (C) adresse de la matrice resultat
  • /
void m_unite(const int k, matrice_t * C); /* Nom : m_nulle Fct : renvoie une matrice nulle Entree : k taille de la matrice (C) adresse de la matrice resultat
  • /
void m_nulle(const int k, matrice_t * C); /* Nom : m_val Fct : renvoie une matrice initialisee a une valeur donnee Entree : k taille de la matrice v valeur des elements de la matrice (C) adresse de la matrice resultat
  • /
void m_val(const int k, const double v, matrice_t * C); /* Nom : m_hilbert Fct : renvoie une matrice de Hilbert Entree : k taille de la matrice (C) adresse de la matrice resultat
  • /
void m_hilbert(const int k, matrice_t * C); #endif matrice.c : #include "matrice.h" /*----------------------------------------------------------------------------*/ /* */ /* Fonctions de gestion de la structure */ /* */ /*----------------------------------------------------------------------------*/ /* Nom : m_alloc (a utiliser systematiquement apres declaration ou allocation d'une matrice) Fct : alloue une matrice Entree : n nombre de lignes m nombre de colonnes (A) adresse de la matrice
  • /
void m_alloc(const int n, const int m, matrice_t * const A) { A->n = n; A->m = m; A->M = (double*)malloc(n*m*sizeof(double)); } /* Nom : m_elem Fct : retourne l'adresse de l'element d'une matrice Entree : (A) adresse de la matrice i indice de la ligne j indice de la colonne Sortie : adresse de l'element correspondant
  • /
double * m_elem(const matrice_t * const A, const int i,const int j) { return (A->M+(i-1)+A->n*(j-1)); } /* Nom : m_free Fct : libere l'espace memoire occupe par une matrice Entree : (A) adresse de la matrice
  • /
void m_free(matrice_t * const A) { free(A->M); } /*----------------------------------------------------------------------------*/ /* */ /* Fonctions basiques */ /* */ /*----------------------------------------------------------------------------*/ /* Nom : m_copy Fct : retourne l'adresse de l'element d'une matrice Entree : (A) adresse de la matrice a copier (B) adresse de la matrice resultat
  • /
void m_copy(const matrice_t * const A, matrice_t * const B) { int k; m_free(B); m_alloc(A->n,A->m,B); for (k=0 ; k<(A->n)*(A->m) ; k++) { B->M[k]=A->M[k]; } } /* Nom : m_somme Fct : effectue la somme de deux matrices Entree : (A) et (B) adresses des matrices a additionner (C) adresse de la matrice resultat
  • /
void m_somme(const matrice_t * const A, const matrice_t * const B, matrice_t * const C) { int i,j; m_free(C); m_alloc(A->n,A->m,C); for(i=1 ; i<=C->n ; i++) { for(j=1 ; j<=C->m ; j++) {
  • m_elem(C,i,j)=(*m_elem(A,i,j))+(*m_elem(B,i,j));
} } } /* Nom : m_somme_pond Fct : effectue une combinaison lineaire de deux matrices Entree : a et b coefficients de ponderation (A) et (B) adresses des matrices a additionner (C) adresse de la matrice resultat
  • /
void m_somme_pond(const double a, const double b, const matrice_t * const A, const matrice_t * const B, matrice_t * const C) { int i,j; m_free(C); m_alloc(A->n,A->m,C); for(i=1 ; i<=C->n ; i++) { for(j=1 ; j<=C->m ; j++) {
  • m_elem(C,i,j)=a*(*m_elem(A,i,j))+b*(*m_elem(B,i,j));
} } } /* Nom : m_ligne Fct : extrait une ligne d'une matrice Entree : (A) adresse de la matrice dont on souhaite extraire une ligne l indice de la ligne a extraire (C) adresse de la matrice resultat
  • /
void m_ligne(const matrice_t * const A, const int l, matrice_t * const C) { int j; m_free(C); m_alloc(1,A->m,C); for(j=1;j<=C->m;j++) {
  • m_elem(C,1,j)=*m_elem(A,l,j);
} } /* Nom : m_colonne Fct : extrait une colonne d'une matrice Entree : (A) adresse de la matrice dont on souhaite extraire une colonne c indice de la colonne a extraire (C) adresse de la matrice resultat
  • /
void m_colonne(const matrice_t * const A, const int c, matrice_t * const C) { int i; m_free(C); m_alloc(A->n,1,C); for(i=1 ; i<=C->n ; i++) {
  • m_elem(C,i,1)=*m_elem(A,i,c);
} } /* Nom : m_produit_scal Fct : renvoie le produit scalaire entre un vecteur ligne et un vecteur colonne Entree : (A) adresse de la matrice ligne (B) adresse de la matrice colonne Sortie : produit scalaire
  • /
double m_produit_scal(const matrice_t * const A, const matrice_t * const B) { double p=0; int k; for(k=1 ; k<=A->m ; k++) { p=p+(*m_elem(A,1,k))*(*m_elem(B,k,1)); } return p; } /* Nom : m_produit Fct : renvoie le produit de deux matrices Entree : (A) et (B) adresses des matrices a multiplier (C) adresse de la matrice resultat
  • /
void m_produit(const matrice_t * const A, const matrice_t * const B, matrice_t * const C) { double p; int i,j,k; m_free(C); m_alloc(A->n,B->m,C); for(i=1 ; i<=A->n ; i++) { for(j=1 ; j<=B->m ; j++) { p=0; for(k=1 ; k<=A->m ; k++) { p=p+(*m_elem(A,i,k))*(*m_elem(B,k,j)); }
  • m_elem(C,i,j)=p;
} } } /* Nom : m_reshape Fct : renvoie une matrice remplie par colonne avec les valeurs d'un vecteur Entree : n nombre de lignes m nombre de colonnes (V) vecteur fournissant les valeurs (C) adresse de la matrice resultat
  • /
void m_reshape(const int n, const int m, const double * const V, matrice_t * const C) { int k; m_free(C); m_alloc(n,m,C); for(k=0 ; k<(C->n * C->m) ; k++) {
  • (C->M+k)=V[k];
} } /*----------------------------------------------------------------------------*/ /* */ /* Fonctions de construction de matrices particulières */ /* */ /*----------------------------------------------------------------------------*/ /* Nom : m_unite Fct : renvoie une matrice unite Entree : k taille de la matrice (C) adresse de la matrice resultat
  • /
void m_unite(const int k, matrice_t * C) { int i,j; m_free(C); m_alloc(k,k,C); for(i=1 ; i<=C->n ; i++) { for(j=1 ; j<=C->m ; j++) { if(i==j) {
  • m_elem(C,i,j)=1;
} else {
  • m_elem(C,i,j)=0;
} } } } /* Nom : m_nulle Fct : renvoie une matrice nulle Entree : k taille de la matrice (C) adresse de la matrice resultat
  • /
void m_nulle(const int k, matrice_t * C) { int i,j; m_free(C); m_alloc(k,k,C); for(i=1;i<=C->n;i++) { for(j=1;j<=C->m;j++) {
  • m_elem(C,i,j)=0;
} } } /* Nom : m_val Fct : renvoie une matrice initialisee a une valeur donnee Entree : k taille de la matrice v valeur des elements de la matrice (C) adresse de la matrice resultat
  • /
void m_val(const int k, const double v, matrice_t * C) { int i,j; m_free(C); m_alloc(k,k,C); for(i=1 ; i<=C->n ; i++) { for(j=1 ; j<=C->m ; j++) {
  • m_elem(C,i,j)=v;
} } } /* Nom : m_hilbert Fct : renvoie une matrice de Hilbert Entree : k taille de la matrice (C) adresse de la matrice resultat
  • /
void m_hilbert(const int k, matrice_t * C) { int i,j; m_free(C); m_alloc(k,k,C); for(i=1;i<=C->n;i++) { for(j=1;j<=C->m;j++) {
  • m_elem(C,i,j)=1/(double)(i+j-1);
} } }

Conclusion :


J'ai à peu près tout vérifié et corrigé tous les bugs connus. Je pense que cette bibliothèque est maintenant dans une version très stable.

Si vous rencontrez des problèmes avec n'hésitez pas à en discuter.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

ncoder
Messages postés
244
Date d'inscription
vendredi 6 mai 2005
Statut
Membre
Dernière intervention
6 avril 2008
1 -
Pour afficher un tableau[X][Y], voici une petite fonction :

void AfficherTableau( float * t[], int TailleX, int TailleY )
{
int x;
int y;
int i, j, k;

printf("\n\t---\n\n\t%c", 201);

for (i=0; i<TailleX*8-1; i++) printf("%c", 205);

printf("%c\n\t", 187);

for(y = 0; y<TailleY; y++) {
for(x = 0; x<TailleX; x++) {

if ( t[x][y]>=0 ){ //Si positif, pas besoin de "-"
if ( t[x][y]<10 ) printf("%c%.5f", 186, t[x][y]);
else if ( t[x][y]<100 ) printf("%c%.4f", 186, t[x][y]);
else if ( t[x][y]<1000 ) printf("%c%.3f", 186, t[x][y]);
else if ( t[x][y]<10000 ) printf("%c%.2f", 186, t[x][y]);
else if ( t[x][y]<100000 ) printf("%c%.1f", 186, t[x][y]);
else if ( t[x][y]<1000000 ) printf("%c%.0f-", 186, t[x][y]);
else if ( t[x][y]<10000000 ) printf("%c%.0f", 186, t[x][y]);
else printf("%c-GRAND-", 186, t[x][y]);
}
else{ //Sinon
if ( t[x][y]>-10 ) printf("%c%.4f", 186, t[x][y]);
else if ( t[x][y]>-100 ) printf("%c%.3f", 186, t[x][y]);
else if ( t[x][y]>-1000 ) printf("%c%.2f", 186, t[x][y]);
else if ( t[x][y]>-10000 ) printf("%c%.1f", 186, t[x][y]);
else if ( t[x][y]>-100000 ) printf("%c%.0f", 186, t[x][y]);
else if ( t[x][y]>-1000000 ) printf("%c%.0f", 186, t[x][y]);
else printf("%cNEGAT", 186, t[x][y]);
}

if ( x==TailleX-1 ) printf("%c\n\t", 186);
}

if (y!=TailleY-1) {
for(j=0; j<TailleX; j++){
printf("%c-------", 186);
if ( x==TailleX-1 ) printf("%c\n\t", 186);
}
printf("%c\n\t", 186);
}

}

printf("%c", 200);

for (i=0; i<TailleX*8-1; i++)printf("%c", 205);

printf("%c\n\n\t---\n\n", 188);
}
cs_Sunglasses
Messages postés
8
Date d'inscription
samedi 20 mai 2006
Statut
Membre
Dernière intervention
11 juillet 2008
-
Ok, merci pour la fonction d'affichage, c'est vrai que c'est un peu plus sympathique quand tous les nombres sont bien alignés (m'enfin quelle idée d'utiliser des nombres plus grands que dix :-) ).

Quand j'aurai un peu de temps il faudra que je l'adapte à ma structure de données, car je n'ai pas utilisé un tableau de tableaux, mais un tableau dans lequel les éléments sont rangés en colonne (c'est un peu plus performant niveau timing).

Si vous avez d'autres suggestions, je suis tout ouïe (même si je n'apporte pas les modifications tout de suite à mon code, dès que j'ai cinq minutes je m'y remets, promis :-) ).

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.