ฉันไม่สามารถเข้าใจสิ่งนี้ได้ซึ่งเป็นการสุ่มมากขึ้น?

rand()

หรือ :

rand() * rand()

ฉันพบว่ามันเป็นอุปกรณ์ช่วยพัฒนาสมองที่แท้จริงคุณสามารถช่วยฉันออกมาได้หรือไม่?

แก้ไข:

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

เพียงชี้แจง

แม้ว่าคำตอบก่อนหน้านี้จะถูกต้องเมื่อใดก็ตามที่คุณพยายามหาจุดสุ่มของตัวแปรหลอกเทียมหรือการคูณคุณควรทราบว่าในขณะที่Random ()มักจะกระจายอย่างสม่ำเสมอสม่ำเสมอRandom () * Random ()ไม่ใช่

ตัวอย่าง

นี่คือตัวอย่างการกระจายแบบสุ่มที่เหมือนกันซึ่งจำลองผ่านตัวแปรแบบหลอกเทียม:

        BarChart[BinCounts[RandomReal[{0, 1}, 50000], 0.01]]

ในขณะนี้คือการแจกแจงที่คุณได้รับหลังจากคูณตัวแปรสุ่มสองตัว:

        BarChart[BinCounts[Table[RandomReal[{0, 1}, 50000] * 
                                 RandomReal[{0, 1}, 50000], {50000}], 0.01]]

ดังนั้นทั้งคู่เป็น "สุ่ม" แต่การกระจายของพวกเขาแตกต่างกันมาก

ตัวอย่างอื่น

ในขณะที่2 * สุ่ม ()มีการกระจายอย่างสม่ำเสมอ:

        BarChart[BinCounts[2 * RandomReal[{0, 1}, 50000], 0.01]]

Random () + Random () ไม่ใช่!

        BarChart[BinCounts[Table[RandomReal[{0, 1}, 50000] + 
                                 RandomReal[{0, 1}, 50000], {50000}], 0.01]]

ทฤษฎีขีด จำกัด กลาง

ทฤษฎีขีด จำกัด กลางระบุว่าผลรวมของสุ่ม ()มีแนวโน้มไปสู่การกระจายปกติเป็นเงื่อนไขเพิ่มขึ้น

คุณจะได้รับเพียงสี่เทอม:

