Discussion :

[oodini]

Hello,

Il y a moyen d'éviter de créer un tel monstre ? Et est-ce vraiment un montre ?
Existe-t-il une structure de données (Boost ?) pour cela ?

[gbdivers]

Bonjour

1. oui, en utilisant un vecteur simple et en calculant l'index avec une fonction du genre :

Code :

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

T at(x, ,y, z) { return data[x+y*xdim+z*xdim*ydim); }

2. oui, c'est un monstre
3. oui, boost multi array

[oodini]

Bonjour

1. oui, en utilisant un vecteur simple et en calculant l'index avec une fonction du genre :

Code :

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

T at(x, ,y, z) { return data[x+y*xdim+z*xdim*ydim); }

2. oui, c'est un monstre
3. oui, boost multi array

1. Dans ce cas là, autant se passer du vecteur pour la 1ère dimension, et passer directement en pointeurs. :-)
2. Faudra que je el mette de côté pour Halloween.
3. Apparemment, il n'y a pas moyen de faire croître le tableau comme avec un push_back().

[screetch]

tu y es arrivé comment pour avoir besoin de ce genre de structure de stockage?
ca pourrait venir d'un problème de conception bien plus haut, et peut-être l'intervention chirurgicale (boost::multi_array) n'est pas le plus efficace; peut-être repensé au problème dans sa globalité pour comprendre pourquoi tu as besoin d'une structure aussi compliquée.

[oodini]

Parce que je récupère des données d'une base de données, que je dois faire pour chacun des éléments des calculs à la noix qui dépendent des autres données, qui finissent elles-même par être mises à jour par ledit calcul, et que que je ne peux sans arrêt faire des lectures/écritures dans la base de données.

[screetch]

je ne suis pas sur de saisir le problème en entier mais am on avis, tu n'as pas reellement cerné le problème et divisé en parties "manageable": le problème est trop compliqué a résoudre et donc tu dois passer par des structures compliquées.

Je dirai que le problème est la, pas dans le vector de vector de vector

[oodini]

Je te rejoins sur le diagnostic. :-)

En fait, je dois boucler sur des jours et des heures.
Les jours et les heures peuvent tous deux être au tarif plein ou creux.
Une troisième dimension (non temporelle) vient s'ajotuer à cela.

Je dois effectuer des opérations (moyennes pondérées, etc.) prenant en compte les jours/heures/[3ème paramètre] du même type.

Comment faire ? Graphe ?...

En fait, je dois reproduire une base de données, avec des requêtes du genre :

Code :

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

SELECT * WHERE critère_1, critère_2, critère_3

[Joel F]

ok genre donc une structure avec trois champs et non pas un tableau 3D

[oodini]

Oui, sauf que n'ayant pas de mécanisme de sélection en fonction du contenu de ces champs, il me semblait que la meilleure méthode était d'utiliser des indices de tableaux.

[gbdivers]

