Random float-Zahl generation

C++11 gibt Ihnen eine Menge neuer Möglichkeiten mit random. Die kanonische Papier zu diesem Thema wäre N3551, Random Number Generation, die in C++11

Sehen, warum mit rand() problematisch sein kann, siehe die rand() considered harmful Präsentation material von Stephan T. Lavavej, die Sie während der GoingNative 2013 Veranstaltung. Die Folien sind in den Kommentaren aber hier ist ein direkter link.

Ich auch cover boost sowie mit rand seit legacy-code benötigen noch Ihre Unterstützung.

Beispiel unten ist destilliert aus dem cppreference Website und verwendet die std::mersenne_twister_engine Motor und die std::uniform_real_distribution generiert zahlen in der [0,10) Intervall, mit anderen Motoren und Distributionen auskommentiert (sehen Sie es live):

#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <random>

int main()
{
    std::random_device rd;

    //
    //Engines 
    //
    std::mt19937 e2(rd());
    //std::knuth_b e2(rd());
    //std::default_random_engine e2(rd()) ;

    //
    //Distribtuions
    //
    std::uniform_real_distribution<> dist(0, 10);
    //std::normal_distribution<> dist(2, 2);
    //std::student_t_distribution<> dist(5);
    //std::poisson_distribution<> dist(2);
    //std::extreme_value_distribution<> dist(0,2);

    std::map<int, int> hist;
    for (int n = 0; n < 10000; ++n) {
        ++hist[std::floor(dist(e2))];
    }

    for (auto p : hist) {
        std::cout << std::fixed << std::setprecision(1) << std::setw(2)
                  << p.first << ' ' << std::string(p.second/200, '*') << '\n';
    }
}

Ausgabe ähnlich der folgenden:

0 ****
1 ****
2 ****
3 ****
4 *****
5 ****
6 *****
7 ****
8 *****
9 ****

Die Ausgabe variieren je nachdem, welche distribution Sie wählen, so dass, wenn wir beschlossen zu gehen mit std::normal_distribution mit einem Wert von 2 für beide bedeuten und stddev z.B. dist(2, 2) stattdessen die Ausgabe ähnlich wie diese (sehen Sie es live):

-6 
-5 
-4 
-3 
-2 **
-1 ****
 0 *******
 1 *********
 2 *********
 3 *******
 4 ****
 5 **
 6 
 7 
 8 
 9 

Folgende ist eine modifizierte version von einigen der dargestellten code in N3551 (sehen Sie es live) :

#include <algorithm>
#include <array>
#include <iostream>
#include <random>

std::default_random_engine & global_urng( )
{
    static std::default_random_engine u{};
    return u ;
}

void randomize( )
{
    static std::random_device rd{};
    global_urng().seed( rd() );
}

int main( )
{
  //Manufacture a deck of cards:
  using card = int;
  std::array<card,52> deck{};
  std::iota(deck.begin(), deck.end(), 0);

  randomize( ) ;  

  std::shuffle(deck.begin(), deck.end(), global_urng());
  //Display each card in the shuffled deck:
  auto suit = []( card c ) { return "SHDC"[c / 13]; };
  auto rank = []( card c ) { return "AKQJT98765432"[c % 13]; };

  for( card c : deck )
      std::cout << ' ' << rank(c) << suit(c);

   std::cout << std::endl;
}

Ergebnisse ähnlich sieht:

5H 5S ALS 9S 4D 6H TH 6D KH-2S QS 9H 8H 3D-KC TD-7H 2D-KS 3C TC 7D 4C QH QC QD JD AH JC AC-KD 9D 5C 2H 4H 9C 8C JH 5D 4S 7C AD-3S-8S TS 2C 8D 3H-6C JS 7S 6S

Boost

Natürlich Boost.Random ist immer eine option, hier bin ich mit boost::random::uniform_real_distribution:

#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_real_distribution.hpp>

int main()
{
    boost::random::mt19937 gen;
    boost::random::uniform_real_distribution<> dist(0, 10);

    std::map<int, int> hist;
    for (int n = 0; n < 10000; ++n) {
        ++hist[std::floor(dist(gen))];
    }

    for (auto p : hist) {
        std::cout << std::fixed << std::setprecision(1) << std::setw(2)
                  << p.first << ' ' << std::string(p.second/200, '*') << '\n';
    }
}

rand()

Wenn Sie verwenden müssen rand() dann können wir gehen, um die C FAQ für einen Führer auf Wie kann ich generieren Fließkomma-Zufallszahlen? , die im Grunde gibt ein Beispiel, ähnlich wie dies für die Erzeugung einer auf das Intervall [0,1):

#include <stdlib.h>

double randZeroToOne()
{
    return rand() / (RAND_MAX + 1.);
}

und zum generieren einer zufälligen Zahl im Bereich von [M,N):

double randMToN(double M, double N)
{
    return M + (rand() / ( RAND_MAX / (N-M) ) ) ;  
}

Rufen Sie den code mit zwei float Werte, der code funktioniert in jedem Bereich.

float rand_FloatRange(float a, float b)
{
    return ((b - a) * ((float)rand() / RAND_MAX)) + a;
}

In der modernen c++ können Sie die <random> header, der kam mit c++11.

Für zufällige float's, die Sie verwenden können std::uniform_real_distribution<>.

Können Sie eine Funktion zum generieren von zahlen, und wenn Sie nicht wollen, dass die zahlen die gleichen die ganze Zeit, stellen Sie den Motor und Verteilung static.

Beispiel:

float get_random()
{
    static std::default_random_engine e;
    static std::uniform_real_distribution<> dis(0, 1); //rage 0 - 1
    return dis(e);
}