BarChart[BinCounts[Table[RandomReal[{0, 1}, 50000] + RandomReal[{0, 1}, 50000] +
                   Table[RandomReal[{0, 1}, 50000] + RandomReal[{0, 1}, 50000],
                   {50000}],
         0.01]]  

และที่นี่คุณสามารถเห็นถนนจากเครื่องแบบไปสู่การกระจายแบบปกติโดยการเพิ่มตัวแปรสุ่มแบบกระจายแบบสุ่ม 1, 2, 4, 6, 10 และ 20:

แก้ไข

เครดิตไม่กี่

ขอบคุณThomas Ahle ที่ชี้ให้เห็นในความคิดเห็นว่าการแจกแจงความน่าจะเป็นที่แสดงในภาพสองภาพสุดท้ายเป็นที่รู้จักกันในชื่อIrwin-Hall distribution

ขอบคุณHeikeสำหรับฟังก์ชั่นการฉีกขาดที่ยอดเยี่ยมของเธอ

ฉันเดาว่าทั้งสองวิธีนั้นเป็นแบบสุ่มแม้ว่า gutfeel ของฉันจะบอกว่าrand() * rand()มันสุ่มน้อยกว่าเพราะมันจะทำให้มีค่าเป็นศูนย์มากขึ้น ทันทีที่หนึ่งrand()คือ0ทั้งหมดจะกลายเป็น0

ไม่เป็น 'สุ่มมากกว่า'

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

การระบุว่าจะลดการชนได้หรือไม่คำตอบคือไม่ 0 < n < 1มันจริงจะเพิ่มการชนกันเนื่องจากผลกระทบของการคูณเลขสองตัวที่ ผลลัพธ์จะเป็นเศษส่วนที่เล็กลงทำให้เกิดอคติในผลลัพธ์ไปจนถึงปลายล่างของสเปกตรัม

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

รับเมล็ดxซึ่งสร้างรายการค่าต่อไปนี้:

0.3, 0.6, 0.2, 0.4, 0.8, 0.1, 0.7, 0.3, ...

rand()จะสร้างรายการด้านบนและrand() * rand()จะสร้าง:

0.18, 0.08, 0.08, 0.21, ...

ทั้งสองวิธีจะสร้างรายการหมายเลขเดียวกันสำหรับเมล็ดเดียวกันเสมอและดังนั้นจึงทำนายได้อย่างเท่าเทียมกันโดยพยากรณ์ แต่ถ้าคุณดูผลลัพธ์สำหรับการคูณสองสายคุณจะเห็นว่าพวกเขาทั้งหมดอยู่ภายใต้0.3การกระจายที่เหมาะสมในลำดับเดิม ตัวเลขมีความเอนเอียงเนื่องจากผลของการคูณสองเศษส่วน จำนวนผลลัพธ์มีขนาดเล็กกว่าเสมอดังนั้นจึงมีแนวโน้มที่จะเกิดการชนกันมากขึ้นแม้ว่าจะยังไม่แน่นอน

การใช้งานเกินขนาดเพื่อแสดงจุด

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

random()เป็นหนึ่งใน(0,1)แต่random()*random()เป็นหนึ่งใน(0,0,0,1)

คุณสามารถเห็นได้ชัดเจนว่ามีโอกาสที่จะได้รับในกรณีที่สองอยู่ในทางที่เท่ากันกับผู้ที่จะได้รับ01

เมื่อฉันโพสต์คำตอบนี้เป็นครั้งแรกฉันต้องการให้สั้นที่สุดเท่าที่จะเป็นไปได้เพื่อให้คนที่อ่านมันจะเข้าใจได้อย่างรวดเร็วถึงความแตกต่างระหว่างrandom()และrandom()*random()แต่ฉันไม่สามารถป้องกันตัวเองจากการตอบคำถามโฆษณาเดิม:

สุ่มแบบไหนดีกว่ากัน?

การที่random(), random()*random(), random()+random(), (random()+1)/2หรือการรวมกันอื่น ๆ ที่ไม่นำไปสู่ผลคงที่มีแหล่งที่มาเดียวกันของเอนโทรปี (หรือสถานะเริ่มต้นเดียวกันในกรณีของเครื่องกำเนิดไฟฟ้า pseudorandom) ให้คำตอบจะเป็นว่าพวกเขาเป็นอย่างเท่าเทียมกันโดยสุ่ม (ความแตกต่าง อยู่ในการกระจาย) ตัวอย่างที่สมบูรณ์แบบที่เราสามารถดูได้คือเกม Craps จำนวนที่คุณจะได้รับrandom(1,6)+random(1,6)และเราทุกคนรู้ว่าการได้รับ 7 มีโอกาสสูงสุด แต่นั่นไม่ได้หมายความว่าผลลัพธ์ของการทอยลูกเต๋าสองลูกนั้นจะสุ่มมากขึ้นหรือน้อยลงกว่าผลของการหมุนหนึ่งครั้ง

นี่คือคำตอบง่ายๆ พิจารณาการผูกขาด คุณหมุนลูกเต๋าหกด้านสอง (หรือ 2d6 สำหรับผู้ที่ชื่นชอบการเล่นเกม) และรับผลรวมของพวกเขา ผลลัพธ์ที่พบบ่อยที่สุดคือ 7 เพราะมี 6 วิธีที่เป็นไปได้ที่คุณสามารถหมุน 7 (1,6 2,5 3,4 4,3 5,2 และ 6,1) ในขณะที่ 2 สามารถหมุนได้เพียง 1,1 เป็นเรื่องง่ายที่จะเห็นว่าการกลิ้ง 2d6 นั้นแตกต่างจากการกลิ้ง 1d12 แม้ว่าช่วงจะเท่ากัน (ไม่สนใจว่าคุณจะได้รับ 1 ใน 1d12 แต่จุดนั้นยังคงเหมือนเดิม) การทวีคูณผลลัพธ์ของคุณแทนที่จะเพิ่มพวกเขาจะทำให้พวกเขาเอียงแบบเดียวกันโดยที่ผลลัพธ์ส่วนใหญ่ของคุณจะมาอยู่ตรงกลางของช่วง หากคุณพยายามลดค่าผิดปกตินี่เป็นวิธีที่ดี แต่จะไม่ช่วยให้มีการกระจายเท่ากัน

(และผิดปกติพอมันจะเพิ่มม้วนต่ำเช่นกันสมมติว่าการสุ่มของคุณเริ่มต้นที่ 0 คุณจะเห็นเข็มที่ 0 เพราะมันจะทำให้ม้วนอื่น ๆ กลายเป็น 0 ลองสุ่มตัวเลขสองตัวระหว่าง 0 และ 1 (รวม ) และการคูณหากผลลัพธ์อย่างใดอย่างหนึ่งเป็น 0 สิ่งทั้งหมดจะกลายเป็น 0 ไม่ว่าผลลัพธ์อื่น ๆ วิธีเดียวที่จะได้ 1 จากนั้นคือการที่ทั้งสองม้วนเป็น 1 ในทางปฏิบัติสิ่งนี้อาจไม่สำคัญ แต่มันทำให้เป็นกราฟแปลก ๆ )

xkcdบังคับ...

มันอาจช่วยให้คิดถึงสิ่งนี้ในจำนวนที่ไม่ต่อเนื่อง พิจารณาว่าต้องการสร้างตัวเลขสุ่มระหว่าง 1 ถึง 36 ดังนั้นคุณตัดสินใจว่าวิธีที่ง่ายที่สุดคือการโยนลูกเต๋าสองลูกที่มีความยุติธรรม 6 หน้า คุณได้รับสิ่งนี้:

     1    2    3    4    5    6
  -----------------------------
1|   1    2    3    4    5    6
2|   2    4    6    8   10   12
3|   3    6    9   12   15   18
4|   4    8   12   16   20   24   
5|   5   10   15   20   25   30
6|   6   12   18   24   30   36

ดังนั้นเราจึงมี 36 หมายเลข แต่ไม่ใช่ทั้งหมดที่แสดงอย่างเป็นธรรมและบางส่วนไม่เกิดขึ้นเลย ตัวเลขที่อยู่ใกล้กับเส้นทแยงมุมตรงกลาง (มุมซ้ายล่างถึงมุมขวาบน) จะเกิดขึ้นที่ความถี่สูงสุด

หลักการเดียวกันซึ่งอธิบายการแจกแจงที่ไม่เป็นธรรมระหว่างลูกเต๋าใช้กับเลขทศนิยมระหว่าง 0.0 ถึง 1.0

บางสิ่งเกี่ยวกับ "การสุ่ม" นั้นตอบโต้ได้ง่าย

สมมติว่าการกระจายแบบแบนของrand()ต่อไปนี้จะให้การกระจายแบบไม่แบน:

• อคติสูง: sqrt(rand(range^2))
• อคติจุดศูนย์กลาง: (rand(range) + rand(range))/2
• ต่ำ: อคติ: range - sqrt(rand(range^2))

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

การใช้งานแรนด์ () ส่วนใหญ่มีระยะเวลาหนึ่ง คือหลังจากมีการโทรจำนวนมหาศาลตามลำดับที่เกิดซ้ำ ลำดับของเอาต์พุตของการrand() * rand()ทำซ้ำในครึ่งเวลาดังนั้นจึงเป็น "การสุ่มน้อยลง" ในแง่นั้น

นอกจากนี้หากไม่มีการสร้างอย่างระมัดระวังการคำนวณทางคณิตศาสตร์เกี่ยวกับค่าสุ่มมักทำให้เกิดการสุ่มน้อยลง โปสเตอร์ด้านบนอ้างถึง " rand()+ rand()+ rand()... " (k คูณ, พูด) ซึ่งอันที่จริงแล้วมักจะเป็น k คูณค่าเฉลี่ยของช่วงของค่าที่rand()ส่งกลับ (เป็นการเดินสุ่มพร้อมขั้นตอนสมมาตรเกี่ยวกับค่าเฉลี่ยนั้น)

สมมติว่า concreteness ของคุณ rand () ฟังก์ชั่นส่งกลับจำนวนจริงสุ่มกระจายอยู่ในช่วง [0,1) (ใช่ตัวอย่างนี้อนุญาตความแม่นยำไม่สิ้นสุดสิ่งนี้จะไม่เปลี่ยนผลลัพธ์) คุณไม่ได้เลือกภาษาใดภาษาหนึ่งและภาษาที่แตกต่างกันอาจทำสิ่งที่แตกต่างกัน แต่การวิเคราะห์ต่อไปนี้จะมีการแก้ไข ) ผลิตภัณฑ์rand() * rand()ยังอยู่ในช่วง [0,1) แต่จะไม่กระจายอย่างสม่ำเสมอ ในความเป็นจริงผลิตภัณฑ์มีแนวโน้มที่จะอยู่ในช่วง [0,1 / 4) เช่นเดียวกับในช่วง [1 / 4,1) การทวีคูณมากขึ้นจะทำให้ผลลัพธ์เอียงไปทางศูนย์มากขึ้น ทำให้สามารถคาดการณ์ผลลัพธ์ได้มากขึ้น ในจังหวะที่กว้างสามารถคาดเดาได้มากขึ้น == สุ่มน้อยลง

ลำดับของการดำเนินการใด ๆ ในการป้อนข้อมูลแบบสุ่มอย่างสม่ำเสมอจะเป็นการสุ่มแบบไม่สม่ำเสมอซึ่งนำไปสู่การทำนายที่เพิ่มขึ้น ด้วยความระมัดระวังเราสามารถเอาชนะคุณสมบัตินี้ได้ แต่จากนั้นจะเป็นการง่ายกว่าที่จะสร้างตัวเลขสุ่มแบบกระจายอย่างสม่ำเสมอในช่วงที่คุณต้องการแทนที่จะเสียเวลาด้วยการคิดเลข

