การสร้างจำนวนเต็มแบบสุ่มจากช่วง

ฉันต้องการฟังก์ชั่นที่จะสร้างจำนวนเต็มแบบสุ่มในช่วงที่กำหนด (รวมถึงค่าเส้นขอบ) ฉันไม่ต้องการคุณภาพ / การสุ่มที่ไม่มีเหตุผลฉันมีข้อกำหนดสี่ข้อ:

• ฉันต้องการมันเร็ว โครงการของฉันต้องสร้างตัวเลขสุ่มนับล้าน (หรือบางครั้งก็เป็นสิบล้าน) และฟังก์ชันตัวสร้างปัจจุบันของฉันได้พิสูจน์แล้วว่าเป็นคอขวด
• ฉันต้องการมันเพื่อให้มีความสม่ำเสมอ (การใช้แรนด์ () นั้นดีมาก)
• ช่วง min-max สามารถเป็นอะไรก็ได้ตั้งแต่ <0, 1> ถึง <-32727, 32727>
• มันจะต้องมีเมล็ด

ขณะนี้ฉันมีรหัส C ++ ดังต่อไปนี้:

output = min + (rand() * (int)(max - min) / RAND_MAX)

ปัญหาคือว่ามันไม่เหมือนกันจริงๆ - max จะถูกส่งคืนเมื่อ rand () = RAND_MAX (สำหรับ Visual C ++ เป็น 1/32727) นี่เป็นปัญหาสำคัญสำหรับช่วงขนาดเล็กเช่น <-1, 1> ซึ่งค่าสุดท้ายแทบไม่เคยส่งคืน

ดังนั้นฉันจึงคว้าปากกาและกระดาษและมาพร้อมกับสูตรต่อไปนี้ (ซึ่งสร้างขึ้นบนเคล็ดลับการปัดเศษ (จำนวนเต็ม) (n + 0.5) จำนวนเต็ม):

แต่มันก็ไม่ได้ให้การกระจายที่เหมือนกัน การรันซ้ำกับ 10,000 ตัวอย่างให้ฉันอัตราส่วน 37:50:13 สำหรับค่า -1, 0. 1

คุณช่วยแนะนำสูตรที่ดีกว่านี้ได้ไหม (หรือฟังก์ชั่นการสร้างตัวเลขสุ่มหลอกทั้งหมด)

วิธีแก้ปัญหาแบบกระจายที่รวดเร็วและดีกว่าของคุณ แต่ก็ยังไม่สม่ำเสมอเท่ากัน

output = min + (rand() % static_cast<int>(max - min + 1))

ยกเว้นเมื่อขนาดของช่วงเป็นอำนาจของ 2, วิธีการนี้ผลิตลำเอียงกระจายไม่สม่ำเสมอหมายเลขrand()โดยไม่คำนึงถึงคุณภาพของ สำหรับการทดสอบที่ครอบคลุมของคุณภาพของวิธีการนี้โปรดอ่านบทความนี้

คำตอบที่ง่ายที่สุด (และดีที่สุด) C ++ (โดยใช้มาตรฐาน 2011) คือ

#include <random>

std::random_device rd;     // only used once to initialise (seed) engine
std::mt19937 rng(rd());    // random-number engine used (Mersenne-Twister in this case)
std::uniform_int_distribution<int> uni(min,max); // guaranteed unbiased

auto random_integer = uni(rng);

ไม่จำเป็นต้องคิดค้นล้อใหม่อีกครั้ง ไม่จำเป็นต้องกังวลเรื่องอคติ ไม่ต้องกังวลกับการใช้เวลาเป็นเมล็ดสุ่ม