Es ist ideal, um den Ort der float's in einem container wie std::vector:

int main()
{
    std::vector<float> nums;
    for (int i{}; i != 5; ++i) //Generate 5 random floats
        nums.emplace_back(get_random());

    for (const auto& i : nums) std::cout << i << " ";
}

Beispiel-Ausgabe:

0.0518757 0.969106 0.0985112 0.0895674 0.895542

drand48(3) ist die POSIX-standard-Weg. GLibC stellt auch eine ablaufinvariante version, drand48_r(3).

Wurde die Funktion als veraltet erklärt in SVID 3, aber keine adäquate alternative zur Verfügung gestellt, so IEEE Std 1003.1-2013 noch schließt es und hat keine Hinweise, dass es überall jederzeit schnell.

In Windows ist der standard-Weg ist CryptGenRandom().

Meiner Meinung nach die obige Antwort geben einige 'zufällig' schwimmen, aber keiner von Ihnen ist wirklich ein random float (d.h. Sie verpassen einen Teil der float-Darstellung). Bevor ich die Hektik in meiner Implementierung können zunächst einen Blick auf die ANSI/IEEE-standard-format für Fließkommazahlen:

|sign (1-bit)| e (8-bit) | f (23 bit) |

die Anzahl vertreten durch das Wort " ist
(-1 * sign) * 2^e * 1.f

beachten Sie die " e " - Nummer ist voreingestellt (mit einem bias von 127) Anzahl so reicht von -127 bis 126. Der einfachste (und eigentlich die meisten random) Funktion ist, schreiben Sie einfach die Daten von einem random-int in ein float, so

int tmp = rand();
float f = (float)*((float*)&tmp);

beachten Sie, dass wenn Sie float f = (float)rand(); wird es konvertiert den integer in einen float (also 10 werden 10.0).

So jetzt, wenn Sie wollen, um die maximal-Wert kannst du so etwas tun (nicht sicher, ob dies funktioniert)

int tmp = rand();
float f = *((float*)&tmp);
tmp = (unsigned int)f       //note float to int conversion!
tmp %= max_number;
f -= tmp;

aber wenn man sich die Struktur der float-Sie können sehen, dass der maximale Wert eines float ist (ca) 2^127 die Art und Weise, die größer als der maximale Wert eines int (2^32) somit ausschließt, ein erheblicher Teil der zahlen, die dargestellt werden kann durch einen Schwimmer.
Dies ist meine Letzte Umsetzung:

/**
 * Function generates a random float using the upper_bound float to determine 
 * the upper bound for the exponent and for the fractional part.
 * @param min_exp sets the minimum number (closest to 0) to 1 * e^min_exp (min -127)
 * @param max_exp sets the maximum number to 2 * e^max_exp (max 126)
 * @param sign_flag if sign_flag = 0 the random number is always positive, if 
 *              sign_flag = 1 then the sign bit is random as well
 * @return a random float
 */
float randf(int min_exp, int max_exp, char sign_flag) {
    assert(min_exp <= max_exp);

    int min_exp_mod = min_exp + 126;

    int sign_mod = sign_flag + 1;
    int frac_mod = (1 << 23);

    int s = rand() % sign_mod;  //note x % 1 = 0
    int e = (rand() % max_exp) + min_exp_mod;
    int f = rand() % frac_mod;

    int tmp = (s << 31) | (e << 23) | f;

    float r = (float)*((float*)(&tmp));

    /** uncomment if you want to see the structure of the float. */
//   printf("%x, %x, %x, %x, %f\n", (s << 31), (e << 23), f, tmp, r);

    return r;
}

mithilfe dieser Funktion randf(0, 8, 0) liefert eine Zufallszahl zwischen 0.0 und 255.0

Für C++, die es erzeugen kann, die real float-zahlen innerhalb des angegebenen Bereichs von dist variable

#include <random>  //If it doesnt work then use   #include <tr1/random>
#include <iostream>

using namespace std;

typedef std::tr1::ranlux64_base_01 Myeng; 
typedef std::tr1::normal_distribution<double> Mydist;

int main() { 
       Myeng eng; 
       eng.seed((unsigned int) time(NULL)); //initializing generator to January 1, 1970);
       Mydist dist(1,10); 

       dist.reset(); //discard any cached values 
       for (int i = 0; i < 10; i++)
       {
           std::cout << "a random value == " << (int)dist(eng) << std::endl; 
       }

       return (0);
}

#include <cstdint>
#include <cstdlib>
#include <ctime>

using namespace std;

/* single precision float offers 24bit worth of linear distance from 1.0f to 0.0f */
float getval() {
    /* rand() has min 16bit, but we need a 24bit random number. */
    uint_least32_t r = (rand() & 0xffff) + ((rand() & 0x00ff) << 16);
    /* 5.9604645E-8 is (1f - 0.99999994f), 0.99999994f is the first value less than 1f. */
    return (double)r * 5.9604645E-8;
}

int main()
{
    srand(time(NULL));
...

Konnte ich nicht post zwei Antworten, also hier ist die zweite Lösung. log2 Zufallszahlen, massive bias in Richtung 0.0 f, aber es ist wirklich ein random float 1.0 f, 0.0 f.

#include <cstdint>
#include <cstdlib>
#include <ctime>

using namespace std;

float getval () {
    union UNION {
        uint32_t i;
        float f;
    } r;
    /* 3 because it's 0011, the first bit is the float's sign.
     * Clearing the second bit eliminates values > 1.0f.
     */
    r.i = (rand () & 0xffff) + ((rand () & 0x3fff) << 16);
    return r.f;
}

int main ()
{
    srand (time (NULL));
...