C++ 两个区间之间双精度随机数生成[a，b]

我需要生成均匀分布在两个区间[a，b]之间的

X

随机双精度数，其中

a

和

b

也是双精度数

那些

X

数字需要在类函数内部生成，比如

myclass:：doSomething（a，b）

。问题是，每次另一个类函数调用

doSomething（a，b）

函数时，传递给

doSomething（a，b）

函数的间隔

[a，b]

都会改变

我想要一个解决方案，允许我：
1.拥有一个范围更大的

引擎

，理想情况下，每次应用程序运行只能对其进行一次种子设定。
2.对

doSomething（）

函数的每次调用中生成的

X

随机双精度数应均匀分布

//file: utilities.h
template <typename Generator>
double randomDoubleEngine(Generator& engine, double low_bound, double high_bound )
{
        if (low_bound > high_bound){
                std::swap(low_bound, high_bound);
        }

        return std::uniform_real_distribution<>( low_bound, high_bound )( engine );
}

//file: myclass.h
       void myclass::doThat(param1, param2){

            for(int i=0; i < myclass.iter; i++){
                ...
                ...
                doSomething(a,b);
                ...
            }

        }

        void myclass::doSomething(double a, double b)
        {
                std::random_device rd;
                static std::mt19937 engine(rd());
                .....
                double curThreshold = randomDoubleEngine(engine, a, b);
                ...
         }

我下面的解决方案不允许

引擎具有更大的范围，而且生成的数字似乎不一定均匀分布

//file: utilities.h
template <typename Generator>
double randomDoubleEngine(Generator& engine, double low_bound, double high_bound )
{
        if (low_bound > high_bound){
                std::swap(low_bound, high_bound);
        }

        return std::uniform_real_distribution<>( low_bound, high_bound )( engine );
}

//file: myclass.h
       void myclass::doThat(param1, param2){

            for(int i=0; i < myclass.iter; i++){
                ...
                ...
                doSomething(a,b);
                ...
            }

        }

        void myclass::doSomething(double a, double b)
        {
                std::random_device rd;
                static std::mt19937 engine(rd());
                .....
                double curThreshold = randomDoubleEngine(engine, a, b);
                ...
         }

//文件：utilities.h
模板
双随机双引擎（发电机和引擎、双低上限、双高上限）
{
if（下限>上限）{
标准：：交换（低界、高界）；
}
返回标准：：均匀实分布（低界、高界）（引擎）；
}
//文件：myclass.h
void myclass:：doThat（param1，param2）{
对于（int i=0；i
我认为您希望引擎成为myclass的静态成员。我不确定这是否会与您拥有的有任何真正的区别，除非您需要在其他方法中使用引擎。我在下面粘贴了一个可能的解决方案

还请注意，与标准相比，gcc看起来是错误的（请参阅代码注释中的链接），因此如果您使用它，它可能会解释为什么您对这些数字应用的任何测试（检查均匀分布）都失败了。据我所知，gcc希望引擎返回[0,1]中的数字，而标准要求它应该是某个范围内的统一整数

恐怕我只能用GCC4.4来测试这一点，因为我运行的是较旧的Ubuntu版本，而ideone似乎不允许使用std:：random_设备

#include <random>
#include <iostream>

/* In GCC 4.4, uniform_real_distribution is called uniform_real; renamed in 4.5
 *
 * However, GCC's description here
 *
 * http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-api-4.6/a00731.html
 *
 * doesn't match expectation here
 *
 * http://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution
 *
 * which seems to match 26.5.8.2.2 of N3337
 *
 */
#if defined(__GNUC_MINOR__) && (__GNUC_MINOR__ <= 4)
#  define uniform_real_distribution uniform_real
#endif

template <typename Generator>
double randomDoubleEngine(Generator& engine, double low_bound, double high_bound)
{
  if (low_bound > high_bound){
    std::swap(low_bound, high_bound);
  }
  return std::uniform_real_distribution<double>(low_bound, high_bound)(engine);
}

class myclass
{
  double curThreshold;
  static std::mt19937 engine;
  void doSomething(double a, double b)
  {
    curThreshold= randomDoubleEngine(engine, a, b);
  }
public:
  myclass(): curThreshold(0) {}

  void doThat(){
    doSomething(0,10);
    std::cout << "threshold is " << curThreshold << std::endl;
  }
};

std::mt19937 myclass::engine=std::mt19937(std::random_device()());

int
main()
{
  myclass m;
  m.doThat();
  m.doThat();
  return 0;
}

#包括
#包括
/*在GCC 4.4中，统一实分布称为统一实分布；在4.5中重命名
*
*然而，GCC在这里的描述
*
* http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-api-4.6/a00731.html
*
*不符合这里的期望
*
* http://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution
*
*这似乎与N3337的26.5.8.2.2相匹配
*
*/
#如果定义（uuu GNUC_uuuminor_uuuuuuu）和（uuu GNUC_uuminor_uuuuuhigh_ubound）{
标准：：交换（低界、高界）；
}
返回标准：：均匀实分布（低界、高界）（引擎）；
}
类myclass
{
双门帘；
静态标准：mt19937发动机；
无效剂量测定（双a、双b）
{
curThreshold=发动机（发动机a、b）；
}
公众：
myclass（）：curThreshold（0）{}
void doThat（）{
剂量测定法（0,10）；
std：：你的解决方案行得通吗？如果行，你需要解决什么问题？换句话说，so受众的问题是什么？@OliCharlesworth，我的解决方案不完全行得通。我更新了我的原始帖子。首先，
引擎不是全局的，其次，生成的数字似乎不是均匀分布的。什么你用什么测试来确定分布的均匀性？你的样本量是多少？顺便说一句，应该注意的是，当两个数字是时，两个生成的数字之间的差异不是均匀分布的。这似乎是OP想要的。这是不一样的。均匀实分布生成的范围是[a，b]，而不是[a，b]