ข้อมูลสุ่ม
use rand::Rng;
fn main() {
// get some random data:
let mut data = [0u8; 8];
rand::rng().fill_bytes(&mut data);
println!("{:?}", data)
}
ความสุ่มคืออะไร?
คำว่า สุ่ม หมายถึงอะไรกันแน่? ในภาษาพูดทั่วไป คำนี้อาจหมายถึงสิ่งใดก็ตามที่ อยู่นอกเหนือความคาดหมาย หรือ ยังไม่ทราบค่า แต่ในทางคอมพิวเตอร์และคณิตศาสตร์ เราจำเป็นต้องมีนิยามที่รัดกุมและชัดเจนกว่านั้น โดย Wikipedia ให้นิยามเฉพาะเจาะจงไว้ว่า:
ความสุ่ม (Randomness) คือการปราศจากรูปแบบที่แน่นอนหรือไม่สามารถทำนายเหตุการณ์ล่วงหน้าได้
เราสามารถต่อยอดจากนิยามนี้ได้: การปราศจากรูปแบบ ย่อมหมายถึงการไม่มี ความลำเอียง (bias) กล่าวอีกนัยหนึ่งคือ ค่าที่เป็นไปได้ทั้งหมดมีโอกาสเกิดขึ้นเท่าๆ กัน
การจะเข้าใจว่า ค่าสุ่ม คืออะไร เรายังต้องมีบริบทกำกับด้วยเสมอ: ค่าสุ่มของเรากำลังถูกเลือกมาจากกลุ่มตัวเลขใด?
- ตัวอย่างง่ายๆ ลองนึกถึงลูกเต๋า: หน้าลูกเต๋ามีเลข 1, 2, 3, 4, 5 และ 6 ลูกเต๋าที่เที่ยงตรง (ไม่ลำเอียง / unbiased) จะทำให้แต่ละหน้ามีโอกาสเกิดขึ้นเท่ากัน ด้วยความน่าจะเป็น ⅙
- คราวนี้ลองมาดูตัวอย่างสุดขั้วชวนคิดเล่นๆ กันบ้าง: สมมติว่าเป็นเซตของจำนวนนับ (1, 2, 3, ฯลฯ) เนื่องจากจำนวนนับ
ไม่มีขีดจำกัดสูงสุด หากคุณต้องการสุ่มจำนวนนับแบบไม่ลำเอียงขึ้นมาสักหนึ่งตัว
เลข 1, 5, 1000, 1 ล้าน หรือ 1 ล้านล้าน — ทุกตัวเลขก็ควรมีโอกาสเท่ากันทั้งหมด
แต่ในความเป็นจริง สำหรับจำนวนนับ
kใดๆ จำนวนสมาชิกในช่วง1, 2, ..., kถือเป็นสัดส่วนที่น้อยมากจนเข้าใกล้อนันต์ส่วนศูนย์เมื่อเทียบกับจำนวนนับทั้งหมด ส่งผลให้ โอกาสที่จะสุ่มได้ตัวเลขจากช่วงนี้แทบจะเป็น1/∞ = 0หรือพูดอีกแง่คือ สำหรับจำนวนนับใดๆ เราย่อมคาดหวังว่าค่าสุ่มที่ไม่ลำเอียง ควรจะมีค่ามากกว่านั้นเสมอ ซึ่งเป็นไปไม่ได้ในทางปฏิบัติ ดังนั้นในทางคณิตศาสตร์จึงไม่มีสิ่งที่เรียกว่า การสุ่มจำนวนนับแบบไม่ลำเอียงอย่างแท้จริง - อีกตัวอย่างหนึ่ง: เซตของจำนวนจริงระหว่าง 0 ถึง 1 จำนวนจริงครอบคลุมทั้งเศษส่วนทั้งหมด
จำนวนอตรรกยะอย่าง π และ √2 ตลอดจนผลคูณของจำนวนเหล่านั้น…
ซึ่งมีความเป็นไปได้มากมายมหาศาลนับไม่ถ้วน แม้จะอยู่ภายในช่วงแคบๆ อย่าง
(0, 1)ก็ตาม ดังนั้นการกล่าวเพียงว่า “ทุกค่าที่เป็นไปได้มีโอกาสเกิดเท่ากัน” จึงไม่เพียงพออีกต่อไป เราจึงตีความ การปราศจากรูปแบบ ในอีกมุมมองหนึ่ง นั่นคือ ทุกช่วงย่อยที่มีขนาดเท่ากัน ย่อมมีโอกาสเกิดขึ้นเท่ากัน ตัวอย่างเช่น เราอาจแบ่งช่วง0, 1ออกเป็น0, ½และ½, 1จากนั้นโยนเหรียญเพื่อตัดสินว่าค่าสุ่มของเราจะตกอยู่ในช่วงใด สมมติว่าได้ช่วง½, 1เราก็โยนเหรียญอีกครั้งเพื่อเลือกระหว่าง½, ¾กับ¾, 1ซึ่งช่วยจำกัดขอบเขตค่าสุ่ม ของเราให้อยู่ในช่วงขนาด¼เราสามารถทำซ้ำขั้นตอนนี้กี่ครั้งก็ได้ตามต้องการ เพื่อให้ได้ค่าสุ่มระหว่าง0ถึง1ที่มีความละเอียดแม่นยำตามต้องการ — แม้ว่าในความเป็นจริง สิ่งที่เราเลือกจะไม่ใช่ค่าจุด เดี่ยวๆ ที่แน่นอน แต่เป็นเพียง ช่วงย่อยที่แคบมากๆ เท่านั้น
สิ่งที่เราได้นิยาม (หรือพยายามนิยาม) ไว้ข้างต้น คือการแจกแจงเลขสุ่มแบบสม่ำเสมอ หรือเรียกสั้นๆ ว่า การแจกแจงแบบสม่ำเสมอ (Uniform distribution) นอกจากนี้ยังมีการแจกแจงแบบไม่สม่ำเสมออีกมากมายดังที่เราจะได้ศึกษากันต่อไป และจุดที่น่าสังเกตคือ การแจกแจงแบบสม่ำเสมอไม่ได้หมายความว่าค่าที่สุ่มออกมาได้ในแต่ละครั้งจะต้องกระจายตัว เรียงกันอย่างสม่ำเสมอ เสมอไป (ลองทอยลูกเต๋า 6 ครั้งดูสิ โอกาสที่จะได้ 1, 2, 3, 4, 5, 6 ครบตามลำดับแทบเป็นไปไม่ได้เลย)
เมื่อวกกลับมาสู่โลกของการคำนวณทางคอมพิวเตอร์ ตอนนี้เราสามารถนิยามความหมายของค่าสุ่มที่มีการแจกแจงแบบสม่ำเสมอ (ค่าสุ่มที่เที่ยงตรง ไม่ลำเอียง) ในแต่ละบริบทของชนิดข้อมูลได้ดังนี้:
u32: ตัวเลขสุ่มระหว่าง 0 ถึงu32::MAXโดยทุกค่า มีโอกาสเกิดขึ้นเท่ากันBigInt: เนื่องจากชนิดข้อมูลนี้ไม่มีขอบเขตบน จึงไม่สามารถสร้างค่าสุ่ม แบบไม่ลำเอียงได้อย่างแท้จริง (เพราะจะต้องมีขนาดใหญ่เป็นอนันต์และกินหน่วยความจำไม่จำกัด)f64: เรามองว่ามันเป็นการประมาณค่าของจำนวนจริง และ ตามแบบแผนปฏิบัติทั่วไป จะจำกัดช่วงค่าให้อยู่ระหว่าง 0 ถึง 1 (หากไม่ได้ระบุไว้เป็นอย่างอื่น) ซึ่งเราจะกลับมาดูรายละเอียดของขั้นตอนวิธีการแปลงค่ากันในภายหลัง สำหรับตอนนี้ ให้ทราบว่าวิธีนี้ให้ความแม่นยำที่ระดับ 52-53 บิต (ขึ้นอยู่กับว่าใช้ขั้นตอนการแปลงรูปแบบใด โดยเอาต์พุตจะเพิ่มขึ้นทีละขั้นของεหรือε/2โดยที่1+εคือค่าที่น้อยที่สุดที่ระบบคอมพิวเตอร์สามารถแทนค่าได้ซึ่งมีค่ามากกว่า1)
ข้อมูลสุ่ม
ดังที่เห็นข้างต้น คำว่า “เลขสุ่ม” จะไร้ความหมายทันทีหากไม่มีบริบทกำกับ ส่วนคำว่า “ข้อมูลสุ่ม (Random data)” นั้น โดยทั่วไปจะหมายถึงลำดับของ ไบต์ สุ่ม โดยแต่ละไบต์สามารถมีค่าที่เป็นไปได้ 256 ค่า และทุกค่ามีโอกาสเกิดขึ้นเท่ากันทั้งหมด
เมธอด RngCore::fill_bytes ทำหน้าที่ผลิตสิ่งนี้โดยตรง นั่นคือการสร้างลำดับของไบต์สุ่ม
หากเรานำลำดับของไบต์สุ่มที่เที่ยงตรงและมีความยาวที่พอดีมาตีความให้เป็นตัวเลขจำนวนเต็ม — เช่น แปลงเป็น u32 หรือ u64 — ผลลัพธ์ที่ได้ก็จะเป็นจำนวนเต็มที่เที่ยงตรงไม่ลำเอียงเช่นเดียวกัน และเนื่องจากการแปลงค่านี้สามารถทำได้อย่างตรงไปตรงมา เมธอด RngCore::next_u32 และ RngCore::next_u64 จึงถูกจัดให้อยู่ในเทรตเดียวกัน (ในความเป็นจริง กระบวนการมักจะเกิดขึ้นในทิศทางตรงกันข้าม — ตัวสร้างเชิงอัลกอริทึมส่วนใหญ่จะประมวลผลภายในเป็นจำนวนเต็มก่อน แล้วค่อยแปลงผลลัพธ์ออกมาเป็นรูปแบบข้อมูลสุ่มตามที่ผู้ใช้ต้องการ)