"สุ่ม" กับ "สุ่มมากขึ้น" เป็นคำถามเล็กน้อยที่ถามว่า Zero ใดเป็นศูนย์มากกว่า

ในกรณีนี้randคือ PRNG ดังนั้นจึงไม่สุ่มทั้งหมด (ในความเป็นจริงค่อนข้างคาดเดาได้ถ้ารู้จักเมล็ด) การคูณด้วยค่าอื่นทำให้ไม่สุ่มมากขึ้นหรือน้อยลง

การเข้ารหัสลับแบบ RNG จริงจะถูกสุ่ม และค่าที่ใช้งานผ่านฟังก์ชั่นประเภทใด ๆ ไม่สามารถเพิ่มเอนโทรปีให้มากขึ้นได้และอาจเป็นไปได้มากที่จะลบเอนโทรปีทำให้ไม่สุ่มขึ้น

แนวคิดที่คุณกำลังมองหาคือ "เอนโทรปี" "ระดับ" ของความผิดปกติของสตริงบิต แนวคิดนี้ง่ายต่อการเข้าใจในแง่ของแนวคิดของ "ค่าสูงสุดของเอนโทรปี"

คำจำกัดความโดยประมาณของสตริงบิตที่มีค่าเอนโทรปีสูงสุดคือไม่สามารถแสดงได้อย่างแม่นยำในแง่ของสตริงบิตที่สั้นกว่า (เช่นการใช้อัลกอริทึมเพื่อขยายสตริงเล็ก ๆ กลับไปเป็นสตริงเดิม)

ความเกี่ยวข้องของเอนโทรปีสูงสุดกับการสุ่มเกิดจากข้อเท็จจริงที่ว่าถ้าคุณเลือกตัวเลข "สุ่ม" คุณจะเลือกตัวเลขที่บิตสตริงใกล้เคียงกับเอนโทรปีสูงสุดนั่นคือมันไม่สามารถบีบอัดได้ นี่คือความเข้าใจที่ดีที่สุดของเราเกี่ยวกับลักษณะของตัวเลข "สุ่ม"

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

ในบันทึกที่ใช้งานได้จริงหากคุณพบว่าตัวเองแบกรับกับแรนดี้เส็งเคร็ง () บางครั้งมันอาจช่วยให้ xor ตัวอย่างสองสามตัวอย่างเข้าด้วยกัน --- แม้ว่าถ้ามันหักจริง ๆ แม้ว่ากระบวนการนั้นจะไม่ช่วยก็ตาม

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

วิธีที่ง่ายที่สุดในการคิดเกี่ยวกับทฤษฎีสารสนเทศคือในส่วนของหน่วยข้อมูลที่เล็กที่สุดเพียงเล็กน้อย

ในไลบรารีมาตรฐาน C ให้rand()ส่งคืนจำนวนเต็มในช่วง 0 ถึงRAND_MAXซึ่งเป็นขีด จำกัด ที่อาจกำหนดแตกต่างกันไปขึ้นอยู่กับแพลตฟอร์ม สมมติว่าRAND_MAXจะมีการกำหนดว่า2^n - 1ที่ไหนnเป็นจำนวนเต็ม (กรณีนี้เกิดขึ้นในการดำเนินการของ Microsoft ที่n15) จากนั้นเราก็จะบอกว่าการใช้งานที่ดีจะคืนค่าnบิตของข้อมูล

ลองนึกภาพว่าrand()สร้างตัวเลขสุ่มโดยการพลิกเหรียญเพื่อหาค่าหนึ่งบิตแล้วทำซ้ำจนกว่ามันจะมีชุดของ 15 บิต จากนั้นบิตจะเป็นอิสระ (ค่าของบิตใด ๆ ไม่มีผลกระทบต่อโอกาสของบิตอื่น ๆ ในชุดเดียวกันมีค่าที่แน่นอน) ดังนั้นแต่ละบิตที่พิจารณาอย่างอิสระนั้นเป็นเหมือนตัวเลขสุ่มระหว่าง 0 และ 1 ที่ครอบคลุมและเป็น "การกระจายแบบสม่ำเสมอ" ในช่วงนั้น (น่าจะเป็น 0 เป็น 1)

ความเป็นอิสระของบิตทำให้มั่นใจได้ว่าตัวเลขที่แสดงด้วยชุดของบิตจะกระจายอย่างสม่ำเสมอในช่วงของพวกเขา สิ่งนี้ชัดเจนโดยสังหรณ์ใจ: ถ้ามี 15 บิตช่วงที่อนุญาตคือศูนย์ถึง2^15 - 1= 32767 ทุกหมายเลขในช่วงนั้นเป็นรูปแบบเฉพาะของบิตเช่น:

010110101110010

และถ้าบิตเป็นอิสระจากนั้นรูปแบบไม่มีแนวโน้มที่จะเกิดขึ้นกว่ารูปแบบอื่น ๆ ดังนั้นตัวเลขที่เป็นไปได้ทั้งหมดในช่วงจึงเท่ากัน ดังนั้นสิ่งที่ตรงกันข้ามจึงเป็นจริง: หากrand()สร้างจำนวนเต็มกระจายอย่างเท่าเทียมกันตัวเลขเหล่านั้นจะทำจากบิตอิสระ

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

กลับไปที่คำแนะนำดั้งเดิมของคุณสมมติว่าคุณต้องการเปลี่ยนจากชุดที่ 15 เป็นชุดที่ 30 ขอrand()หมายเลขแรกเปลี่ยนเป็น 15 ครั้งจากนั้นเพิ่มอีกrand()ชุด นั่นคือวิธีรวมการโทรสองสายเข้าrand()โดยไม่รบกวนการกระจายแบบสม่ำเสมอ มันใช้งานได้ง่ายเพราะไม่มีการซ้อนทับกันระหว่างตำแหน่งที่คุณวางบิตของข้อมูล

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

ช่องว่างในช่วงจำนวนนั้นไม่สามารถจับได้ในแอพพลิเคชั่นหมายเลขจุดลอยตัวเนื่องจากช่วงจุดลอยตัวนั้นมีช่องว่างอยู่ในตัวซึ่งไม่สามารถแสดงได้เลย: มีจำนวนจริงที่ไม่มีที่สิ้นสุดของจำนวนจริงที่ขาดหายไป ตัวเลขจุด! ดังนั้นเราต้องเรียนรู้ที่จะอยู่กับช่องว่าง

ดังที่คนอื่น ๆ เตือนปรีชามีความเสี่ยงในเรื่องนี้โดยเฉพาะอย่างยิ่งเนื่องจากนักคณิตศาสตร์ไม่สามารถต้านทานเสน่ห์ของจำนวนจริงซึ่งเป็นสิ่งที่ทำให้เกิดความสับสนอย่างน่ากลัวที่เต็มไปด้วย infinities gnarly และความขัดแย้งที่ชัดเจน

แต่อย่างน้อยถ้าคุณคิดว่ามันเป็นเศษบิตสัญชาตญาณของคุณอาจทำให้คุณเพิ่มขึ้นอีกนิด บิตเป็นเรื่องง่ายมาก - แม้แต่คอมพิวเตอร์ก็สามารถเข้าใจได้

