This question already has answers here:
c++ integer->std::string conversion. Simple function?
(3 answers)
Closed 9 years ago.
My code:
#include <iostream>
#include <random>
void main()
{
std::random_device rd;
std::cout << "Random value: " << rd() << std::endl;
system("pause");
}
How do i get the result rd(), and convert it to std::string?
Since you are asking how to convert the result of std::random_device to a string, and std::random_device returns an unsigned int. C++11 provides std::to_string, can be used to convert numbers to strings. See here.
#include <iostream>
#include <random>
#include <string>
int main()
{
std::random_device rd;
std::string str = std::to_string(rd());
std::cout << str << std::endl;
return 0;
}
Here's an example I found on http://en.academic.ru/dic.nsf/enwiki/11574016
#include <random>
#include <functional>
std::uniform_int_distribution<int> distribution(0, 99);
std::mt19937 engine; // Mersenne twister MT19937
auto generator = std::bind(distribution, engine);
int random = generator(); // Generate a uniform integral variate between 0 and 99.
int random2 = distribution(engine); // Generate another sample directly using the distribution and the engine objects.
I haven't worked with it before, but this might help you get started.
std::stringstream is one way to convert a number to a string, the code below shows various engines and distributions possible. It defaults to Mersenne Twister for the engine and the normal distribution. This is good reference for the options available:
#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <random>
#include <sstream>
int main()
{
std::random_device rd;
//
// Engines
//
std::mt19937 e2(rd());
//std::knuth_b e2(rd());
//std::default_random_engine e2(rd()) ;
//
// Distribtuions
//
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::stringstream s1 ;
s1 << dist(e2) ;
std::string str1 = s1.str();
std::cout << str1 << std::endl ;
}
another method to convert to a string would be to use std::to_string:
str1 = std::to_string( dist(e2) ) ;
#include <stdlib.h>
#include <time.h>
int main(){
srand(time(NULL));
unsigned int maxValue = 50;
std::cout << "Random value: " << rand()%maxValue; //random between 0-50
return 0;
}
Related
I am creating a random number generator for numbers between 110,000 and 320,000. When I run it, no numbers are above 150,000. Is there some way to make sure that numbers above 150,000 are generated? Even generating thousands of numbers do not work. I am aware I have lots of things included. Here is the code:
#include <stdlib.h>
#include <iostream>
#include <Windows.h>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <sstream>
#include <conio.h>
#include <ctime>
#include <random>
#include <cstdlib>
#include <ctime>
#include <iostream>
using namespace std;
int main() {
srand((unsigned) time(0));
int randomNumber;
for (int index = 0; index < 500; index++) {
randomNumber = (rand() % 320000) + 110000;
cout << randomNumber << endl;
}
}
As noted by John. You could use more recent random number generators easier to manipulate.
Adapting the code from C++ Reference about uniform_int_distribution
for your use case is straightforward:
#include <iostream>
#include <random>
int main(void) {
std::random_device rd; // Will be used to obtain a seed for the random number engine
std::mt19937 gen(rd()); // Standard mersenne_twister_engine seeded with rd()
std::uniform_int_distribution<> distrib(110000, 320000);
for (int n=0; n<10; ++n)
// Use `distrib` to transform the random unsigned int generated by
// gen into an int in [110000, 320000]
std::cout << distrib(gen) << ' ';
std::cout << '\n';
}
I am trying to generate a random number between 0 and 2 (inclusive) for a C++ program:
#include <iostream>
#include <string>
#include <cstdlib>
#include <random>
using namespace std;
int generateRowMovement(){
//http://www.cplusplus.com/reference/random/uniform_int_distribution/
default_random_engine generator;
uniform_int_distribution<int> distribution(0,2);
int row = distribution(generator);
return row;
}
int main(){
int row = generateRowMovement();
cout << row << endl;
int row2 = generateRowMovement();
cout << row2 << endl;
int row3 = generateRowMovement();
cout << row3 << endl;
return 0;
}
All 3 results are:
0
0
0
I have been testing this for 30 minute and it is always zero. I have tried following this link and this SO post (which posts link back to), but none of their solution is fix this problem. How can I generate 0, 1, and 2?
There are two issues with the code you posted that keeps it from working how you intend it to. The first is that generator is never given a seed, or as is commonly shown online, a random_device, ie
random_device rd;
default_random_engine generator(rd());
The second is that every time you call the function, you're creating a new random engine, and a new distribution. It would be better to create a random device, give it to to the engine only once, and then let your function return the values based on those.
#include <iostream>
#include <string>
#include <cstdlib>
#include <random>
using namespace std;
random_device rd;
default_random_engine generator(rd());
uniform_int_distribution<int> distribution(0,2);
int generateRowMovement(){
return distribution(generator);
}
int main(){
int row = generateRowMovement();
cout << row << endl;
int row2 = generateRowMovement();
cout << row2 << endl;
int row3 = generateRowMovement();
cout << row3 << endl;
return 0;
}
I need a series of normally distributed random numbers, with different mean and variance, I know how to create one series with a particular mean and variance but can I have like an array of generators?
like for 1 series we have
#include <random>
#include <iostream>
using namespace std;
int main()
{
random_device rd;
mt19937 gen(rd());
normal_distribution<double> d(0.0, 1.0);
for (int i = 0; i < 5000; i++)
cout << " " << d(gen) << "\n";
return 0;
}
and this gives me a series of normally distributed random numbers, and i know i can create another d with another mean and variance for another series but is there any way to have a lot of such normal_distribution d together in an array so that i can choose a particular generator by simply choosing an element in the array.
I have tried a version where
#include <random>
#include <iostream>
using namespace std;
int main()
{
random_device rd;
mt19937 gen(rd());
normal_distribution<double> d(0.0, 1.0),d2(0.0,1.0);
normal_distribution<double> D[]={d,d2};
for (int i = 0; i < 5000; i++)
cout << " " << D[0](gen) << "\n";
system("pause");
return 0;
}
but I want to initialize it directly with the array like D0 some thing like that so that i can put it in a loop
Sure you can
#include <iostream>
#include <vector>
#include <random>
int main() {
std::vector<std::normal_distribution<double>> D{
std::normal_distribution<double>{0.0, 1.0 },
std::normal_distribution<double>{0.0, 2.0 } };
std::random_device rd;
std::mt19937 gen(rd());
std::cout << D[0](gen) << "\n";
std::cout << D[1](gen) << "\n";
return 0;
}
As you know C++ provide a functions for random numbers and we can also create and initialize array as given below. I hope it will helpful if not comment below.
const int nrolls=10000; // number of experiments
const int nstars=100; // maximum number of stars to distribute
std::default_random_engine generator;
std::normal_distribution<double> distribution(5.0,2.0);
int p[10]={};
for (int i=0; i<nrolls; ++i) {
double number = distribution(generator);
if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
}
std::cout << "normal_distribution (5.0,2.0):" << std::endl;
for (int i=0; i<10; ++i) {
std::cout << i << "-" << (i+1) << ": ";
std::cout << std::string(p[i]*nstars/nrolls,'*') << std::endl;
}
This is a follow up question on an answer on this page:
How to generate random double numbers with high precision in C++?
#include <iostream>
#include <random>
#include <iomanip>
int main()
{
std::random_device rd;
std::mt19937 e2(rd());
std::uniform_real_distribution<> dist(1, 10);
for( int i = 0 ; i < 10; ++i )
{
std::cout << std::fixed << std::setprecision(10) << dist(e2) << std::endl ;
}
return 0 ;
}
The answer works fine but I had a hard time to realize how to put the output of this code in a double variable instead of printing it to stdout. Can anyone help with this?
Thanks.
You're getting confused between actual precision and displayed precision - try this:
#include <iostream>
#include <random>
#include <iomanip>
int main()
{
std::random_device rd;
std::mt19937 e2(rd());
std::uniform_real_distribution<> dist(1, 10);
double v = dist(e2); // get a random double at full precision
std::cout << std::fixed << std::setprecision(10) << v << std::endl;
// display random double with 10 digits of precision
return 0;
}
so my question in a nutshell would be: How do I access a random engine initialized in main() from another function without passing the engine as an argument?
I read that is a good habit to initialize a random engine only once in a program.
I would do it like this at the beginning of my main() function:
#include <iostream>
#include <random>
#include <ctime>
using std::cout;
using std::endl;
using std::default_random_engine;
using std::uniform_int_distribution;
int main() {
int seed = time(0);
default_random_engine engine(seed);
uniform_int_distribution<int> dist(0,100);
cout << "Random num: " << engine(dist) << endl;
}
But how would I make it accessible to other functions? E.g., in a nested structure where function func_a calls func_b, which is supposed to do something with a random number generated by the engine.
For example:
#include <iostream>
#include <random>
#include <ctime>
using std::cout;
using std::endl;
using std::default_random_engine;
using std::uniform_int_distribution;
void func_b() {
// do sth
cout << "Print a random number: " << endl;
}
void func_a() {
func_b();
}
int main() {
int seed = time(0);
default_random_engine engine(seed);
uniform_int_distribution<int> dist(0,100);
func_a();
}
EDIT: Problem Solved, thanks.
#include <iostream>
#include <random>
#include <ctime>
using std::cout;
using std::endl;
using std::default_random_engine;
using std::uniform_int_distribution;
////////////////////////
// GLOBAL VARIABLES
////////////////////////
int seed = time(0);
default_random_engine engine(seed);
////////////////////////
// FUNCTION DEFINITIONS
////////////////////////
void func_b() {
uniform_int_distribution<int> dist(0,100);
cout << dist(engine) << endl;
}
void func_a() {
func_b();
}
int main() {
int seed = time(0);
default_random_engine engine(seed);
uniform_int_distribution<int> dist(0,100);
func_a();
}
Thanks for all your help. I copy the solution to the answer section so it can be marked as accepted.
#include <iostream>
#include <random>
#include <ctime>
using std::cout;
using std::endl;
using std::default_random_engine;
using std::uniform_int_distribution;
////////////////////////
// GLOBAL VARIABLES
////////////////////////
int seed = time(0);
default_random_engine engine(seed);
////////////////////////
// FUNCTION DEFINITIONS
////////////////////////
void func_b() {
uniform_int_distribution<int> dist(0,100);
cout << dist(engine) << endl;
}
void func_a() {
func_b();
}
int main() {
int seed = time(0);
default_random_engine engine(seed);
uniform_int_distribution<int> dist(0,100);
func_a();
}