หากคอมไพเลอร์ของคุณรองรับ C ++ 0x และการใช้มันเป็นตัวเลือกสำหรับคุณ<random>ส่วนหัวมาตรฐานใหม่น่าจะตรงกับความต้องการของคุณ มันมีคุณภาพสูงuniform_int_distributionซึ่งจะยอมรับขอบเขตขั้นต่ำและสูงสุด (รวมตามที่คุณต้องการ) และคุณสามารถเลือกเครื่องกำเนิดตัวเลขสุ่มแบบต่างๆเพื่อเชื่อมต่อกับการกระจายนั้น

นี่คือโค้ดที่สร้างการแจกแจงแบบสุ่มล้านintตัวใน [-57, 365] ฉันได้ใช้<chrono>สิ่งอำนวยความสะดวกมาตรฐานใหม่เพื่อให้ทันเวลาตามที่คุณกล่าวถึงประสิทธิภาพเป็นข้อกังวลสำคัญสำหรับคุณ

#include <iostream>
#include <random>
#include <chrono>

int main()
{
    typedef std::chrono::high_resolution_clock Clock;
    typedef std::chrono::duration<double> sec;
    Clock::time_point t0 = Clock::now();
    const int N = 10000000;
    typedef std::minstd_rand G;
    G g;
    typedef std::uniform_int_distribution<> D;
    D d(-57, 365);
    int c = 0;
    for (int i = 0; i < N; ++i) 
        c += d(g);
    Clock::time_point t1 = Clock::now();
    std::cout << N/sec(t1-t0).count() << " random numbers per second.\n";
    return c;
}

สำหรับฉัน (2.8 GHz Intel Core i5) สิ่งนี้จะพิมพ์ออกมา:

2.10268e + 07 ตัวเลขสุ่มต่อวินาที

คุณสามารถ seed ตัวกำเนิดโดยส่งผ่าน int ไปยัง constructor:

    G g(seed);

หากภายหลังคุณพบว่าintไม่ครอบคลุมช่วงที่คุณต้องการสำหรับการกระจายของคุณสิ่งนี้สามารถแก้ไขได้โดยการเปลี่ยนชื่อที่uniform_int_distributionคล้ายกัน (เช่นเป็นlong long):

    typedef std::uniform_int_distribution<long long> D;

หากคุณพบในภายหลังว่าตัวminstd_randกำเนิดที่มีคุณภาพไม่สูงพอคุณสามารถเปลี่ยนได้อย่างง่ายดาย เช่น:

    typedef std::mt19937 G;  // Now using mersenne_twister_engine

มีการควบคุมแยกตัวสร้างตัวเลขสุ่มและการกระจายแบบสุ่มนั้นสามารถปลดปล่อยได้อย่างอิสระ

ฉันยังคำนวณ (ไม่แสดง) ช่วงเวลา 4 ช่วงแรกของการแจกแจงนี้ (โดยใช้minstd_rand) และเปรียบเทียบกับค่าทางทฤษฎีเพื่อพยายามประเมินคุณภาพของการแจกแจง:

min = -57
max = 365
mean = 154.131
x_mean = 154
var = 14931.9
x_var = 14910.7
skew = -0.00197375
x_skew = 0
kurtosis = -1.20129
x_kurtosis = -1.20001

( x_คำนำหน้าหมายถึง "คาดหวัง")

ลองแบ่งปัญหาออกเป็นสองส่วน:

• สร้างตัวเลขสุ่มnในช่วง 0 ถึง (สูงสุด - นาที)
• เพิ่มขั้นต่ำลงในหมายเลขนั้น

ส่วนแรกนั้นยากที่สุด สมมติว่าค่าส่งคืนของ rand () เหมือนกันอย่างสมบูรณ์ การใช้โมดูโล่จะเพิ่มอคติให้กับ(RAND_MAX + 1) % (max-min+1)ตัวเลขแรก ดังนั้นหากเราสามารถเปลี่ยนRAND_MAXไปอย่างน่าอัศจรรย์RAND_MAX - (RAND_MAX + 1) % (max-min+1)ก็จะไม่มีอคติอีกต่อไป