อย่างที่คนอื่น ๆ พูดไว้คำตอบสั้น ๆ ง่ายๆคือ: ไม่มันไม่สุ่มมากขึ้น แต่เปลี่ยนการกระจาย

สมมติว่าคุณกำลังเล่นเกมลูกเต๋า คุณมีลูกเต๋าสุ่มที่ยุติธรรมและสมบูรณ์ หากว่าก่อนที่จะมีการทอยลูกเต๋าแต่ละครั้งคุณจะใส่ลูกเต๋าสองตัวลงในชามแล้วเขย่ามันรอบ ๆ หยิบลูกเต๋าหนึ่งลูกโดยการสุ่มจากนั้นจึงกลิ้งลูกเต๋านั้น? เห็นได้ชัดว่ามันจะไม่สร้างความแตกต่าง หากลูกเต๋าทั้งคู่ให้ตัวเลขสุ่มการสุ่มเลือกหนึ่งในสองลูกเต๋านั้นจะไม่ทำให้เกิดความแตกต่าง ไม่ว่าจะด้วยวิธีใดคุณจะได้รับหมายเลขสุ่มระหว่าง 1 ถึง 6 พร้อมการกระจายแบบสม่ำเสมอในจำนวนม้วนที่เพียงพอ

ฉันคิดว่าในชีวิตจริงขั้นตอนดังกล่าวอาจมีประโยชน์หากคุณสงสัยว่าลูกเต๋าอาจไม่ยุติธรรม ถ้าพูดว่าลูกเต๋านั้นมีความไม่สมดุลเล็กน้อยดังนั้นเรามักจะให้ 1 บ่อยกว่า 1/6 ของเวลาและอีกคนหนึ่งมักจะให้ 6 อย่างผิดปกติจากนั้นการสุ่มเลือกระหว่างทั้งสองจะมีแนวโน้มที่จะปิดบังอคติ (แม้ว่าในกรณีนี้ 1 และ 6 จะยังคงเกิดขึ้นมากกว่า 2, 3, 4 และ 5 แต่ฉันเดาว่าขึ้นอยู่กับลักษณะของความไม่สมดุล)

มีคำจำกัดความของการสุ่มมากมาย นิยามหนึ่งของชุดสุ่มคือมันเป็นชุดของตัวเลขที่ผลิตโดยกระบวนการสุ่ม ตามคำจำกัดความนี้ถ้าฉันหมุนตัว fair 5 ครั้งและรับตัวเลข 2, 4, 3, 2, 5 นั่นคือชุดสุ่ม ถ้าฉันหมุนตัวแฟร์เดียวกันนั้นเสียอีก 5 ครั้งและรับ 1, 1, 1, 1, 1 นั่นก็คือซีรีย์สุ่ม

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

แก้ไข

ฉันไม่คิดว่าฉันสามารถตอบสนองต่อปัญหา Monty Hall ได้ในความคิดเห็นดังนั้นฉันจะอัปเดตคำตอบของฉัน

สำหรับผู้ที่ไม่ได้อ่านลิงก์ของเบลิซาเรียสสิ่งที่สำคัญคือ: ผู้เข้าแข่งขันรายการเกมจะมีให้เลือก 3 ประตู เบื้องหลังหนึ่งเป็นรางวัลอันทรงคุณค่าเบื้องหลังสิ่งอื่น ๆ ที่ไร้ค่า เขาเลือกประตู # 1 ก่อนที่จะเปิดเผยว่าเป็นผู้ชนะหรือผู้แพ้เจ้าภาพจะเปิดประตูหมายเลข 3 เพื่อเปิดเผยว่าเป็นผู้แพ้ จากนั้นเขาก็ให้โอกาสผู้เข้าแข่งขันสลับไปที่ประตู # 2 ผู้เข้าแข่งขันควรทำสิ่งนี้หรือไม่?

คำตอบที่ทำให้คนอื่นเข้าใจผิดคือเขาควรเปลี่ยน ความน่าจะเป็นที่การเลือกแบบดั้งเดิมของเขาคือผู้ชนะคือ 1/3 ซึ่งประตูอีกอันคือผู้ชนะคือ 2/3 สัญชาตญาณเริ่มต้นของฉันรวมถึงคนอื่น ๆ อีกหลายคนก็คือว่าจะไม่มีการสลับสับเปลี่ยนอัตราต่อรองที่เพิ่งเปลี่ยนเป็น 50:50

หลังจากทั้งหมดสมมติว่ามีคนเปิดทีวีหลังจากโฮสต์เปิดประตูสูญเสีย บุคคลนั้นจะเห็นประตูปิดที่เหลืออยู่สองแห่ง สมมติว่าเขารู้ลักษณะของเกมเขาจะบอกว่ามีโอกาส 1/2 ของแต่ละประตูที่ซ่อนรางวัล อัตราต่อรองของผู้ดูจะเป็นอย่างไร 1/2: 1/2 ในขณะที่อัตราต่อรองของผู้เข้าแข่งขันคือ 1/3: 2/3

ฉันต้องคิดเรื่องนี้จริงๆเพื่อเอาชนะสัญชาตญาณของฉันให้เป็นรูปร่าง หากต้องการจัดการกับมันให้เข้าใจว่าเมื่อเราพูดถึงความน่าจะเป็นในปัญหาเช่นนี้เราหมายถึงความน่าจะเป็นที่คุณได้รับข้อมูลที่มีอยู่ สำหรับสมาชิกของทีมที่นำรางวัลมาพูดประตู # 1 ความน่าจะเป็นที่รางวัลหลังประตู # 1 คือ 100% และความน่าจะเป็นที่อยู่ด้านหลังประตูทั้งสองของทั้งสองเป็นศูนย์

อัตราต่อรองของลูกเรือแตกต่างจากอัตราต่อรองของผู้เข้าแข่งขันเพราะเขารู้ว่าสิ่งที่ผู้เข้าแข่งขันไม่ได้กล่าวคือประตูที่เขาวางรางวัลไว้ข้างหลัง ในทำนองเดียวกันอัตราต่อรองของผู้เข้าร่วมจะแตกต่างจากอัตราต่อรองของผู้ชมเพราะเขารู้ว่าสิ่งที่ผู้ชมไม่ได้กล่าวคือประตูแรกที่เขาเลือก สิ่งนี้ไม่เกี่ยวข้องเนื่องจากตัวเลือกของโฮสต์ที่ประตูเปิดไม่สุ่ม เขาจะไม่เปิดประตูที่ผู้เข้าแข่งขันเลือกและเขาจะไม่เปิดประตูที่ซ่อนรางวัล หากสิ่งเหล่านี้เป็นประตูเดียวกันนั่นทำให้เขามีทางเลือกสองทาง หากพวกเขาเป็นประตูที่แตกต่างนั่นจะเหลือเพียงประตูเดียว

