Discussion :

[vbbarent]

Bonjour à tous;
je desire calculer la valeur mediane d'un vecteur (ou d'un tableau). Alors j'ai écrit le code suivant:

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
21
22
23
24
25
26
27
28
29
30
 
void CalculMediane(float *tab, int nb_ech, float *mediane, float *max, float *min)
 
{	
   *mediane=0.0;
    *max=0.0;
    *min=0.0;
	int i,per=1;
	float tmp;
	while (per == 1)
	{
		per = 0;
		for (i=0; i<nb_ech; i++)
		{
			if (tab[i] > tab[i+1])
			{
				tmp = tab[i];
				tab[i] = tab[i+1];
				tab[i+1] = tmp;
				per = 1;
			}
		}
	}
 
	*min = tab[0];
	*max = tab[nb_ech-1];
	*mediane = (tab[nb_ech/2 -1] + tab[nb_ech/2])/2;
	//Attention : cas d'un tableau contenant n = 2*k echantillons;
 
}

Ce code me permet de calculer la valeur mediane d'un tableau. Mon problème est que je manipule des données et j'ai besoin de supprimer certaines valeurs comme ce qui suit:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
 vector<double> tabs0;
 for (int j=0;j<257;j++)
		 {
			 if(lignebase[j]!=0)
			 {
				 tabs0.push_back(lignebase[j]);
 
			 }
		 }

Je voudrais calculer la valeur mediane de mon nouveau vecteur comme suit:

Code :

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

1
2
3
 
 float  mediane, M, m;
CalculMediane(tabs0,tabs0.size(),&mediane,&M,&m);

A la compilation, j'obtiens une erreur "no matching function for call to CalculMediane(......)";

Merci pour votre aide;

[Luc Hermitte]

Tu as toutes les fonctions qu'il faut dans <algorithm>.

[vbbarent]

J'ai été sur le forum algorithme mais je n'ai pas trouvé un exemple qui puisse me débloquer.

[Luc Hermitte]