ปรากฎว่าเราสามารถใช้สัญชาตญาณนี้ถ้าเรายินดีที่จะอนุญาตให้หลอก - nondeterminism เป็นเวลาทำงานของอัลกอริทึมของเรา เมื่อใดก็ตามที่ rand () ส่งกลับตัวเลขที่มีขนาดใหญ่เกินไปเราก็จะขอหมายเลขสุ่มอีกจนกว่าเราจะได้หมายเลขที่มีขนาดเล็กพอ

ขณะนี้เวลาทำงานมีการกระจายแบบเรขาคณิตด้วยค่า1/pที่คาดไว้ซึ่งpเป็นความน่าจะเป็นที่จะได้รับจำนวนที่น้อยพอในการลองครั้งแรก เนื่องจากRAND_MAX - (RAND_MAX + 1) % (max-min+1)น้อยกว่า(RAND_MAX + 1) / 2เรารู้อยู่เสมอp > 1/2ดังนั้นจำนวนการทำซ้ำที่คาดไว้จะน้อยกว่าสองเท่าสำหรับช่วงใด ๆ มันเป็นไปได้ที่จะสร้างตัวเลขสุ่มนับล้านในเวลาน้อยกว่าหนึ่งวินาทีบน CPU มาตรฐานด้วยเทคนิคนี้

แก้ไข:

แม้ว่าข้างต้นจะถูกต้องทางเทคนิคคำตอบของ DSimon อาจมีประโยชน์มากกว่าในทางปฏิบัติ คุณไม่ควรใช้สิ่งนี้ด้วยตนเอง ฉันได้เห็นการใช้งานจำนวนมากของการสุ่มตัวอย่างการปฏิเสธและมักจะยากที่จะดูว่ามันถูกต้องหรือไม่

วิธีการเกี่ยวกับMersenne Twister ? การใช้งานบูสต์นั้นค่อนข้างง่ายต่อการใช้งานและได้รับการทดสอบอย่างดีในแอปพลิเคชันในโลกแห่งความเป็นจริงมากมาย ฉันใช้มันด้วยตัวเองในโครงการทางวิชาการหลายอย่างเช่นปัญญาประดิษฐ์และอัลกอริธึมวิวัฒนาการ

นี่คือตัวอย่างของพวกเขาที่พวกเขาสร้างฟังก์ชั่นง่าย ๆ ในการหมุนแม่พิมพ์แบบหกด้าน:

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/variate_generator.hpp>

boost::mt19937 gen;

int roll_die() {
    boost::uniform_int<> dist(1, 6);
    boost::variate_generator<boost::mt19937&, boost::uniform_int<> > die(gen, dist);
    return die();
}

โอ้และนี่คือบางส่วนเล็กน้อยของเครื่องกำเนิดไฟฟ้านี้ในกรณีที่คุณไม่มั่นใจคุณควรใช้มันให้ดีกว่าrand():

Mersenne Twister เป็นเครื่องกำเนิดไฟฟ้า "หมายเลขสุ่ม" ที่คิดค้นโดย Makoto Matsumoto และ Takuji Nishimura; เว็บไซต์ของพวกเขารวมถึงการใช้อัลกอริทึมมากมาย

โดยพื้นฐานแล้ว Mersenne Twister เป็นระบบลงทะเบียนกะตอบรับแบบเส้นตรงขนาดใหญ่มาก อัลกอริทึมทำงานกับเมล็ด 19,937 บิตซึ่งเก็บในอาร์เรย์ 624 องค์ประกอบของจำนวนเต็ม 32 บิตที่ไม่ได้ลงชื่อ ค่า 2 ^ 19937-1 คือ Mersenne prime เทคนิคสำหรับการจัดการเมล็ดพันธุ์นั้นขึ้นอยู่กับอัลกอริทึม "การบิด" ที่เก่ากว่า - ดังนั้นชื่อ "Mersenne Twister"