แล้วเราจะหาค่า 1/3 และ 2/3 ได้อย่างไร เมื่อผู้เข้าแข่งขันเลือกประตูมา แต่เดิมเขามีโอกาส 1/3 ในการเลือกผู้ชนะ ฉันคิดว่าชัดเจนมาก นั่นหมายความว่ามีโอกาส 2/3 ที่อีกประตูหนึ่งเป็นผู้ชนะ หากโฮสต์เกมเปิดโอกาสให้เขาสลับโดยไม่ให้ข้อมูลเพิ่มเติมใด ๆ ก็จะไม่ได้รับประโยชน์ใด ๆ อีกครั้งนี้ควรชัดเจน แต่วิธีหนึ่งที่จะมองว่ามันคือการบอกว่ามีโอกาส 2/3 ที่เขาจะชนะโดยการสลับ แต่เขามีทางเลือก 2 ทาง ดังนั้นแต่ละคนมีเพียง 2/3 หารด้วย 2 = 1/3 โอกาสในการเป็นผู้ชนะซึ่งไม่ดีไปกว่าการเลือกครั้งแรกของเขา แน่นอนเรารู้แล้วว่าผลลัพธ์สุดท้ายนี่แค่คำนวณมันในวิธีที่ต่างออกไป

แต่ตอนนี้พิธีกรเผยว่าหนึ่งในสองทางเลือกนั้นไม่ใช่ผู้ชนะ ดังนั้นโอกาสที่ 2/3 ที่ประตูที่เขาไม่ได้เลือกคือผู้ชนะตอนนี้เขารู้แล้วว่าทางเลือก 1 จาก 2 ทางเลือกไม่ใช่ใช่ อื่น ๆ อาจหรืออาจจะไม่ ดังนั้นเขาจึงไม่ได้ 2/3 หารด้วย 2 เขามีศูนย์สำหรับประตูที่เปิดอยู่และ 2/3 สำหรับประตูที่ปิด

พิจารณาว่าคุณมีปัญหาการพลิกเหรียญอย่างง่าย ๆ แม้กระทั่งหัวที่ถือว่าเป็นเรื่องแปลกและถือว่าเป็นก้อย การใช้งานเชิงตรรกะคือ:

rand() mod 2

การกระจายที่มากพอจำนวนของเลขคู่ควรเท่ากับจำนวนของเลขคี่

ตอนนี้ลองปรับแต่งเล็กน้อย:

rand() * rand() mod 2

หากผลลัพธ์ใดผลลัพธ์หนึ่งเป็นเลขคู่ผลลัพธ์ทั้งหมดควรเป็นเลขคู่ พิจารณาผลลัพธ์ที่เป็นไปได้ 4 ประการ (คู่ * แม้ = แม้กระทั่งแม้แต่ * คี่ = แม้กระทั่งคี่ * แม้แต่ = คี่ * คี่ = คี่) ตอนนี้มีการกระจายมากพอคำตอบควรเป็น 75% ของเวลา

ฉันจะพนันหัวถ้าฉันเป็นคุณ

ความคิดเห็นนี้เป็นคำอธิบายเพิ่มเติมว่าทำไมคุณไม่ควรใช้ฟังก์ชันสุ่มแบบกำหนดเองตามวิธีการของคุณมากกว่าการอภิปรายเกี่ยวกับคุณสมบัติทางคณิตศาสตร์ของการสุ่ม

เมื่อมีข้อสงสัยเกี่ยวกับสิ่งที่จะเกิดขึ้นกับการรวมกันของตัวเลขสุ่มของคุณคุณสามารถใช้บทเรียนที่คุณเรียนรู้ในทฤษฎีทางสถิติ

ในสถานการณ์ของ OP เขาต้องการทราบว่าผลลัพธ์ของ X * X = X ^ 2 โดยที่ X คือตัวแปรสุ่มที่กระจายอยู่ทั่ว Uniform [0,1] เราจะใช้เทคนิค CDF เนื่องจากเป็นเพียงการทำแผนที่แบบหนึ่งต่อหนึ่ง

ตั้งแต่ X ~ Uniform [0,1] มันคือ cdf: f _X (x) = 1 เราต้องการการแปลง Y <- X ^ 2 ดังนั้น y = x ^ 2 ค้นหา inverse x (y): sqrt (y) = x นี่ทำให้เรา x เป็นฟังก์ชันของ y ถัดไปค้นหาอนุพันธ์ dx / dy: d / dy (sqrt (y)) = 1 / (2 sqrt (y))

การแจกแจงของ Y ให้เป็น: f _Y (y) = f _X (x (y)) | dx / dy | = 1 / (2 sqrt (y))

เรายังไม่เสร็จเราต้องได้โดเมนของ Y ตั้งแต่ 0 <= x <1, 0 <= x ^ 2 <1 ดังนั้น Y อยู่ในช่วง [0, 1) หากคุณต้องการตรวจสอบว่า pdf ของ Y เป็น pdf หรือไม่ให้รวมเข้ากับโดเมน: รวม 1 / (2 sqrt (y)) จาก 0 ถึง 1และแน่นอนจะปรากฏเป็น 1 และสังเกตรูปร่างของ ฟังก์ชั่นดังกล่าวดูเหมือนว่าสิ่งที่ไม่น่าเชื่อโพสต์

สำหรับสิ่งต่าง ๆ เช่น X ₁ + X ₂ + ... + X _n , (ที่ X _i ~ Uniform [0,1]) เราสามารถอุทธรณ์ Central Theorem ซึ่งใช้งานได้กับทุกช่วงเวลา นี่คือเหตุผลที่การทดสอบ Z มีอยู่จริง

เทคนิคอื่น ๆ ในการพิจารณาผล pdf ได้แก่ การแปลง Jacobian (ซึ่งเป็นรุ่นทั่วไปของเทคนิค cdf) และเทคนิค MGF

แก้ไข: เพื่อเป็นการชี้แจงโปรดทราบว่าฉันกำลังพูดถึงการกระจายตัวของการเปลี่ยนแปลงที่เกิดขึ้นและไม่ได้การสุ่ม ที่จริงแล้วสำหรับการอภิปรายแยกต่างหาก สิ่งที่ฉันได้รับจริง ๆ ก็คือสำหรับ (rand ()) ^ 2 สำหรับแรนด์ () * แรนด์ () มันซับซ้อนกว่ามากซึ่งในกรณีใด ๆ จะไม่ส่งผลให้เกิดการแจกแจงแบบสม่ำเสมอ

ไม่ชัดเจนอย่างแน่นอน แต่rand()โดยทั่วไปจะสุ่มมากกว่าrand()*rand()โดยทั่วไปจะมีการสุ่มมากกว่าสิ่งสำคัญคือสิ่งนี้ไม่ได้มีความสำคัญมากสำหรับการใช้งานส่วนใหญ่

แต่ก่อนอื่นพวกเขาสร้างการแจกแจงที่แตกต่างกัน นี่ไม่ใช่ปัญหาถ้านั่นคือสิ่งที่คุณต้องการ แต่มันก็สำคัญ หากคุณต้องการการแจกจ่ายแบบพิเศษให้เพิกเฉยต่อคำถาม“ ซึ่งสุ่มขึ้นมา” ดังนั้นทำไมเป็นrand()สุ่มมากกว่า

