Discussion :

[salseropom]

Bonjour, j'ai écrit un prgm dont le contenu est ultra simple : ce prgm se "contente" d'additionner, soustraire et multiplier des tableaux 27*1, 27*3 et/ou 27*7 (en tout il y a une petite quinzaine de tableaux mais je répète 500 fois ces calculs).

J'ai écrit ce prgm de deux manière, car je cherche à optimiser le temps de calculs.

Mon 1e prgm conistait à faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
double tableau[27][3]

Mais lorsque je veux multiplier, additionner et multiplier ces tableaux, je faisais des boucles "for" si bien que je trouve que le prgm est "lourd" à lire (bien qu'il ne fasse que 500 lignes)

temps de calculs : 39 min

La 2e version était une classe Matrice afin de rendre le code plus lisible (donc j'évitais d'écrire toutes mes boucles "for")

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
class Matrice
{
  unsigned int NB_LIGNE;
  unsigned int NB_COL;
  vector<vector<double> > m;
 
public:
blabla
}

Temps de calcul : 5 heures 46 !!

Etant donné que je n'ai que peu de tableaux, j'ai opté pour avoir une matrice en tant que variable statique et non dynamique, d'où mon vector<vector<double> > m et non un double**m ou un double * m

Je comprends tout à fait qu'avec la classe Matrice cela aille plus lentement qu'avec mon double tableau[27][3] mais de là à mettre plus de 5h !!

Pouvez-vous soit m'expliquer cette si grande différence de temps de calcul ou bien me proposer une autre solution afin que mon code soit plus lisible ?

Cordialement

[dok3]

ton implementation avec la classe Matrice doit probablement faire un tres grand nombre de copy de celle ci et donc egalement de ton vector<vector<double> >

evite les copies

[salseropom]

Oui je pense que le pb vient de là.

Voici ma fct qui multipile deux matrices :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
typedef unsigned int uint;
 
Matrice Matrice::operator*(const Matrice & mat)
{
  // produit de deux matrices
  assert(NB_COL==mat.NB_LIGNE);
  Matrice temp(NB_LIGNE,mat.NB_COL);
  for(uint i=0;i<NB_LIGNE;i++)
    {
      for(uint j=0;j<mat.NB_COL;j++)
	{
	  double s=0.; // somme temporaire
	  for(uint k=0;k<NB_COL;k++)
	    s+=m[i][k]*mat.m[k][j];
	  temp.m[i][j]=s;
	}
    }
  return temp;
}

Mais comment éviter la copie de la matrice temp ? Car celle-ce sera effacer à la fin de la fonction donc je ne vois pas trop comment utiliser un pointeur par exemple.

[Gandalf]

Typiquement il faut eviter les operateurs mathematique binaires, et leur preferer les version affectation qui ne necessitent pas de copie (+=, *=)

La solution la plus evoluée est de faire une classe Matrix_Prod qui permet de designer le produit de deux matrices sans le calculer effectivement (idem pour la somme, de maniere à ne faire le cacul du produit qu'au moment de l'affectation...

[Luc Hermitte]

S'il ne s'agit pas d'un projet scolaire/éducatif/..., des bibliothèques comme Blitz++, boost.uBLAS, ..., seront tes meilleures amies.

[FVIRTMAN]

Bon, il est clair que c'est la copie qui te bouffe.

Uns solution :
sachant que ta matrice temp est toujours ré-écrite entiermeent, au lieu de la réallouer a chaque fois, en copiant, tu fais une matrice globale temp, que tu n'alloue donc pas du tout, et tu écris tes résultats dedans directement. Elle te sert de "cache" de réponse.

[salseropom]

Bonjour, merci de vos nombreuses réponses !
Mais j'ai un peu de mal à tout comprendre :
Gandalf, tu m'as dit :

de maniere à ne faire le cacul du produit qu'au moment de l'affectation...

si je fais C=A*B, est-ce que là je fais le produit A*B au moment de l'affectation ?

Sinon je n'ai aucune idée de comment implémenter la classe Matrix_Prod. Peux-tu m'être un peu plus clair (sachant que je débute le c++) ?

Luc Hermitte, non il ne s'agit pas d'un sujet scolaire mais j'ai besoin d'une classe Matrice pour mon prgm (qui est pour mon boulot). Je suis allé voir sur google tes renseignements mais sais-tu comment installer des librairies sous linux ?
Mais je ne te cache pas que j'aimerais bien savoir coder une "bonne" classe de Matrice (cad que j'aimerais savoir implémenter (juste pour mes connaissances de C++) l'idée de Gandalf avec sa classe Matrix_Prod)

FVIRTMAN, Loulou (le redacteur de ce forum) m'avait mis en garde contre les variables globales.
Mais dans ma fonction qui multiplie deux matrices, où dois-je mettre cette matrice globale ?

Merci encore de votre patience !

[dok3]

d'une maniere generale evite les variables globales, c'est tres piege

pour les library qui on ete cite plus haut c'est essentiellement des templates donc il suffit d'inclure le bon fichier, rien a installer, tu decompresse les .h tu les rajoute a la compilation et voila

[Laurent Gomila]

En ce qui concerne les techniques d'optimisation sur les matrices tu as notamment les expression templates, utilisées par toutes les bibliothèques qu'on t'a citées plus haut. Ca permet de n'effectuer les calculs qu'au moment de l'affectation, ça rejoint ce que te disait Gandalf.

Tu peux aller voir là pour voir à quoi ça ressemble : http://loulou.developpez.com/tutorie...metaprog/#L3.3

[Luc Hermitte]

Blitz++ est je trouve la première grosse bonne référence sur le sujet.
Je ne peux que te conseiller de lire les articles disponibles sur le site de la bibliothèque.

boost.uBLAS a l'air de reprendre les techniques de Blitz++.

Pour l'installation, il suffit de suivre les indications données pour chacune des bibliothèques.
De façon générale pour installer (et compiler!!) une bibliothèque (/un logiciel) Sous *nix, il suffit d'un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
./configure --avec-les-bonnes-options
make
make install

Boost utilise un autre outil, bjam, dont il existe des versions précompilées.