Генерация случайных чисел с плавающей точкой

Как мне генерировать случайные числа с плавающей точкой в ​​C ++?

Я думал, что смогу взять целое число рандов и разделить его на что-нибудь, будет ли этого достаточно?

rand()может использоваться для генерации псевдослучайных чисел в C ++. В сочетании с RAND_MAXнебольшой математикой вы можете генерировать случайные числа в любом произвольном интервале по вашему выбору. Этого достаточно для учебных целей и игрушечных программ. Если вам нужны действительно случайные числа с нормальным распределением, вам нужно использовать более продвинутый метод.

Будет сгенерировано число от 0,0 до 1,0 включительно.

float r = static_cast <float> (rand()) / static_cast <float> (RAND_MAX);

Это будет генерировать число от 0,0 до некоторой произвольной float, X:

float r2 = static_cast <float> (rand()) / (static_cast <float> (RAND_MAX/X));

Это сгенерирует число от некоторого произвольного LOдо некоторого произвольного HI:

float r3 = LO + static_cast <float> (rand()) /( static_cast <float> (RAND_MAX/(HI-LO)));

Обратите внимание, что rand()функции часто будет недостаточно, если вам нужны действительно случайные числа.

Перед тем, как позвонить rand(), вы должны сначала «запустить» генератор случайных чисел, позвонив srand(). Это должно быть сделано один раз во время выполнения вашей программы - не один раз при каждом вызове rand(). Это часто делается так:

srand (static_cast <unsigned> (time(0)));

Для того, чтобы позвонить randили srandнеобходимо #include <cstdlib>.

Для того, чтобы позвонить time, необходимо #include <ctime>.

C ++ 11 дает вам много новых опций random. Канонической статьей на эту тему будет N3551, Генерация случайных чисел в C ++ 11

Чтобы понять, почему использование rand()может быть проблематичным, смотрите презентацию rand () «Считается вредным » Стефана Т. Лававея, данную во время мероприятия GoingNative 2013 . Слайды в комментариях, но здесь есть прямая ссылка .

Я также расскажу boostи об использовании, randтак как устаревший код все еще может требовать его поддержки.

Приведенный ниже пример извлечен из сайта cppreference и использует механизм std :: mersenne_twister_engine и std ::iform_real_distribution, который генерирует числа в [0,10)интервале, с другими закомментированными движками и дистрибутивами ( смотрите вживую ):

#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';
    }
}

вывод будет похож на следующее:

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

Вывод будет варьироваться в зависимости от того, какое распределение вы выберете, поэтому, если мы решили использовать std :: normal_distribution со значением 2для mean и stddev, например, dist(2, 2)вместо этого вывод будет аналогичен этому ( смотрите его вживую ):

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

Ниже приведена модифицированная версия некоторого кода, представленного в N3551( смотрите его вживую ):

#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;
}

Результаты будут выглядеть примерно так:

5H 5S AS 9S 4D 6H TH 6D KH 2S QS 9H 8H 3D KC TD 7H 2D KS 3C TC 7D 4C QH QC 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 6C JS 7S 6S

Увеличение

Конечно, Boost.Random также всегда доступен , здесь я использую boost :: random ::iform_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 ()

Если вы должны использовать его, rand()мы можем перейти к разделу часто задаваемых вопросов C для получения инструкций о том, как генерировать случайные числа с плавающей запятой? , который в основном дает пример, подобный этому для генерации на интервале [0,1):

#include <stdlib.h>

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

и генерировать случайное число в диапазоне от [M,N):

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

Взгляните на Boost.Random . Вы могли бы сделать что-то вроде этого:

float gen_random_float(float min, float max)
{
    boost::mt19937 rng;
    boost::uniform_real<float> u(min, max);
    boost::variate_generator<boost::mt19937&, boost::uniform_real<float> > gen(rng, u);
    return gen();
}

Поиграйте, вы могли бы лучше передать один и тот же объект mt19937, вместо того, чтобы каждый раз создавать новый, но, надеюсь, вы поняли идею.

В современном 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

Назовите код с двумя floatзначениями, код работает в любом диапазоне.

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

Если вы используете C ++, а не C, то помните, что в техническом отчете 1 (TR1) и в черновике C ++ 0x они добавили средства для генератора случайных чисел в заголовочном файле, я считаю, что он идентичен Boost. Случайная библиотека и определенно более гибкая и «современная», чем функция библиотеки C, rand.

Этот синтаксис дает возможность выбрать генератор (например, mersenne twister mt19937), а затем выбрать распределение (нормальное, бернулли, биномиальное и т. Д.).

Синтаксис выглядит следующим образом (бесстыдно позаимствовано с этого сайта ):

  #include <iostream>
  #include <random>

  ...

  std::tr1::mt19937 eng;  // a core engine class 
  std::tr1::normal_distribution<float> dist;     

  for (int i = 0; i < 10; ++i)        
      std::cout << dist(eng) << std::endl;

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

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

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

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

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

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

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

Пока что я не был удовлетворен ни одним из ответов, поэтому я написал новую функцию случайного числа. Это делает побитовые предположения о типе данных с плавающей точкой. Для этого все еще нужна функция 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));
}

По моему мнению, приведенный выше ответ дает некоторое «случайное» смещение, но ни один из них не является действительно случайным смещением (то есть они пропускают часть представления с плавающей точкой). Прежде чем я углублюсь в свою реализацию, давайте сначала посмотрим на стандартный формат ANSI / IEEE для float:

| знак (1 бит) | е (8 бит) | f (23 бита) |

число, представленное этим словом, (-1 * знак) * 2 ^ e * 1.f

обратите внимание, что число 'e' является смещенным (с смещением 127) числом, таким образом, в диапазоне от -127 до 126. Самая простая (и фактически самая случайная) функция - просто записать данные случайного int в число с плавающей точкой, таким образом

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

обратите внимание, что если вы сделаете float f = (float)rand();это, он преобразует целое число в число с плавающей точкой (таким образом, 10 станет 10,0).

Так что теперь, если вы хотите ограничить максимальное значение, вы можете сделать что-то вроде (не уверен, что это работает)

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

но если вы посмотрите на структуру числа с плавающей точкой, то увидите, что максимальное значение числа с плавающей точкой составляет (приблизительно) 2 ^ 127, что намного больше, чем максимальное значение целого числа (2 ^ 32), что исключает значительную часть числа, которые могут быть представлены поплавком. Это моя последняя реализация:

/**
 * 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;
}

использование этой функции randf(0, 8, 0)вернет случайное число от 0,0 до 255,0

Если вы знаете, что ваш формат с плавающей запятой - это 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;
}

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

Для C ++ он может генерировать реальные числа с плавающей точкой в ​​диапазоне, указанном distпеременной

#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);
}

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

#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));
...

Я не мог опубликовать два ответа, так что вот второе решение. log2 случайные числа, массивный уклон в сторону 0,0f, но это действительно случайное смещение от 1,0f до 0,0f.

#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));
...