CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2010 03 21 05:54:22

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

Maths & Algorithmes

> BIBLIOTHÈQUE DE GESTION DE MATRICES EN C

BIBLIOTHÈQUE DE GESTION DE MATRICES EN C

Information sur la source

Note :
Aucune note

Catégorie :Maths & Algorithmes Classé sous :matrices, matrice, matrix, bibliothèque Niveau :Débutant Date de création :08/05/2007 Date de mise à jour :26/02/2008 20:17:49 Vu / téléchargé :9 010 / 608

Auteur : Sunglasses

Ecrire un message privé

Site perso

Ce membre participe au partage de revenus publicitaires

Commentaire sur cette source (2)

Ajouter un commentaire et/ou une note

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

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

main.c 1 035 octets
matrice.c 7 642 octets
matrice.dev1 324 octets
matrice.h 5 977 octets
matrice_io.c 1 534 octets
matrice_io.h 828 octets

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

VISUALISEUR RVB AVEC QT

TEMPLATE DE VECTEUR AVEC TIRAGE ALEATOIRE (C++)

BIBLIOTHÈQUE DE GESTION DE FILES DYNAMIQUES

BIBLIOTHÈQUE DE GESTION DE FILES STATIQUES

BIBLIOTHÈQUE DE GESTION DES PILES DYNAMIQUES EN C

Toutes les sources de Sunglasses

Sources de la même categorie

TRANSFORMER UN ENTIER EN DEUX NOMBRES COMPOSÉ DES MEMES CHIF... par thebroyeur

CALCULE LOG(X) par tagtog

ALGORITHME DE TRI D'UN TABLEAU PAR ORDRE CROISSANT OU DÉCROI... par Thuzhen

CALCUL DE VARIANCE par Minilogus

GÉNÉRATEUR DE CLÉS SUR 26 DIGITS AU FORMAT HEXADÉCIMAL par besilent

Toutes les sources de la catégorie Maths & Algorithmes

Sources en rapport avec celle ci

CALCULER LE PRODUIT DE DEUX MATRICES DE TAILLE DIFFERENT par aymenet1

OPERATION SUR LES MATRICES CARREES AVEC CLASSE GENERIQUE par chouhad

OPÉRATIONS SUR MATRICES C++ par Minilogus

CLASSES POUR TRAITER DES MATRICES DE COMPLEXES. par Gastonm

MATRIX par lebarn

Commentaires et avis

Commentaire de ncoder le 09/05/2007 20:35:13

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);
}

Commentaire de Sunglasses le 09/05/2007 21:08:21

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 :-) ).

Ajouter un commentaire

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 Inverser une matrice avec plusieurs processus [ par JinaJumbo ] Bonjour,Pour un projet, je dois écrire un programme en C sous Linux qui permet d'inverser une matrice partitionnée, ie décomposer ma matrice en plusie 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

Nos sponsors

Derniers Blogs

NOUVEAU SYSTèME D'AIDE POUR VISUAL STUDIO 2010 : POUR CEUX QUI N'APPRéCIENT PAS TROP L'ABSENCE D'INDEX... par coq

L'INTERFACE NATURELLE DE WINDOWS PHONE 7 SERIES par odewit

COMMENT MAPPER UNE VUE SQL SUR UNE COLLECTION DE COMPLEX TYPE? par Matthieu MEZIL

SQL SERVER : QUERY NOTIFICATION OU COMMENT êTRE NOTIFIé DE MODIFICATIONS DE DONNéES CôTé APPLICATION (SQLDEPENDENCY) par christian

[WF4] UN BINDING ACTIVITY/ACTIVITYDESIGNER QUI PASSE MAL? par JeremyJeanson

Forum

TRADAION par shootangel

LIER UN FICHIER .CFG à UN FICHIER .EXE à L'AIDE D'UN FICHIER .BAT par fox555

RE : LE NOUVEAU GCC ET LE PROBLèME AVEC IOSTREAM.H par CptPingu

RE : CONVERTION D'UNE APPLICATION CONSOL VERS WINDOWS par nanonavich

RE : INTERFACE GRAPHIQUE EN C++ AVEC UN PROJET WIN32 SOUS VISUAL STUDIO 2008 par zeom

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Logiciels

Academy System (10.9.4.0)
ACADEMY SYSTEM (10.9.4.0)

Logiciel de gestion des établissements. - élèves/étudiants (inscription, dossier, absence...) -...

Cliquez pour télécharger Academy System
Xilisoft Convertisseur Vidéo Ultimate (5.1.39.0305)
XILISOFT CONVERTISSEUR VIDéO ULTIMATE (5.1.39.0305)

Xilisoft Convertisseur Vidéo Ultimate est un outil puissant de conversion vidéo, facile à utilise...

Cliquez pour télécharger Xilisoft Convertisseur Vidéo Ultimate
Xilisoft DVD Ripper Ultimate (5.0.64.0304)
XILISOFT DVD RIPPER ULTIMATE (5.0.64.0304)

Xilisoft DVD Ripper Ultimate est un logiciel excellent pour copier et convertir DVD vers presque ...

Cliquez pour télécharger Xilisoft DVD Ripper Ultimate
Axalot, logiciel de sauvegarde de données en ligne (1.10.108.1)
AXALOT, LOGICIEL DE SAUVEGARDE DE DONNéES EN LIGNE (1.10.108.1)

Perdre tout le contenu de votre disque dur, vous imaginez ? Vos photos, vos musiques, votre compt...

Cliquez pour télécharger Axalot, logiciel de sauvegarde de données en ligne
Rigs of Rods (63.3)
RIGS OF RODS (63.3)

c'est un jeu de multi-simulation camions,autobus voitures, avions, bateaux, hélicoptère avec défo...

Cliquez pour télécharger Rigs of Rods