แก่นแท้ของสาเหตุ rand()เป็นแบบสุ่มมากขึ้น (ภายใต้ข้อสมมติที่ว่ามันสร้างตัวเลขสุ่มแบบ floating-point ด้วยช่วง [0..1] ซึ่งเป็นเรื่องธรรมดามาก) คือเมื่อคุณคูณหมายเลข FP สองตัวพร้อมกับข้อมูลจำนวนมากใน mantissa คุณจะได้รับ การสูญเสียข้อมูลบางอย่างในตอนท้าย; มีบิตไม่เพียงพอในความแม่นยำสองเท่าของ IEEE เพื่อเก็บข้อมูลทั้งหมดที่อยู่ในความแม่นยำสองเท่าของ IEEE สองลอยแบบสุ่มเลือกจาก [0..1] และข้อมูลบิตพิเศษเหล่านั้นจะหายไป แน่นอนว่ามันไม่สำคัญว่าตั้งแต่คุณ (อาจ) ไม่ได้ใช้ข้อมูลนั้น แต่การสูญเสียเป็นเรื่องจริง มันไม่สำคัญว่าคุณจะสร้างการกระจายแบบใด (เช่นการดำเนินการที่คุณใช้ในการรวมกัน) ตัวเลขสุ่มแต่ละตัวมี 52 บิตของข้อมูลสุ่ม - ที่ '

การใช้ตัวเลขสุ่มส่วนใหญ่ไม่ใช้แม้กระทั่งการสุ่มมากเท่าที่มีในแหล่งสุ่ม รับ PRNG ที่ดีและไม่ต้องกังวลมากเกินไป (ระดับของ "ความดี" ขึ้นอยู่กับสิ่งที่คุณทำกับมันคุณต้องระวังเมื่อทำการจำลองแบบมอนติคาร์โลหรือการเข้ารหัส แต่ไม่เช่นนั้นคุณอาจใช้ PRNG มาตรฐานได้ซึ่งปกติแล้วจะเร็วกว่ามาก)

โดยทั่วไปแล้ว randoms แบบลอยตัวจะขึ้นอยู่กับอัลกอริทึมที่สร้างจำนวนเต็มระหว่างศูนย์และช่วงที่แน่นอน ดังนั้นโดยใช้ rand () * rand () คุณกำลังพูด int_rand () * int_rand () / rand_max ^ 2 - หมายถึงคุณไม่รวมจำนวนเฉพาะ / rand_max ^ 2

ที่เปลี่ยนการกระจายแบบสุ่มอย่างมีนัยสำคัญ

rand () มีการกระจายอย่างสม่ำเสมอในระบบส่วนใหญ่และยากที่จะคาดการณ์ว่าเมล็ดถูกต้องหรือไม่ ใช้สิ่งนั้นเว้นแต่ว่าคุณมีเหตุผลเฉพาะที่จะทำคณิตศาสตร์เกี่ยวกับมัน (เช่นการสร้างการกระจายไปยังโค้งที่จำเป็น)

ตัวเลขทวีคูณจะสิ้นสุดลงในช่วงที่เล็กกว่าโซลูชันขึ้นอยู่กับสถาปัตยกรรมคอมพิวเตอร์ของคุณ

หากการแสดงผลคอมพิวเตอร์ของคุณแสดงตัวเลข 16 หลักrand()จะบอกว่า 0.1234567890123 คูณด้วยวินาทีrand()0.1234567890123 จะให้ 0.0152415 สิ่งที่คุณจะได้พบกับการแก้ปัญหาน้อยลงถ้าคุณทำการทดลองซ้ำ 10 ครั้ง 14 ครั้ง

การแจกแจงส่วนใหญ่เกิดขึ้นเพราะคุณต้อง จำกัด หรือทำให้จำนวนสุ่มเป็นปกติ

เราปรับมาตรฐานให้เป็นค่าบวกพอดีภายในขอบเขตและเพื่อให้พอดีกับข้อ จำกัด ของขนาดหน่วยความจำสำหรับประเภทตัวแปรที่กำหนด

กล่าวอีกนัยหนึ่งเนื่องจากเราต้อง จำกัด การโทรแบบสุ่มระหว่าง 0 และ X (X เป็นขีด จำกัด ขนาดของตัวแปรของเรา) เราจะมีกลุ่มของตัวเลข "สุ่ม" ระหว่าง 0 ถึง X

ตอนนี้เมื่อคุณเพิ่มตัวเลขสุ่มไปยังหมายเลขสุ่มอื่นผลรวมจะอยู่ระหว่าง 0 ถึง 2X ... นี่จะทำให้ค่าอยู่ห่างจากจุดที่ขอบ (ความน่าจะเป็นที่จะเพิ่มตัวเลขสองตัวเล็ก ๆ เข้าด้วยกันและตัวเลขขนาดใหญ่สองตัวอยู่ด้วยกัน คุณมีตัวเลขสุ่มสองตัวในช่วงใหญ่)

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

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

ยกตัวอย่างเช่นRandomReal({-x, x}, 50000, .01)ถ้าอย่างนั้นคุณจะได้การกระจายตัวของตัวเลขที่เป็นบวกในด้านลบและถ้าคุณบวกเลขสุ่มเข้าด้วยกันพวกมันก็จะรักษา "การสุ่ม" ไว้

ตอนนี้ฉันไม่แน่ใจว่าจะเกิดอะไรขึ้นกับเครื่องหมายRandom() * Random()ลบถึงช่วงบวก ... นั่นจะเป็นกราฟที่น่าสนใจที่จะเห็น ... แต่ฉันต้องกลับไปเขียนโค้ดตอนนี้ :-P

1. ไม่มีสิ่งที่เป็นแบบสุ่มมากขึ้น มันเป็นแบบสุ่มหรือไม่ การสุ่มหมายถึง "ยากที่จะทำนาย" มันไม่ได้หมายถึงไม่กำหนดขึ้น ทั้ง Random () และ Random () * Random () จะสุ่มเท่ากันถ้า Random () เป็น Random การแจกแจงนั้นไม่เกี่ยวข้องเท่าที่การสุ่มเกิดขึ้น หากการกระจายที่ไม่สม่ำเสมอเกิดขึ้นก็หมายความว่าค่าบางค่ามีแนวโน้มมากกว่าค่าอื่น ๆ พวกเขายังคงคาดเดาไม่ได้

2. เนื่องจากการสุ่มหลอกมีส่วนเกี่ยวข้องตัวเลขจึงค่อนข้างแน่นอน อย่างไรก็ตามแบบแผนหลอกมักจะเพียงพอในแบบจำลองความน่าจะเป็นและแบบจำลอง เป็นที่ทราบกันดีอยู่แล้วว่าการสร้างตัวสร้างตัวเลขสุ่มหลอกนั้นซับซ้อนเพียงทำให้ยากต่อการวิเคราะห์ มันไม่น่าที่จะปรับปรุงแบบแผน; มันมักจะทำให้มันล้มเหลวในการทดสอบทางสถิติ

