如何在C ++中生成随机浮点数?
我以为我可以将整数兰特除以某物,这是否足够?
random
于C ++ 11中添加的标头的选择又得到了标准文档N3924:C ++ 14中不鼓励rand()的支持。我rand()
在回答中主要考虑了历史因素,但也意识到确实存在遗留应用程序。
<random>
标头都得到相同的数字
如何在C ++中生成随机浮点数?
我以为我可以将整数兰特除以某物,这是否足够?
random
于C ++ 11中添加的标头的选择又得到了标准文档N3924:C ++ 14中不鼓励rand()的支持。我rand()
在回答中主要考虑了历史因素,但也意识到确实存在遗留应用程序。
<random>
标头都得到相同的数字
Answers:
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>
。
rand()
。这个问题和我的回答特别关注于基础知识的学习,而不关注高精度。您必须学会走路,然后才能跑步。
C ++ 11为您提供了许多新选项random
。关于该主题的规范性论文为N3551,C ++ 11中的随机数生成
要了解使用为什么rand()
会出现问题,请参阅在GoingNative 2013活动期间由Stephan T. Lavavej提供的rand()被认为有害的演示材料。幻灯片在评论中,但这是直接链接。
由于遗留代码可能仍需要其支持,因此我还将介绍boost
和使用rand
。
下面的示例是从cppreference站点中提取的,并使用std :: mersenne_twister_engine引擎和std :: uniform_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 ****
输出会根据您选择的分布而有所不同,因此,如果我们决定使用均值和stddev均为std :: normal_distribution的值,例如,输出将与此类似(请参见live):2
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 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.Random也总是一个选项,在这里我使用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()
如果必须使用,rand()
则可以转到C FAQ中有关如何生成浮点随机数的指南。,基本上给出了与此类似的示例来生成on间隔[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) ) ) ;
}
randMToN
吗?请注意,[M,N]
或者是+ 1.
从上添加randZeroToOne
。->想像这样称呼它:randMToN(0.0, 1.0);
(N-M)
。对付这种误差的最好方法是在这里找到:stackoverflow.com/questions/33058848/...
看一下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对象,而不是每次都构造一个新的mt19937对象,但希望您能理解。
max
但可以使用开放式min
,则可以轻松地反转间隔:return min + max - gen();
。
在现代情况下,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
std::uniform_real_distribution<> dis(0, 1); // rage 0 - 1
在技术上是不正确,1.0永远不会被产生,见en.cppreference.com/w/cpp/numeric/random/... To create a distribution over the closed interval [a,b], std::nextafter(b, std::numeric_limits<RealType>::max()) may be used as the second parameter.
用两个float
值调用代码,该代码可在任何范围内使用。
float rand_FloatRange(float a, float b)
{
return ((b - a) * ((float)rand() / RAND_MAX)) + a;
}
fmaf()
(或fma()
C ++中的float 重载)的潜在用例,它可能会保留更高的精度。如中fmaf((float)rand() / RAND_MAX, b - a, 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;
在某些系统上(目前可以想到带有VC的Windows)RAND_MAX
小得离谱。e。只有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()。
到目前为止,我对任何答案都不满意,因此我编写了一个新的随机浮点函数。它对float数据类型进行按位假设。它仍然需要带有至少15个随机位的rand()函数。
//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标准格式:
|符号(1位)| e(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;
但是如果您看一下float的结构,您会发现float的最大值约为2 ^ 127,这比int的最大值(2 ^ 32)大得多,因此排除了float的重要部分浮点数可以表示的数字。这是我的最终实现:
/**
* 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之间的随机数
int e = (rand() % (max_exp - min_exp)) + min_exp_mod;
和尾数:int f = (int)(frac_mod * (float)rand() / RAND_MAX);
替换上面的相应行。请注意,尾数错误很严重:对于RAND_MAX
较小的尾数,1 << 23
您只会将较低的有效位随机化,并始终将最高有效位设为0!
如果知道浮点格式是IEEE 754(几乎包括Intel和ARM在内的几乎所有现代CPU),则可以使用按位方法从随机整数构建随机浮点数。仅当您无法访问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;
}
这将比使用除法的分布更好。
return (float)random23 / (1 << 23)
。(是的,我刚刚对此进行了测试,修改了您的函数以使其random32
作为参数并针对从零到最大的所有值运行它(1 << 23)-1
。是的,您的方法的确提供与除以相同的结果1 << 23
。)
对于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);
}
#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));
...