|
 Trouver une ressource
Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !
 BIBLIOTHÈQUE DE GESTION DE MATRICES EN C
 Information sur la source
 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
- 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);
- }
- }
- }
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.
 Fichier Zip
Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !
 Télécharger le zip
 Historique
- 26 février 2008 20:15:18 :
- Amélioration de l'affichage et correction de fuites de mémoires.
- 26 février 2008 20:17:49 :
- Amélioration de l'affichage et correction de fuites de mémoire.
 Sources du même auteur
 Sources de la même categorie
Sources en rapport avec celle ci
 Commentaires et avis
 Discussions en rapport avec ce code source dans le forum
matrice OpenGL [ par fabienGL ]
Voici une question, voir réflexion est sur comment se présente les matrices OpenGL, en effet elles ont les lignes et colonnes inversé par rapport à le
Template matrice [ par anisdilou ]
Je souhaite q'on s'aide a fin d'meliorer nos nivauxSalut : Je veux implémenter une classe qui représente des matrices de dimensions et type de donnés
matrices et c++ [ par anne-lise ]
Bonjour, je debute en c++ et j'ai quelques problemes avec les tableaux... D'abord, y a t'il un moyen d'avoir pour resultat d'une fonction un tableau ?
Free d'une matrice de structures [ par zizofredj ]
Je suis entrain de travailler dans mon projet de thèse et j
problème de stockage [ par gyzmo1 ]
bonjour à tous !voilà mon problème, je travaille sur des Matrices . Chaque classe Matrice est composé de :float ** Mat;int Ligne;int Colonne;Lors de C
[matrices] [ par jeanw ]
Bonjourj'ai une matrice et j'aimerais créer une autre matrice qui est une permutation aléaoire des colonnes de la première matrice
Des matrices sans ou avec openGL [ par theidiot ]
J'ai remarquer qu'un bon nombre de programmeur creait leur propre petite bibliotheque de matrice en utilisant openGL.Je suis moi meme en train de
matrices creuses [ par abidouvitch ]
salut lees amisj ai besoin d aide de klk un s il vous plait j ai un projet concernant les matrices creuses et j arrrive pas a le faire tout seul s il
quadrillage matrices [ par Gaston0510 ]
Notre prof d cours nous a demand¨¦ de saisir et afficher des matrices .Les matrices affich¨¦ doivent etr entour¨¦ avec un double qudrillage on utilisa
Inversion de matrices [ par Stubbornman ]
Bonjour a tous, Mon probleme est le suivant: je cherche à inverser une matrice de taille tres importante (environ 2000x2000), malheureusement, mon al
|
 Téléchargements
Logiciels à télécharger sur le même thème :
Comparez les prix Nouvelle version
|