สิ่งที่น่าดึงดูดใจของ Mersenne Twister คือการใช้การดำเนินงานแบบไบนารี - ซึ่งต่างจากการคูณที่ใช้เวลานานในการสร้างตัวเลข อัลกอริทึมยังมีระยะเวลานานมากและมีความละเอียดมาก ทั้งรวดเร็วและมีประสิทธิภาพสำหรับแอพพลิเคชั่นที่ไม่ได้เข้ารหัส

int RandU(int nMin, int nMax)
{
    return nMin + (int)((double)rand() / (RAND_MAX+1) * (nMax-nMin+1));
}

นี่คือการแม็พจำนวนเต็ม 32768 ถึง (nMax-nMin + 1) การทำแผนที่จะค่อนข้างดีถ้า (nMax-nMin + 1) มีขนาดเล็ก (ตามที่คุณต้องการ) อย่างไรก็ตามโปรดทราบว่าหาก (nMax-nMin + 1) มีขนาดใหญ่การทำแผนที่จะไม่ทำงาน (ตัวอย่างเช่น - คุณไม่สามารถแมปค่า 32768 กับ 30000 ค่าด้วยความน่าจะเป็นที่เท่ากัน) หากจำเป็นต้องใช้ช่วงดังกล่าวคุณควรใช้แหล่งข้อมูลแบบสุ่ม 32 บิตหรือ 64 บิตแทนที่จะเป็น rand 15- บิต () หรือละเว้นผลลัพธ์ rand () ซึ่งอยู่นอกช่วง

นี่คือเวอร์ชันที่ไม่เอนเอียงที่สร้างตัวเลขใน[low, high]:

int r;
do {
  r = rand();
} while (r < ((unsigned int)(RAND_MAX) + 1) % (high + 1 - low));
return r % (high + 1 - low) + low;

หากช่วงของคุณมีขนาดเล็กพอสมควรจะไม่มีเหตุผลใดที่แคชด้านขวามือของการเปรียบเทียบในdoลูป

ฉันแนะนำไลบรารี Boost.Randomมันมีรายละเอียดและมีเอกสารที่ดีมากช่วยให้คุณระบุการกระจายที่คุณต้องการได้อย่างชัดเจนและในสถานการณ์ที่ไม่ใช่การเข้ารหัสลับอาจมีประสิทธิภาพเหนือกว่าการใช้งานไลบรารี C ทั่วไป

สมมติว่า min และ max เป็นค่า int [และ] หมายถึงรวมค่านี้ (และ) หมายความว่าไม่รวมค่านี้โดยใช้ด้านบนเพื่อรับค่าที่ถูกต้องโดยใช้ c ++ rand ()

การอ้างอิง: สำหรับ () [] define ไปที่:

https://en.wikipedia.org/wiki/Interval_(mathematics)

สำหรับฟังก์ชั่น rand และ srand หรือ RAND_MAX define ให้ไปที่:

http://en.cppreference.com/w/cpp/numeric/random/rand

[ต่ำสุดสูงสุด]

int randNum = rand() % (max - min + 1) + min

(นาที, สูงสุด]

int randNum = rand() % (max - min) + min + 1

[ต่ำสุดสูงสุด)

int randNum = rand() % (max - min) + min

(ขั้นต่ำสูงสุด)

int randNum = rand() % (max - min - 1) + min + 1

ในการสุ่มตัวอย่างการปฏิเสธเธรดนี้ได้ถูกกล่าวถึงแล้ว แต่ฉันต้องการแนะนำการปรับให้เหมาะสมอย่างใดอย่างหนึ่งตามความจริงที่rand() % 2^somethingไม่แนะนำอคติใด ๆ ดังที่ได้กล่าวมาแล้ว

อัลกอริทึมนั้นง่ายมาก:

• คำนวณพลังงานที่เล็กที่สุดของ 2 มากกว่าความยาวช่วงเวลา
• สุ่มตัวเลขหนึ่งตัวในช่วง "ใหม่"
• คืนค่าจำนวนนั้นถ้าน้อยกว่าความยาวของช่วงเวลาเดิม
  • ปฏิเสธเป็นอย่างอื่น