Je n'ai jamais fait allusion au forum "algorithmes", mais au fichier d'en-tête standard <algorithm> (d'où les chevrons) -> http://r0d.developpez.com/articles/algos-stl/

[grouff]

salut,

redéfini calculMediane avec un vector<double> &, plutôt qu'un pointeur sur un float, et le compilateur te trouvera une correspondance. Et tant qu'à faire, tu pourrais même utiliser la fonction "sort" de algorithm, au lieu t'embéter :

http://www.cplusplus.com/reference/algorithm/sort.html

[Luc Hermitte]

Même std::sort, c'est s'embêter quand on peut directement accéder au N/2 i-ème.

[koala01]

Salut,

L'un des grands avantages du C++, c'est qu'il permet de renvoyer une valeur en sortie des fonctions...

Du coup, les arguments sont à considérer, en priorité, comme des données entrantes (des données nécessaires à la fonction pour qu'elle puisse faire son travail).

Il ne faut en effet considérer de créer des arguments "in/out" que si tu n'as vraiment pas le choix (que les modifications apportées à plusieurs "objets" dans une fonction doivent être répercutées dans la fonction appelante)

De plus, le C++ fournit la possibilité d'utiliser des références, qui sont largement plus faciles à utiliser que les pointeurs.

Du coup, il est également préférable de choisir de passer les arguments in/out sous forme de référence non constante plutôt que sous forme de pointeurs, à moins que l'on n'ait de nouveau pas le choix.

Tu peux donc simplifier la signature de ta fonction sous une forme proche de

Code :

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

float CalculMediane(float *tab, int nb_ech,float &max, float &min)

En effet, le code que tu fournis semble indiquer que tu veux garder la valeur correcte non seulement de la médiane, mais également du minimum et du maximum...

Mais le fait d'utiliser des références te permet d'écrire le code exactement comme s'il s'agissait, pour min et max, de réels tout ce qu'il y a de plus classiques, et donc de t'éviter les problèmes liés au déréférencement et à l'utilisation de "l'adresse de la variable".

L'appel de la fonction devenant alors

Code :

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

float mediane=CalculerMediane(tabs0,tabs0.size(),M,m);

(tu ne trouves pas cela plus simple )

Enfin, il faut quand même se rappeler que le C++ est un langage orienté objet, et qu'il semblerait peut être opportun de réfléchir à une conception sous cette forme (mais ca, c'est un autre débat )

Mais, même en ne considérant pas l'orientation objet du C++, ne crois tu pas qu'il serait opportun de travailler avec des structures "qui vont bien", dont une qui regrouperait les informations obtenues lors du calcul de la médiane (le minimum, le maximum et la médiane, en l'occurrence), qui ressemblerait par exemple à:

Code :

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

1
2
3
4
5
6
7
8
9
struct MinMaxMed
{
    float min; // le minimum
    float max; // le maximum
    float med; // la médiane
    /*juste "pour le fun" */
    MinMaxMed(float min, float max, float med):min(min), 
             max(max),med(med){}
};

et qui te permettrait encore de simplifier la signature de la fonction sous une forme proche de

Code :

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

MinMaxMed CalculerMediane(float*tab,int size)

(c'est encore mieux, non )

Dont l'implémentation prendrait alors la forme de (en prenant en compte l'existence du type booléen, qui fournit uniquement les valeur true et false

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
21
22
23
 
MinMaxMed CalculerMediane(float*tab,int size)
{
    /* on commence par trier le tableau */
    bool permutation=true; /* j'aime bien les noms de variables qui me disent
                           * précisément ce qu'elles font :D
                           */
    while (permutation==true)
    {
        permutation=false;
        for(int i=0;i<size+1;++i)
        {
            if(tab[i]<tab[i+1])
            {
                double tmp=tab[i+1];
                tab[i+1]=tab[i];
                tab[i]=tmp;
                permutation=true;
            } 
        }
    }
    return MinMaxMed(tab[0],tab[size-1],(tab[nb_ech/2 -1] + tab[nb_ech/2])/2);
}

et qui pourrait alors être appelée sous la forme de

Code :

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

1
2
3
4
5
6
 
float *tab=NULL;
int size = 10;
tab= new float[size];
/*...*/
MinMaxMed result=CalculerMediane(tab, size);

Maintenant, étant donné que tu décide d'utiliser la classe vector, tu peux même encore simplifier la signature sous une forme proche de

Code :

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

MinMaxMed CalculerMediane(std::vector<float>& tab);

dont l'implémentation prendrait en compte le fait que la classe vector connait le nombre d'éléments qu'elle contient et qui fera que l'appel devienne tout simplement de l'ordre de

Code :

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

1
2
3
std::vector<float> myVector;
/*...*/
MinMaxMed result=CalculerMediane(myVector)

(n'est-ce pas là le rafinement suprême )

Et, bien sur, comme l'ont sussuré les autres, tu devrais aller faire un petit tour du côté du fichier d'en-tête <algorithm> (et de l'article de rüd qui le concerne )

[Médinoc]

Et pour parfaire, on remplace tous les int devant faire office d'indexes ou de taille de tableaux par des size_t.

[koala01]

Et pour parfaire, on remplace tous les int devant faire office d'indexes ou de taille de tableaux par des size_t.

De fait...

Disons que ca, c'est vraiment pour parfaire une fois que l'on utilise la classe vector...

Dans les autres cas, c'est moins nécessaire (quoi que cela puisse être utile, sur les tableaux particulièrement important )

En fait, je ne voulais pas *trop* modifier l'existant quand meme (je l'ai déjà fait un sérieux coup )

[vbbarent]

Merci beaucoup pour votre aide. En effet cette fonction fait partie d'une classe. L'idée de la structure est très interssante mais je ne sais pas exactement où la placer (avant la declaration de la classe je pense); voilà ce que je fais:

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
21
22
23
24
#include <vector>
using namespace std;
#ifndef DETECTION_H_
#define DETECTION_H_
 
struct MinMaxMed
{
    float min; // le minimum
    float max; // le maximum
    float med; // la médiane
    MinMaxMed(float min, float max, float med):min(min), 
             max(max),med(med){}
};
class Detection
{
public:
 
	void highpass(float *sig,float *sigfiltre, double *h,int nbech, int ncoef);
	void EnvelopEnergie(float *sigin, float *sigOut, int n);	
	void seuillage(float *sigin,float *sigSeuille,float *ligneBase, float seuil,int taille);	
  MinMaxMed CalculerMediane(float *tab,int size);
};
 
#endif /*DETECTION_H_*/

en suivant vos indications, je fais l'implémentation de la méthode comme suit:

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
21
float Detection::CalculerMediane(vector<double> &tab,int size)
{
    /* on commence par trier le tableau */
    bool permutation=true; /* j'aime bien les noms de variables qui me disent
                           * précisément ce qu'elles font :D
                           */
    while (permutation==true)
    {
        permutation=false;
        for(int i=0;i<size+1;++i)
        {
            if(tab[i]<tab[i+1])
            {
                double tmp=tab[i+1];
                tab[i+1]=tab[i];
                tab[i]=tmp;
                permutation=true;
            } 
        }
    }
    return MinMaxMed(tab[0],tab[size-1],(tab[size/2 -1] + tab[size/2])/2);

Je n'arrive pas à compiler: erreur"candidate is: MinMaxMed Detection::CalculerMediane(std::vector<float, std::allocator<float> >&, int)"

Je ne sais pas exactement ce qu'il faut faire;