Discussion :

[deubelte]

Je voudrais remplir/parcourir/repérer et selection des valeurs un tableau, d'une taille 20000*100 (au maximum),
Je sais que le meilleur moyen est d'utiliser un vector.
Mais quel est le moyen le plus rapide pour passer d'un élément a un autre?
Faut il utiliser les pointeurs... ?
Merci

[Laurent Gomila]

Un pointeur, ou un itérateur (qui est assimilable à un pointeur).

[deubelte]

Ok, c'est ce que je pensais.

Quand je fais:

Code :

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

1
2
3
4
5
6
 
int main(){
 
     vector<double > tableaux;
    tableaux[3]=3;
}

Ca plante. J'imagine que c'est parce que; j'ai pas spécifié la taille du tableaux,
j'ai pas rentré 3avec un itérateur.

[nikko34]

Ca plante. J'imagine que c'est parce que; j'ai pas spécifié la taille du tableaux

tu n'as pas besoin avec un vector.

Pour ajouter une donnée:

Code :

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

1
2
 
tableau.push_back( 3 );

j'ai pas rentré 3avec un itérateur.

l'itérateur sert à parcourir ton tableau, pas à le remplir.

Je te conseille de chercher de la documentation sur ce que tu utilises, essayer au hasard n'est pas vraiment la bonne méthode

[deubelte]

ok
merci, c'est ce que j'ai fait:
voici le code:
Merci de le corriger, afin de l'optimiser,(meme si je pense pas qu'il y ait vraiment besoin de l'optimiser vu la taille)
Est-ce la manière la plus rapide de remplir?

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
 
using namespace std;
int main(){
     double i,j;
      vector<double > lignes ;
 
      vector<vector<double> > tableaux ;
 
 for (j=0;j<=100;j++){
  for(i=0;i<=10000;i++){
    lignes.push_back(i);
  }
   tableaux.push_back(lignes);
 }
}

[olive_le_malin]

ben teste le comme ça, et compare en faisant un remplissage par accés direct avec [].

[Sébastien P]

Salut, C'est une méthode correcte que tu utilise !

Maintenant si ton objectif est une optimisation à tout prix comme je voix que tu connais tes valeur max pour i et j tu pourrais vraiment te passer des vecteurs ou si tu aime ça quand même tu pourrais déclarer leur taille à la déclaration car push_back n'est pas forcément la plus rapide des méthodes de cette classe.

Et ensuite pour le remplir ben par exemple en le parcourant avec iterateurs !!!

Voila bon courage ++
Seb

[deubelte]

"pourrais vraiment te passer des vecteurs ou si tu aime ça quand même tu pourrais déclarer"

On m'a dit que les vecteurs étaient les plus rapides.

Qu'est ce que tu proposes de mieux pour aller plus vite?

[Sébastien P]

En fait la question utile est la suivante : ton tableau a-t-il une taille fixe ou flexible ( durant l'exécution ) si taille flexible => vector sinon tableau classique tout simplement ......

++
Seb

[deubelte]

la taille ne varie pas. On sait quelle sera la taille du tableau avant d'entrer dans la fonction qui manipule le tableau.
Donc si je t'écoute, je prends un tableau normale.

[Luc Hermitte]

Tableau "normal", cela ne veux rien dire.

Vu la taille, tu oublies les tableaux statiques.
Il faut donc passer à des solutions dynamiques.
Tu as le couple new[]/delete[] que je déconseille tant que l'on n'a pas compris comment fonctionne les exceptions. Qui plus est, si tu veux pouvoir être redimensionné, c'est la cata.

Viennent après les vecteurs qui peuvent avoir des coûts de 0-initialisation (avec resize()) ou pas (avec reserve(), mais là on paie un test lors des push_back).

Ceci dit, avec ta structure rectangulaire, je m'orienterai plutôt vers des conteneurs et autres solutions spécialisées -> boost.multi_array (pour les objets quelconque), boost.uBlas (pour les matrices et autres vecteurs mathématiques), Blitz++, ATLAS, ...

J'avais pondu ça il y a quelques temps -> http://www.developpez.net/forums/sho...8&page=1&pp=15

[deubelte]

Ouais, mais s'il faut utiliser la technologie Boost, (que je ne connais pas) ca devient tres complexe. Mais je veux bien regader.
merci

[loufoque]

Réserve la mémoire quand même avant peut-être.
Ou alors détermine directement la taille, mais ça initialisera tout à 0.

[olive_le_malin]

Ou alors détermine directement la taille, mais ça initialisera tout à 0.

Oui et dérrière tu fais tes affectations avec l'operateur [] et compare les perf par rapport aux push_back

[deubelte]

je suis en train d'installer Boost. Ca prend pas mal de temps.
Je vais faire comme a dit Luc, a savoir l'utilisation de matrice.
Je ne comprend pas ce que dit olive_le_malin quand il parle de [].

[olive_le_malin]

salut,
Regarde là :
http://c.developpez.com/faq/cpp/?page=STL#STL_vector

C'est l'opérateur [] :

Code :

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

1
2
3
4
5
6
7
8
9
 
lignes.resize(10000);
tableaux.resize(100);
for (j=0;j<=100;j++){
  for(i=0;i<=10000;i++){
    lignes[i] = i;
  }
   tableaux[j]=lignes;
 }

Je sais pas si c'est + rapide ...

[deubelte]

j'ai réussi a installé Boost.
Comme je l'ai déja dit, je dois remplir un tableau de 10000 par 100, au minimum. Le nombre de lignes et de colonnes sont connus dès le début.
Comme le dit Luc, le moyenle plus rapide est donc bien l'utilisation de boost boost.uBlas pour les matrices ?

[Luc Hermitte]

Disons qu'elle devient intéressante si tu profites des fonctions fournies avec -- si tu manques de perf, il y a moyen de la combiner avec d'autres libs de ce que j'a lu.

Autrement, pour l'accès avec des [][], ce devrait être comme avec les autres techniques.

[deubelte]

j'ai essayé deux méthodes:
Celle-ci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>
using namespace std;
using namespace boost::numeric::ublas;
int main () {
 
    matrix<double> m (10000, 200);
    for (unsigned i = 0; i < m.size1 (); ++ i)
        for (unsigned j = 0; j < m.size2 (); ++ j)
            m (i, j) = 3 * i + j;
 
 
}

Ca fonctionne très bien, très rapide pour 10000*200.

J'ai comparé avec :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
using namespace std;
int main(){
 
 
     double A[10000][100];
    int i,j,k;
 
  for(j=0;j<10000;j++){
     for(i=0;i<100;i++){
         A[j][i]=3 * i + j;
   }
  }

c'est meme pas la pein d'essayé, ca plante. Je pense pas que mon code ait une erreur. C'est que 10000 est trop gros. Dépassement de mémoire.

La question est:
Peux-tu m'expliquer pq Boost est bcp plus puissant?

[loufoque]

Ton second code plante parce que tu fais une allocation de très grande taille sur la pile qui n'est pas suffisamment grande.
Je me demande d'ailleurs si des compilateurs intelligents pourraient pas détecter ça et éventuellement adapter la taille de la pile en conséquence...