boost::multi_index (je sais pas ce que j'ai avec boost en ce moment )

Sinon, il suffit de fournir les foncteurs adéquates pour travailler sur le(s) critère(s) qui t’intéresse (ou mieux, utiliser les lambdas).

EDIT :
si les performance sont critiques, peut être qu'il est possible d'utiliser des map pour les critères (peut être que c'est ce que fait boost::multi_index) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
std::vector<Data> data;
typedef std::vector<Data>::iterator iterator;
map<critère1, iterator> c1;
map<critère2, iterator> c2;
map<critère3, iterator> c3;
 
void add(critère1, critère2, critère3, data)
{
   data.push_back(data);
   c1.insert(make_pair(critère1, data.end()-1);
   c2.insert(make_pair(critère2, data.end()-1);
   c3.insert(make_pair(critère3, data.end()-1);
}

c'est peut être un peu tordu (et le coût de création sera très important)

[oodini]

Je suis parti sur une solution très tordue à base de map. Pour créer la clé, je me sers de mes trois variables pour cnstituer un entier: une pour les centaines, une pour les dizaines, et une pour les unités. :-)

En valeur, j'ai un vecteur de tous les objets qui répondent aux trois critères.

[3DArchi]

Salut,

boost::multi_index (je sais pas ce que j'ai avec boost en ce moment )

Sinon, il suffit de fournir les foncteurs adéquates pour travailler sur le(s) critère(s) qui t’intéresse (ou mieux, utiliser les lambdas).

EDIT :
si les performance sont critiques, peut être qu'il est possible d'utiliser des map pour les critères (peut être que c'est ce que fait boost::multi_index) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
std::vector<Data> data;
typedef std::vector<Data>::iterator iterator;
map<critère1, iterator> c1;
map<critère2, iterator> c2;
map<critère3, iterator> c3;
 
void add(critère1, critère2, critère3, data)
{
   data.push_back(data);
   c1.insert(make_pair(critère1, data.end()-1);
   c2.insert(make_pair(critère2, data.end()-1);
   c3.insert(make_pair(critère3, data.end()-1);
}

c'est peut être un peu tordu (et le coût de création sera très important)

Puisqu'on en est avec boost, autant construire l'itérateur ad-hoc avec Boost.iterator pour aller chercher le champ qui t'intéresse.

[Emmanuel Deloget]

ok genre donc une structure avec trois champs et non pas un tableau 3D

Je dirais même plus : il y a de forte chance que le tableau 3D soit presque vide, ce qui tendrait à monter qu'il n'est pas la bonne solution (si l'OP a 100 éléments à mettre dans un tableau de 10x10x10, alors celui-ci est vide à 90%).

[oodini]

D'où mon utilisation, au final, d'un map à base d'un entier reconstitué.
Conceptuellement, il eût fallu un tuple, mais la recherche dans le map aurait été moins efficace (je pense).

[raphchar]

En fait, je dois reproduire une base de données, avec des requêtes du genre :

Code :

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

SELECT * WHERE critère_1, critère_2, critère_3

Ca ne fait que du 2D là, pas du 3D, donc un vecteur de vecteur ?

[koala01]

Salut,

Pourquoi ne pas tout simplement faire une structure avec tes trois données, et t'amuser avec les foncteurs qui vont bien

La structure serait proche de

Code :

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

1
2
3
4
5
6
struc Data
{
    int valeur1_;
    int valeur2_;
    int valeur3_;
};

que tu placerais dans un vecteur simple (std::vector<Data> )

et tu aurais une "batterie" de foncteurs correspondant à tes différents besoins :

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
31
32
33
34
struct less
{
    bool operator ()(Data const & first, Data const & second) const
    {
        return first.valeur1_ < second.valeur1 ||
 
               (first.valeur1_ == second.valeur1_ && 
                 first.valeur2_<second.valeur2_) ||
 
               (first.valeur1_ == second.valeur1_ && 
                 first.valeur2_<second.valeur2_ &&
                  first.valeur3_<second.valeur3_ );
    }
};
struc secondLess
{
    bool operator ()(Data const & first, Data const & second) const
    {
        return first.valeur1_ < second.valeur1 ||
 
               first.valeur2_<second.valeur2_ ||
 
               first.valeur3_<second.valeur3_ ;
    }
}
 
struc onlyValue1
{
    bool operator ()(Data const & first, Data const & second) const
    {
        return first.valeur1_ < second.valeur1  ;
    }
};
/*  ... */

tu remplis ton vecteur une bonne fois pour toutes, puis tu le tries sur base de tes besoins (en essayant de faire en sorte de regrouper les utilisations des différents tris )

Dans le pire des cas, il suffira de rajouter un foncteur pour LE cas particulier de tri auquel tu n'auras pas pensé quand tes manipulations deviendront plus complexes

[oodini]

Quel serait l'intérêt de cette méthode par rapport au map ?

[koala01]

Le principal intérêt serait que tu n'aurais besoin que d'un seul vecteur, que tu tries "à la demande", alors qu'avec les map, tu serais obligé de le copier à chaque fois que tu veux faire un tri différent

En effet, il ne me semble pas qu'il soit possible de changer le foncteur de tri une fois que la map existe

Si tu as de nombreux enregistrements, cela peut te faire économiser pas mal de mémoire, sans compter que le tri est * peut etre * plus rapide dans cet ordre que s'il faut à chaque fois recopier l'intégralité de la map

Et surtout, c'est "simplement" plus facile, car tu peux manipuler des itérateurs "simple" et non des itérateur composés de paires

[oodini]

Je n'ai pas besoin d'un ordre de tri particulier, et je ne vois pas en quoi j'économiserais de la mémoire, car la clé serait dans le vecteur plutôt que dans le map.

Le seul argument serait celui relatif à la manipulation des paires (honni soit qui mâle y pense). Mais je ne le trouve pas si critique.

Je trouve que l'utilisation des map est en outre plus conforme à une conception intuitive de ce qu'il faut coder.

[jblecanard]

Tu peux créer ta structure et t'en servir de clé pour une map, pour peu que tu aies implémenté les bons foncteurs dessus. Ca t'évite la magouille de reconstitution d'entier et ça ne sera pas particulièrement moins efficace. Par contre faut bien choisir ta structure avant de te taper l'implémentation des foncteurs et des itérateurs.