Как создать случайный float в c ++ [duplicate]

В современных c++ вы можете использовать заголовок <random> , который появился с c++11. Чтобы получить случайные float, вы можете использовать std::uniform_real_distribution<>.

Вы можете использовать функцию для генерации чисел, и если вы не хотите, чтобы числа были одинаковыми все время, установите двигатель и распределение будут static. Пример:

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

Идеально разместить float в контейнере, таком как 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 << " ";
}

Пример вывода:

0.0518757 0.969106 0.0985112 0.0895674 0.895542

Полностью случайное действительное число с плавающей точкой генерируется следующим образом: случайный знак, случайный показатель и случайная мантисса. Ниже приведен пример генерации случайных чисел из 0..MAXFLOAT с равномерным распределением:

static float frand(){
    float f;
    UINT32 *fi = (UINT32*)&f;
    *fi = 0;
    const int minBitsRandGives  = (1<<15);          //  RAND_MAX is at least (1<<15)    
    UINT32 randExp              = (rand()%254)+1;   //  Exponents are in range of [1..254]
    UINT32 randMantissa         = ((rand() % minBitsRandGives) << 8) | (rand()%256);
    *fi                         = randMantissa | (randExp<<23);                 // Build a float with random exponent and random mantissa
    return f;
}

Важное примечание: RAND_MAX по умолчанию равно 2 ^ 16 (в 32 битовых системах), поэтому rand () может генерировать не более 15 случайных бит. Поскольку с плавающей запятой имеется всего 32 бита, мы должны активировать rand () не менее 3 раз для генерации случайных 32 бит. Я использовал 8 бит rand () для генерации Exponent и еще 2 вызова rand () для генерации 23 бит мантиссы.

Общая ошибка, которой следует избегать: если вы используете (float)rand()/MAX_RAND для получения плавающей запятой в range [0..1], вы все равно получите случайные числа в равномерном распределении, но с низкой точностью. Например, ваш случайный генератор может генерировать 0,00001 и 0,00002, но не может генерировать 0,000017. Такое случайное число в 256 раз меньше, чем фактическое представление с плавающей запятой.

Оптимизация. Моя функция не оптимизирована для скорости. Вы можете улучшить его, заменив разделение «%» на побитовые логические операции. Например, вместо %256 используйте &0xFF

До сих пор я не был удовлетворен ни одним из ответов, поэтому написал новую функцию случайного поплавка. Он делает побитовые предположения о типе данных float. Ему по-прежнему нужна функция rand () с не менее 15 случайными битами.

//Returns a random number in the range [0.0f, 1.0f).  Every
//bit of the mantissa is randomized.
float rnd(void){
  //Generate a random number in the range [0.5f, 1.0f).
  unsigned int ret = 0x3F000000 | (0x7FFFFF & ((rand() << 8) ^ rand()));
  unsigned short coinFlips;

  //If the coin is tails, return the number, otherwise
  //divide the random number by two by decrementing the
  //exponent and keep going. The exponent starts at 63.
  //Each loop represents 15 random bits, a.k.a. 'coin flips'.
  #define RND_INNER_LOOP() \
    if( coinFlips & 1 ) break; \
    coinFlips >>= 1; \
    ret -= 0x800000
  for(;;){
    coinFlips = rand();
    RND_INNER_LOOP(); RND_INNER_LOOP(); RND_INNER_LOOP();
    //At this point, the exponent is 60, 45, 30, 15, or 0.
    //If the exponent is 0, then the number equals 0.0f.
    if( ! (ret & 0x3F800000) ) return 0.0f;
    RND_INNER_LOOP(); RND_INNER_LOOP(); RND_INNER_LOOP();
    RND_INNER_LOOP(); RND_INNER_LOOP(); RND_INNER_LOOP();
    RND_INNER_LOOP(); RND_INNER_LOOP(); RND_INNER_LOOP();
    RND_INNER_LOOP(); RND_INNER_LOOP(); RND_INNER_LOOP();
  }
  return *((float *)(&ret));
}

drand48(3) является стандартным способом POSIX. GLibC также предоставляет реентерабельную версию, drand48_r(3) .

Функция была объявлена ​​устаревшей в SVID 3, но адекватная альтернатива не была предоставлена, поэтому IEEE Std 1003.1-2013 по-прежнему включает в себя и не имеет никаких заметок о том, что в любом случае это произойдет в ближайшее время.

В Windows стандартным способом является CryptGenRandom () .

rand () возвращает int между 0 и RAND_MAX. Чтобы получить случайное число между 0.0 и 1.0, сначала введите int return by rand () в float, а затем разделите на RAND_MAX.

На некоторых системах (в настоящее время Windows с VC наводит на мысль,] RAND_MAX смехотворно мала, i. е. всего 15 бит. При делении на RAND_MAX вы генерируете мантиссону из 15 бит вместо 23 возможных бит. Это может быть или не быть проблемой для вас, но в этом случае вы упускаете некоторые значения.

О, только что заметил, что для этой проблемы уже есть комментарий. В любом случае, вот какой код, который может решить это для вас:

float r = (float)((rand() << 15 + rand()) & ((1 << 24) - 1)) / (1 << 24);

Не проиндексирован, но может работать: -)

Если вы знаете, что ваш формат с плавающей запятой - IEEE 754 (почти все современные процессоры, включая Intel и ARM), то вы можете построить случайное число с плавающей запятой из случайного целого с использованием битовых методов. Это следует учитывать только в том случае, если у вас нет доступа к C ++ 11 random или Boost.Random , которые намного лучше.

float rand_float()
{
    // returns a random value in the range [0.0-1.0)

    // start with a bit pattern equating to 1.0
    uint32_t pattern = 0x3f800000;

    // get 23 bits of random integer
    uint32_t random23 = 0x7fffff & (rand() << 8 ^ rand());

    // replace the mantissa, resulting in a number [1.0-2.0)
    pattern |= random23;

    // convert from int to float without undefined behavior
    assert(sizeof(float) == sizeof(uint32_t));
    char buffer[sizeof(float)];
    memcpy(buffer, &pattern, sizeof(float));
    float f;
    memcpy(&f, buffer, sizeof(float));

    return f - 1.0;
}

Это даст лучшее распределение, чем использование деления.