3. คุณสมบัติที่ต้องการของตัวเลขสุ่มมีความสำคัญ: ความสามารถในการทำซ้ำและการทำซ้ำสถิติแบบสุ่ม (ปกติ) กระจายอย่างสม่ำเสมอและมีช่วงเวลาที่มีขนาดใหญ่

4. เกี่ยวกับการแปลงของตัวเลขสุ่ม: ดังที่มีคนพูดว่าผลรวมของการแจกแจงสองแบบหรือมากกว่าอย่างสม่ำเสมอในการแจกแจงแบบปกติ นี่คือทฤษฎีบทขีด จำกัด กลางของสารเติมแต่ง มันใช้โดยไม่คำนึงถึงการกระจายแหล่งที่มาตราบใดที่การกระจายทั้งหมดเป็นอิสระและเหมือนกัน คูณทฤษฎีขีด จำกัด กลางกล่าวว่าผลคูณของตัวแปรสุ่มสองตัวที่อิสระและกระจายแบบเยื้องคือ lognormal กราฟที่คนอื่นสร้างขึ้นมีลักษณะเป็นเลขชี้กำลัง ดังนั้น random () * random () มีการกระจายแบบ lognormally (แม้ว่ามันอาจจะไม่อิสระเนื่องจากตัวเลขจะถูกดึงจากสตรีมเดียวกัน) สิ่งนี้อาจเป็นที่ต้องการในบางแอปพลิเคชัน อย่างไรก็ตามโดยปกติแล้วจะเป็นการดีกว่าหากสร้างหมายเลขสุ่มหนึ่งหมายเลขและแปลงเป็นหมายเลขที่กระจายแบบล็อกนอร์มา สุ่ม () * สุ่ม () อาจวิเคราะห์ได้ยาก

สำหรับข้อมูลเพิ่มเติมโปรดอ่านหนังสือของฉันที่ www.performorama.org หนังสือเล่มนี้อยู่ระหว่างการปรับปรุง แต่มีเนื้อหาที่เกี่ยวข้องอยู่ โปรดทราบว่าหมายเลขบทและส่วนอาจเปลี่ยนแปลงตลอดเวลา บทที่ 8 (ทฤษฎีความน่าจะเป็น) - ส่วน 8.3.1 และ 8.3.3, บทที่ 10 (ตัวเลขสุ่ม)

เราสามารถเปรียบเทียบสองอาร์เรย์ของตัวเลขเกี่ยวกับการสุ่มโดยใช้ Kolmogorov complex หากลำดับของตัวเลขไม่สามารถบีบอัดได้มันเป็นการสุ่มที่มากที่สุดที่เราสามารถเข้าถึงได้ที่ความยาวนี้ ... ฉันรู้ว่าการวัดแบบนี้เป็นทฤษฎีมากกว่า ตัวเลือก ...

อันที่จริงเมื่อคุณคิดเกี่ยวกับมันrand() * rand()เป็นน้อยrand()สุ่มกว่า นี่คือเหตุผล

โดยพื้นฐานแล้วมีเลขคี่เป็นเลขคู่เหมือนกัน และบอกว่า 0.04325 นั้นแปลกและเหมือน 0.388 คือเท่ากันและ 0.4 คือเท่ากันและ 0.15 นั้นแปลก

นั่นหมายความว่าrand()มีโอกาสเท่ากันในการเป็นเลขทศนิยมคู่หรือคี่โอกาสเท่าเทียมกันของการเป็นคู่หรือคี่ทศนิยม

ในทางกลับกันrand() * rand()มันเป็นราคาที่ซ้อนกันแตกต่างกันเล็กน้อย ให้พูดว่า:

double a = rand();
double b = rand();
double c = a * b;

aและbทั้งคู่มีโอกาส 50% ที่จะเป็นเลขคู่หรือคี่ รู้ว่า

• คู่ * แม้แต่ = แม้แต่
• คู่ * คี่ = แม้
• คี่ * odd = คี่
• คี่ * แม้ = แม้

หมายความว่ามีโอกาส 75%ที่cเป็นคู่ในขณะที่โอกาสเพียง25%เท่านั้นที่แปลกทำให้ค่าrand() * rand()คาดการณ์ได้มากกว่าrand()จึงสุ่มน้อย

ใช้ linear feedback shift register (LFSR) ที่ใช้พหุนามแบบดั้งเดิม

ผลลัพธ์จะเป็นลำดับของตัวเลขสุ่มหลอก 2 ^ n นั่นคือไม่มีการทำซ้ำในลำดับโดยที่ n คือจำนวนบิตใน LFSR .... ทำให้มีการแจกแจงแบบเดียวกัน

http://en.wikipedia.org/wiki/Linear_feedback_shift_register http://www.xilinx.com/support/documentation/application_notes/xapp052.pdf

ใช้เมล็ดพันธุ์ "สุ่ม" โดยยึดตามไมโครวินาทีของนาฬิกาคอมพิวเตอร์ของคุณหรืออาจเป็นส่วนย่อยของผล md5 จากข้อมูลที่เปลี่ยนแปลงอย่างต่อเนื่องในระบบไฟล์ของคุณ

ตัวอย่างเช่น LFSR แบบ 32 บิตจะสร้างตัวเลขที่ไม่ซ้ำกัน 2 ^ 32 ตามลำดับ (ไม่เหมือนกัน 2) เริ่มต้นด้วยเมล็ดที่กำหนด ลำดับจะอยู่ในลำดับเดียวกันเสมอ แต่จุดเริ่มต้นจะแตกต่างกัน (ชัดเจน) สำหรับเมล็ดที่แตกต่างกัน ดังนั้นหากการเรียงลำดับซ้ำระหว่างการปลูกอาจไม่ใช่ปัญหานี่อาจเป็นทางเลือกที่ดี

ฉันใช้ LFSR 128 บิตเพื่อสร้างการทดสอบแบบสุ่มในตัวจำลองฮาร์ดแวร์โดยใช้เมล็ดซึ่งเป็นผล md5 ในการเปลี่ยนแปลงข้อมูลระบบอย่างต่อเนื่อง

สมมติว่าrand()ผลตอบแทนที่ตัวเลขระหว่าง[0, 1)เป็นที่ชัดเจนว่าrand() * rand()จะเอนเอียงไปทาง 0. นี้เป็นเพราะการคูณxโดยตัวเลขระหว่างจะส่งผลให้ในจำนวนที่มีขนาดเล็กกว่า[0, 1) xนี่คือการแจกแจงของตัวเลขสุ่มอีก 10,000 ตัว:

google.charts.load("current", { packages: ["corechart"] });
google.charts.setOnLoadCallback(drawChart);

function drawChart() {
  var i;
  var randomNumbers = [];
  for (i = 0; i < 10000; i++) {
    randomNumbers.push(Math.random() * Math.random());
  }
  var chart = new google.visualization.Histogram(document.getElementById("chart-1"));
  var data = new google.visualization.DataTable();
  data.addColumn("number", "Value");
  randomNumbers.forEach(function(randomNumber) {
    data.addRow([randomNumber]);
  });
  chart.draw(data, {
    title: randomNumbers.length + " rand() * rand() values between [0, 1)",
    legend: { position: "none" }
  });
}

