L'initialisation d'un C++ d'un vecteur aléatoire à valeurs rapide...

aujourd'hui, ce devrait être vraiment rapide étant donné que la boucle ne sera pas exécuté.

Personnellement, je serais probablement utiliser quelque chose comme ceci:

struct gen_rand { 
    double range;
public:
    gen_rand(double r=1.0) : range(r) {}
    double operator()() { 
        return (rand()/(double)RAND_MAX) * range;
    }
};

std::vector<double> x(num_items);
std::generate_n(x.begin(), num_items, gen_rand());

Edit: C'est purement une micro-optimisation qui pourrait faire aucune différence, mais vous pourriez envisager de réorganiser le calcul pour obtenir quelque chose comme:

struct gen_rand { 
    double factor;
public:
    gen_rand(double r=1.0) : factor(range/RAND_MAX) {}
    double operator()() { 
        return rand() * factor;
    }
};

Bien sûr, il ya une très bonne chance que le compilateur va déjà le faire (ou quelque chose d'équivalent), mais il ne fera pas de mal à essayer quand même (même si c'est vraiment susceptible d'aider à l'optimisation éteint).

Edit2: "sbi" (comme c'est généralement le cas) est la droite: vous pourriez gagner un peu en réservant de l'espace, puis à l'aide d'un itérateur d'insertion pour mettre les données en place:

std::vector<double> x;
x.reserve(num_items);
std::generate_n(std::back_inserter(x), num_items, gen_rand());

Comme avant, nous sommes dans une telle microscopique de l'optimisation, je ne suis pas sûr que je serais vraiment attendre pour voir une différence. En particulier, puisque c'est fait avec des modèles, il ya une très bonne chance que la plupart (si pas tous), le code sera généré en ligne. Dans ce cas, l'optimiseur de requête est susceptible d'avis que les données initiales de tous est écrasée, puis passez à l'initialisation.

En fin de compte, cependant, presque la seule partie qui est vraiment probablement de faire une différence importante est de se débarrasser de la .at(i). Les autres pourrait, mais avec les optimisations activées, je ne serais pas vraiment attendre d'eux.

OriginalL'auteur Jerry Coffin

Oui, alors que x.à(i) la vérification des limites, x[i] ne pas le faire. Aussi, votre code est incorrect, car vous avez omis de spécifier la taille de x à l'avance. Vous avez besoin d'utiliser std::vector<double> x(n), où n est le nombre d'éléments que vous souhaitez utiliser; sinon, votre boucle, il n'y aura jamais exécuter.

Alternativement, vous pouvez personnaliser un itérateur pour générer des valeurs aléatoires et de le remplir à l'aide de l'itérateur; parce que le std::vector constructeur permet d'initialiser l'un de ses éléments, de toute façon, donc si vous avez une coutume classe iterator qui génère des nombres aléatoires, vous pouvez être en mesure d'éliminer une passe sur les éléments.

En termes de mise en œuvre d'un itérateur de votre propre, voici mon code non testé:

 class random_iterator
 {
     public:
         typedef std::input_iterator_tag iterator_category;
         typedef double value_type;
         typedef int difference_type;
         typedef double* pointer;
         typedef double& reference;

         random_iterator() : _range(1.0), _count(0) {}
         random_iterator(double range, int count) : 
                                         _range(range), _count(count) {}
         random_iterator(const random_iterator& o) : 
                                         _range(o._range), _count(o._count) {}
         ~random_iterator(){}

         double operator*()const{ return ((rand()/(double)RAND_MAX) * _range); }
         int operator-(const random_iterator& o)const{ return o._count-_count; }
         random_iterator& operator++(){ _count--; return *this; }
         random_iterator operator++(int){ random_iterator cpy(*this); _count--; return cpy; }
         bool operator==(const random_iterator& o)const{ return _count==o._count; }
         bool operator!=(const random_iterator& o)const{ return _count!=o._count; }

     private:
         double _range;
         int _count;
 };

Avec le code ci-dessus, il devrait être possible d'utiliser:

std::vector<double> x(random_iterator(range,number),random_iterator());

Cela dit, la génération de code pour l'autre solution est plus simple, et franchement, je me permets juste de remplir de façon explicite le vecteur sans avoir recours à quelque chose de compliqué comme ça.... mais c'est cool de penser.

OriginalL'auteur Michael Aaron Safyan

Vous pouvez envisager d'utiliser un générateur de nombres pseudo aléatoires qui donne en sortie une séquence. Depuis plus PRNGs, il suffit de fournir une séquence de toute façon, ce sera beaucoup plus efficace que de simplement appeler rand() maintes et maintes fois.

Mais ensuite, je pense que j'ai vraiment besoin d'en savoir plus sur votre situation.

• Pourquoi ce morceau de code à exécuter à ce point? Pouvez-vous restructurer votre code pour éviter de re-génération de données aléatoires si souvent?
• De quelle taille sont vos vecteurs?
• Comment "bien" est-ce que votre générateur de nombre aléatoire? De haute qualité, les distributions ont tendance à être plus coûteux à calculer.
• Si vos vecteurs sont grandes, êtes-vous réutiliser leur espace tampon, ou êtes-vous de le jeter et à réaffecter ailleurs? La création de nouveaux vecteurs de bon gré mal gré est un excellent moyen de détruire votre cache.

OriginalL'auteur Tom

int main() {
  int size = 10;
  srand(time(NULL));
  std::vector<int> vec(size);
  std::generate(vec.begin(), vec.end(), rand);

  std::vector<int> vec_2(size);
  std::generate(vec_2.begin(), vec_2.end(), [](){ return rand() % 50;})
}

Vous devez inclure vecteur, l'algorithme, le temps, cstdlib.

OriginalL'auteur Taras Shevchenko