นี่คือตัวอย่างรหัสของฉัน:

int randInInterval(int min, int max) {
    int intervalLen = max - min + 1;
    //now calculate the smallest power of 2 that is >= than `intervalLen`
    int ceilingPowerOf2 = pow(2, ceil(log2(intervalLen)));

    int randomNumber = rand() % ceilingPowerOf2; //this is "as uniform as rand()"

    if (randomNumber < intervalLen)
        return min + randomNumber;      //ok!
    return randInInterval(min, max);    //reject sample and try again
} 

วิธีนี้ใช้งานได้ดีโดยเฉพาะอย่างยิ่งสำหรับช่วงเวลาเล็ก ๆ เพราะพลังของ 2 จะเป็น "ใกล้" ถึงความยาวช่วงเวลาจริงดังนั้นจำนวนของการผิดพลาดจะน้อยลง

PS
เห็นได้ชัดว่าการหลีกเลี่ยงการเรียกซ้ำจะมีประสิทธิภาพมากขึ้น (ไม่จำเป็นต้องคำนวณซ้ำไปซ้ำมา .. ) แต่ฉันคิดว่ามันอ่านได้ง่ายกว่าสำหรับตัวอย่างนี้

โปรดสังเกตว่าในข้อเสนอแนะส่วนใหญ่ค่าเริ่มต้นแบบสุ่มที่คุณได้รับจากฟังก์ชั่น rand () ซึ่งโดยทั่วไปแล้วจะอยู่ระหว่าง 0 ถึง RAND_MAX คุณกำลังสร้างหมายเลขสุ่มเพียงหมายเลขเดียวในขณะที่มีขั้นตอนเสียงที่สามารถให้คุณมากกว่านี้

สมมติว่าคุณต้องการ [min, max] ขอบเขตของตัวเลขสุ่มจำนวนเต็ม เราเริ่มต้นจาก [0, สูงสุด - นาที]

ใช้ฐาน b = max-min + 1

เริ่มต้นจากการแทนตัวเลขที่คุณได้จาก rand () ในฐาน b

ด้วยวิธีนี้คุณจะมีพื้น (log (b, RAND_MAX)) เพราะแต่ละหลักในฐาน b ยกเว้นตัวเลขสุดท้ายอาจแทนตัวเลขสุ่มในช่วง [0, max-min]

แน่นอนว่าการเปลี่ยนครั้งสุดท้ายเป็น [min, max] นั้นง่ายสำหรับการสุ่มหมายเลข r + min

int n = NUM_DIGIT-1;
while(n >= 0)
{
    r[n] = res % b;
    res -= r[n];
    res /= b;
    n--;
}

ถ้า NUM_DIGIT เป็นจำนวนหลักในฐาน b ที่คุณสามารถแยกและนั่นคือ

NUM_DIGIT = floor(log(b,RAND_MAX))

จากนั้นข้างต้นเป็นการใช้งานง่าย ๆ ในการดึงตัวเลขสุ่ม NUM_DIGIT จาก 0 ถึง b-1 จากหมายเลขสุ่ม RAND_MAX หนึ่งหมายเลขโดยให้ b <RAND_MAX

สูตรนี้ง่ายมากดังนั้นลองใช้นิพจน์นี้ดู

 int num = (int) rand() % (max - min) + min;  
 //Where rand() returns a random number between 0.0 and 1.0

การแสดงออกต่อไปนี้ควรเป็นกลางถ้าฉันไม่ผิด:

std::floor( ( max - min + 1.0 ) * rand() ) + min;

ฉันสมมุติว่า rand () ให้ค่าสุ่มในช่วงระหว่าง 0.0 ถึง 1.0 ไม่รวม 1.0 และ max และ min นั้นเป็นจำนวนเต็มโดยมีเงื่อนไขว่า min <max