<script src="https://www.gstatic.com/charts/loader.js"></script>

<div id="chart-1" style="height: 500px">Generating chart...</div>

ถ้าrand()คืนค่าจำนวนเต็มระหว่าง[x, y]นั้นแสดงว่าคุณมีการแจกแจงดังต่อไปนี้ สังเกตจำนวนคี่ vs คู่ค่า:

google.charts.load("current", { packages: ["corechart"] });
google.charts.setOnLoadCallback(drawChart);
document.querySelector("#draw-chart").addEventListener("click", drawChart);

function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

function drawChart() {
  var min = Number(document.querySelector("#rand-min").value);
  var max = Number(document.querySelector("#rand-max").value);
  if (min >= max) {
    return;
  }
  var i;
  var randomNumbers = [];
  for (i = 0; i < 10000; i++) {
    randomNumbers.push(randomInt(min, max) * randomInt(min, max));
  }
  var chart = new google.visualization.Histogram(document.getElementById("chart-1"));
  var data = new google.visualization.DataTable();
  data.addColumn("number", "Value");
  randomNumbers.forEach(function(randomNumber) {
    data.addRow([randomNumber]);
  });
  chart.draw(data, {
    title: randomNumbers.length + " rand() * rand() values between [" + min + ", " + max + "]",
    legend: { position: "none" },
    histogram: { bucketSize: 1 }
  });
}

<script src="https://www.gstatic.com/charts/loader.js"></script>

<input type="number" id="rand-min" value="0" min="0" max="10">
<input type="number" id="rand-max" value="9" min="0" max="10">
<input type="button" id="draw-chart" value="Apply">

<div id="chart-1" style="height: 500px">Generating chart...</div>

ตกลงดังนั้นฉันจะพยายามเพิ่มค่าบางอย่างเพื่อเติมเต็มคำตอบของผู้อื่นโดยบอกว่าคุณกำลังสร้างและใช้ตัวสร้างตัวเลขแบบสุ่ม

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

• เอนโทรปี: ในแชนนอนเอนโทรปี
• การแจกแจง: การแจกแจงเชิงสถิติ (ปัวซอง, ปกติ, ฯลฯ )
• ประเภท: อะไรคือแหล่งที่มาของตัวเลข (อัลกอริทึมเหตุการณ์ธรรมชาติการรวมกันของ ฯลฯ ) และการใช้อัลกอริทึม
• ประสิทธิภาพ: ความรวดเร็วหรือความซับซ้อนของการดำเนินการ
• รูปแบบ: ระยะเวลา, ลำดับ, วิ่ง, ฯลฯ
• และอาจมากกว่า ...

ในคำตอบส่วนใหญ่ที่นี่การกระจายเป็นจุดสนใจหลัก แต่ด้วยการผสมผสานและการจับคู่ฟังก์ชั่นและพารามิเตอร์คุณสร้างวิธีการใหม่ในการสร้างตัวเลขสุ่มซึ่งจะมีลักษณะที่แตกต่างกันสำหรับบางส่วนที่การประเมินอาจไม่ชัดเจน

มันง่ายที่จะแสดงว่าผลรวมของตัวเลขสุ่มสองตัวนั้นไม่จำเป็นต้องสุ่ม ลองนึกภาพคุณมีตาย 6 ด้านและม้วน แต่ละหมายเลขมีโอกาส 1/6 ที่จะปรากฏ ตอนนี้บอกว่าคุณมี 2 ลูกเต๋าและสรุปผล การกระจายของจำนวนเงินดังกล่าวไม่ได้เป็น 1/12 ทำไม? เพราะตัวเลขบางอย่างปรากฏมากกว่าคนอื่น ๆ มีหลายพาร์ติชันของพวกเขา ตัวอย่างเช่นหมายเลข 2 คือผลรวมของ 1 + 1 เท่านั้น แต่ 7 สามารถเกิดขึ้นได้โดย 3 + 4 หรือ 4 + 3 หรือ 5 + 2 ฯลฯ ... ดังนั้นจึงมีโอกาสมากขึ้นที่จะเข้ามา

ดังนั้นการใช้การแปลงในกรณีนี้นอกจากนี้ในฟังก์ชั่นแบบสุ่มไม่ได้ทำให้มันสุ่มมากขึ้นหรือจำเป็นต้องรักษาแบบสุ่ม ในกรณีของลูกเต๋าด้านบนการแจกแจงจะเบ้ถึง 7 ดังนั้นจึงสุ่มน้อยลง

ตามที่คนอื่น ๆ ชี้ไปคำถามนี้ยากที่จะตอบเพราะทุกคนในพวกเรามีภาพการสุ่มในหัวของเขา

นั่นคือเหตุผลที่ฉันขอแนะนำให้คุณใช้เวลาสักครู่และอ่านผ่านเว็บไซต์นี้เพื่อให้ได้แนวคิดแบบสุ่มที่ดีขึ้น:

• http://www.random.org/

เพื่อกลับไปที่คำถามจริง ไม่มีการสุ่มมากขึ้นหรือน้อยลงในเทอมนี้:

ทั้งคู่ปรากฏแบบสุ่มเท่านั้น !

ในทั้งสองกรณี - เพียงแค่ Rand () หรือแรนด์ () * Rand () - สถานการณ์เป็นเหมือนเดิม: หลังจากที่ไม่กี่พันล้านหมายเลขลำดับจะทำซ้ำ (!) มันปรากฏแบบสุ่มต่อผู้สังเกตการณ์เพราะเขาไม่รู้จักลำดับทั้งหมด แต่คอมพิวเตอร์ไม่มีแหล่งสุ่มอย่างแท้จริง - ดังนั้นเขาจึงไม่สามารถสร้างแบบสุ่มได้เช่นกัน

เช่นอากาศสุ่มหรือไม่ เราไม่มีเซ็นเซอร์หรือความรู้เพียงพอที่จะตรวจสอบว่าสภาพอากาศเป็นแบบสุ่มหรือไม่

คำตอบนั้นขึ้นอยู่กับว่าหวังว่าแรนด์ () * แรนด์ () จะสุ่มมากกว่าแรน () แต่เป็น:

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

ถ้าคุณตรวจสอบสิ่งเหล่านี้ฉันขอแนะนำให้คุณใช้ "rand ()" แบบง่าย ๆ เนื่องจากรหัสของคุณจะอ่านง่ายขึ้น(จะไม่ถามตัวคุณเองว่าทำไมคุณถึงต้องเขียนสิ่งนี้เพราะ ... ดีกว่า 2 วินาทีขึ้นไป) ง่ายต่อการบำรุงรักษา (ถ้าคุณต้องการแทนที่ฟังก์ชัน rand ด้วย super_rand)

หากคุณต้องการการสุ่มที่ดีกว่าฉันขอแนะนำให้คุณสตรีมจากแหล่งใด ๆ ที่มีเสียงดังพอ ( วิทยุคงที่ ) และจากนั้นrand()ควรจะง่ายพอ