Trình tạo số ngẫu nhiên có phân phối beta

Question

Tôi cần mã nguồn c hoặc C++ của một hàm như betarand(a,b) tạo số ngẫu nhiên với phân phối beta. Tôi biết rằng tôi có thể sử dụng thư viện tăng nhưng tôi sẽ chuyển nó cho kiến ​​trúc CUDA vì vậy tôi cần mã. Ai đó có thể giúp tôi được không?
Trong thời gian chờ đợi, tôi có betapdf (Chức năng mật độ xác suất beta). Nhưng tôi không biết cách sử dụng nó để tạo số ngẫu nhiên :).

Answer 1

C++ 11 thư viện số ngẫu nhiên không cung cấp một phân phối phiên bản beta. Tuy nhiên, bản phân phối beta có thể được mô hình hóa theo hai bản phân phối gamma, mà thư viện cung cấp. Tôi đã triển khai beta_distribution theo điều khoản của std::gamma_distribution cho bạn. Theo như tôi có thể nói, nó hoàn toàn phù hợp với các yêu cầu đối với Phân phối số ngẫu nhiên.

#include <iostream> 
#include <sstream> 
#include <string> 
#include <random> 

namespace sftrabbit { 

    template <typename RealType = double> 
    class beta_distribution 
    { 
    public: 
     typedef RealType result_type; 

     class param_type 
     { 
     public: 
      typedef beta_distribution distribution_type; 

      explicit param_type(RealType a = 2.0, RealType b = 2.0) 
      : a_param(a), b_param(b) { } 

      RealType a() const { return a_param; } 
      RealType b() const { return b_param; } 

      bool operator==(const param_type& other) const 
      { 
      return (a_param == other.a_param && 
        b_param == other.b_param); 
      } 

      bool operator!=(const param_type& other) const 
      { 
      return !(*this == other); 
      } 

     private: 
      RealType a_param, b_param; 
     }; 

     explicit beta_distribution(RealType a = 2.0, RealType b = 2.0) 
     : a_gamma(a), b_gamma(b) { } 
     explicit beta_distribution(const param_type& param) 
     : a_gamma(param.a()), b_gamma(param.b()) { } 

     void reset() { } 

     param_type param() const 
     { 
     return param_type(a(), b()); 
     } 

     void param(const param_type& param) 
     { 
     a_gamma = gamma_dist_type(param.a()); 
     b_gamma = gamma_dist_type(param.b()); 
     } 

     template <typename URNG> 
     result_type operator()(URNG& engine) 
     { 
     return generate(engine, a_gamma, b_gamma); 
     } 

     template <typename URNG> 
     result_type operator()(URNG& engine, const param_type& param) 
     { 
     gamma_dist_type a_param_gamma(param.a()), 
         b_param_gamma(param.b()); 
     return generate(engine, a_param_gamma, b_param_gamma); 
     } 

     result_type min() const { return 0.0; } 
     result_type max() const { return 1.0; } 

     result_type a() const { return a_gamma.alpha(); } 
     result_type b() const { return b_gamma.alpha(); } 

     bool operator==(const beta_distribution<result_type>& other) const 
     { 
     return (param() == other.param() && 
       a_gamma == other.a_gamma && 
       b_gamma == other.b_gamma); 
     } 

     bool operator!=(const beta_distribution<result_type>& other) const 
     { 
     return !(*this == other); 
     } 

    private: 
     typedef std::gamma_distribution<result_type> gamma_dist_type; 

     gamma_dist_type a_gamma, b_gamma; 

     template <typename URNG> 
     result_type generate(URNG& engine, 
     gamma_dist_type& x_gamma, 
     gamma_dist_type& y_gamma) 
     { 
     result_type x = x_gamma(engine); 
     return x/(x + y_gamma(engine)); 
     } 
    }; 

    template <typename CharT, typename RealType> 
    std::basic_ostream<CharT>& operator<<(std::basic_ostream<CharT>& os, 
    const beta_distribution<RealType>& beta) 
    { 
    os << "~Beta(" << beta.a() << "," << beta.b() << ")"; 
    return os; 
    } 

    template <typename CharT, typename RealType> 
    std::basic_istream<CharT>& operator>>(std::basic_istream<CharT>& is, 
    beta_distribution<RealType>& beta) 
    { 
    std::string str; 
    RealType a, b; 
    if (std::getline(is, str, '(') && str == "~Beta" && 
     is >> a && is.get() == ',' && is >> b && is.get() == ')') { 
     beta = beta_distribution<RealType>(a, b); 
    } else { 
     is.setstate(std::ios::failbit); 
    } 
    return is; 
    } 

} 

Sử dụng nó như vậy:

std::random_device rd; 
std::mt19937 gen(rd()); 
sftrabbit::beta_distribution<> beta(2, 2); 
for (int i = 0; i < 10000; i++) { 
    std::cout << beta(gen) << std::endl; 
} 

Answer 2

Kiểm tra việc triển khai bộ tạo số ngẫu nhiên trong NumPy: NumPy distributions source

Chúng được thực hiện trong C, và làm việc rất nhanh.

Answer 3

Có thể bạn có thể sử dụng mã mà gsl sử dụng để tạo số ngẫu nhiên với bản phân phối beta. Họ sử dụng một cách kỳ lạ của produging chúng, như bạn phải vượt qua một máy phát điện số ngẫu nhiên để chức năng, nhưng chắc chắn bạn có thể có được những gì bạn cần.

Đây là documentation và web page

Answer 4

Boost "nghịch đảo không đầy đủ Beta" là một cách nhanh chóng (và đơn giản) để mô phỏng Betas.

#include <random> 
#include <boost/math/special_functions/beta.hpp> 
template<typename URNG> 
double beta_sample(URNG& engine, double a, double b) 
{ 
    static std::uniform_real_distribution<double> unif(0,1); 
    double p = unif(engine); 
    return boost::math::ibeta_inv(a, b, p); 
    // Use Boost policies if it's not fast enough 
}