The Rust Rand Book (ฉบับภาษาไทย)
นี่คือเอกสารคู่มือฉบับสมบูรณ์สำหรับไลบรารีตัวสร้างเลขสุ่ม Random ในภาษา Rust
หนังสือเล่มนี้ประกอบด้วยเนื้อหาหลักดังนี้:
- เริ่มต้นอย่างรวดเร็ว
- ภาพรวมของเครต ฟีเจอร์ และการรองรับแพลตฟอร์ม
- คู่มือผู้ใช้
- คู่มือการอัปเดต
- คู่มือผู้มีส่วนร่วม
แหล่งข้อมูลภายนอกอื่นๆ ที่น่าสนใจ:
- เอกสารอ้างอิง API สำหรับรีลีสล่าสุด
- คลังโค้ด (Repository) ของ Rand บน GitHub
- ซอร์สโค้ดของหนังสือเล่มนี้
เริ่มต้นอย่างรวดเร็ว
ด้านล่างนี้คือตัวอย่างการใช้งานสั้นๆ เพื่อให้เห็นภาพรวม หากต้องการศึกษาเพิ่มเติม โปรดดูที่ เอกสารอ้างอิง API หรือคู่มือ
มาเริ่มต้นด้วยตัวอย่างโค้ดกันเลย:
// import commonly used items from the prelude:
use rand::prelude::*;
fn main() {
// We can use random() immediately. It can produce values of many common types:
let x: u8 = rand::random();
println!("{}", x);
if rand::random() { // generates a boolean
println!("Heads!");
}
// If we want to be a bit more explicit (and a little more efficient) we can
// make a handle to the thread-local generator:
let mut rng = rand::rng();
if rng.random() { // random bool
let x: f64 = rng.random(); // random number in range [0, 1)
let y = rng.random_range(-10.0..10.0);
println!("x is: {}", x);
println!("y is: {}", y);
}
println!("Dice roll: {}", rng.random_range(1..=6));
println!("Number from 0 to 9: {}", rng.random_range(0..10));
// Sometimes it's useful to use distributions directly:
let distr = rand::distr::Uniform::new_inclusive(1, 100).unwrap();
let mut nums = [0i32; 3];
for x in &mut nums {
*x = rng.sample(distr);
}
println!("Some numbers: {:?}", nums);
// We can also interact with iterators and slices:
let arrows_iter = "➡⬈⬆⬉⬅⬋⬇⬊".chars();
println!("Lets go in this direction: {}", arrows_iter.choose(&mut rng).unwrap());
let mut nums = [1, 2, 3, 4, 5];
nums.shuffle(&mut rng);
println!("I shuffled my {:?}", nums);
}
สิ่งแรกที่คุณอาจสังเกตเห็นคือเราได้ import ทุกอย่างมาจาก prelude ซึ่งถือเป็นวิธีทางลัดที่สะดวกที่สุดในการเรียก use ฟังก์ชันต่างๆ ของ rand เช่นเดียวกับ
prelude ของไลบรารีมาตรฐาน
ที่จะนำเข้าเฉพาะไอเท็มที่ใช้งานบ่อยที่สุดเท่านั้น หากคุณไม่ต้องการใช้ prelude
ก็อย่าลืม import เทรต Rng เข้ามาด้วย!
ไลบรารี Rand จะเริ่มต้นสร้างตัวสร้างเลขสุ่มระดับเธรด (thread-local generator) ที่มีความปลอดภัยให้โดยอัตโนมัติเมื่อมีการเรียกใช้งาน
ซึ่งสามารถเข้าถึงได้ผ่านฟังก์ชัน rng() และ random สำหรับรายละเอียดเพิ่มเติมในหัวข้อนี้ โปรดดูที่ ตัวสร้างแบบสุ่ม
ในขณะที่ฟังก์ชัน random สามารถสุ่มได้เฉพาะค่าตามการแจกแจง StandardUniform
(ซึ่งขึ้นอยู่กับชนิดข้อมูลที่กำหนด) แต่การเรียก rng() จะคืนค่าแฮนเดิล (handle) ของตัวสร้างมาให้คุณ
ซึ่งตัวสร้างทุกตัวจะอิมพลีเมนต์เทรต Rng ที่มีเมธอดอำนวยความสะดวกมากมาย เช่น เมธอด random,
random_range และ sample ตามที่เห็นในตัวอย่างข้างต้น
นอกจากนี้ Rand ยังมอบฟังก์ชันการทำงานร่วมกับอิเทอเรเตอร์และสไลซ์ผ่านอีกสองเทรต คือ
IteratorRandom และ SliceRandom
RNG ที่ใช้ซีดแบบคงที่
หลายท่านที่เห็นการเรียกใช้ rand::rng() ข้างต้น อาจสงสัยว่าจะกำหนดค่าซีด (seed) แบบคงที่ได้อย่างไร
หากต้องการทำเช่นนั้น คุณจะต้องระบุตัวสร้าง RNG ที่ต้องการ แล้วเรียกใช้เมธอดอย่าง seed_from_u64 หรือ from_seed
โปรดทราบว่า seed_from_u64 ไม่เหมาะสำหรับการใช้งานเชิงรหัสลับ (cryptographic uses)
เนื่องจากค่า u64 เพียงค่าเดียวมีเอนโทรปีไม่เพียงพอที่จะซีด RNG ได้อย่างปลอดภัย
โดย RNG เชิงรหัสลับทุกตัวจะรองรับการรับค่าซีดที่เหมาะสมกว่าผ่านเมธอด from_seed
ในตัวอย่างด้านล่าง เราเลือกใช้ ChaCha8Rng เนื่องจากทำงานได้รวดเร็ว พอร์ตข้ามแพลตฟอร์มได้ และให้คุณภาพการสุ่มที่ดี
หากต้องการดูตัวสร้าง RNG ตัวอื่นๆ สามารถดูเพิ่มเติมได้ที่หัวข้อ RNGs แต่ขอแนะนำให้หลีกเลี่ยง SmallRng และ StdRng
หากคุณให้ความสำคัญกับผลลัพธ์ที่ทำซ้ำได้แน่นอน (reproducible)
use rand::{rngs::ChaCha8Rng, RngExt, SeedableRng};
fn main() {
let mut rng = ChaCha8Rng::seed_from_u64(10);
println!("Random f32: {}", rng.random::<f32>());
}
ตระกูลเครต
┌ statrs
├ rand_distr
rand_core ┬───────────────┬ rand ┘
├ chacha20 ─────┤
├ getrandom ────┘
├ rand_chacha
├ rand_hc
├ rand_isaac
├ rand_jitter
├ rand_pcg
├ rand_sfc
├ rand_seeder
├ rand_xorshift
└ rand_xoshiro
อินเทอร์เฟซ
rand_core ทำหน้าที่นิยาม RngCore และเทรตหลักอื่นๆ ตลอดจนเครื่องมือช่วยอำนวยความสะดวกสำหรับผู้ที่ต้องการอิมพลีเมนต์ RNG ขึ้นมาเอง
เครต getrandom มอบ API ระดับต่ำสำหรับเชื่อมต่อกับแหล่งสร้างเลขสุ่มเฉพาะของแต่ละแพลตฟอร์ม
ตัวสร้างเลขสุ่มเทียม
เครตต่อไปนี้ทำหน้าที่อิมพลีเมนต์ตัวสร้างเลขสุ่มเทียม (PRNG) หลากหลายรูปแบบ (ดูเพิ่มเติมได้ที่ ตัวสร้างเลขสุ่มของเรา):
chacha20มอบตัวสร้างที่ใช้อัลกอริทึมการเข้ารหัส ChaCha (ถูกเรียกใช้เป็นการภายในโดยrandผ่านฟีเจอร์แฟล็กchacha)rand_chachaมอบตัวสร้างที่ใช้ ChaCha เช่นกัน (เป็นเวอร์ชันดั้งเดิมของchacha20สำหรับงานนี้ ซึ่งคงไว้เพื่อความเข้ากันได้ย้อนหลัง)rand_hcอิมพลีเมนต์ตัวสร้างที่ใช้อัลกอริทึมการเข้ารหัส HC-128rand_isaacอิมพลีเมนต์ตัวสร้างตระกูล ISAACrand_pcgอิมพลีเมนต์ตัวสร้างตระกูล PCG สำหรับบางโมเดลที่คัดสรรมาrand_sfcอิมพลีเมนต์ตัวสร้างตระกูล SFC (Small Fast Counter)rand_xorshiftอิมพลีเมนต์ตัวสร้าง Xorshift ขั้นพื้นฐานrand_xoshiroอิมพลีเมนต์ตัวสร้าง SplitMix และ Xoshiro
โดยมีข้อยกเว้นคือ SmallRng ซึ่งถูกอิมพลีเมนต์ไว้ใน rand โดยตรง
นอกจากนี้ rand_jitter ยังมอบแหล่งเอนโทรปีที่อิงจากความผันผวนของรอบสัญญาณนาฬิกา CPU (jitter) และ
rand_seeder ทำหน้าที่แปลงข้อมูลใดๆ ที่สามารถแฮชได้มาสร้างเป็นค่าซีด (ใช้เป็นองค์ประกอบสำคัญใน การซีด RNG)
rand (เครตหลัก)
เครต rand ได้รับการออกแบบขึ้นเพื่อให้สามารถเรียกใช้งานฟังก์ชันเกี่ยวกับเลขสุ่มทั่วไปได้อย่างง่ายดาย
โดยแบ่งความสามารถออกเป็นหลายด้านดังนี้:
- โมดูล
rngsมีตัวสร้างเลขสุ่มสำเร็จรูปที่สะดวกต่อการใช้งานทั่วไป - โมดูล
distrรับผิดชอบการสุ่มค่าตามการแจกแจงทางสถิติ - โมดูล
seqรับผิดชอบการสุ่มเลือกสมาชิกจากลำดับข้อมูลและการสับเปลี่ยนลำดับ - เทรต
Rngรวบรวมเมธอดอำนวยความสะดวกหลากหลายรูปแบบสำหรับการสร้างค่าสุ่ม - ฟังก์ชัน
randomช่วยให้สุ่มสร้างค่าได้ง่ายๆ ในการเรียกใช้เพียงคำสั่งเดียว
การแจกแจง
เครต rand มุ่งเน้นอิมพลีเมนต์เฉพาะการสุ่มจากการแจกแจงที่เป็นที่นิยมที่สุดเท่านั้น
ได้แก่ การสุ่มแบบสม่ำเสมอ (Uniform) และการสุ่มแบบถ่วงน้ำหนัก (Weighted sampling) ส่วนการแจกแจงรูปแบบอื่นๆ มีเครตแยกเฉพาะรองรับ:
rand_distrมอบการสุ่มค่าที่รวดเร็วจากการแจกแจงทางสถิติที่หลากหลาย รวมถึง Normal (Gauss), Binomial, Poisson, UnitCircle และอื่นๆ อีกมากมายstatrsเป็นไลบรารีที่พอร์ตมาจาก Math.NET ของภาษา C# ซึ่งอิมพลีเมนต์ การแจกแจงหลายชนิดคล้ายคลึงกัน (อาจมีมากกว่าหรือน้อยกว่าในบางฟังก์ชัน) ควบคู่ไปกับฟังก์ชันความหนาแน่นความน่าจะเป็น (PDF) และฟังก์ชันการแจกแจงสะสม (CDF) ฟังก์ชันพิเศษทางคณิตศาสตร์อย่าง error, beta, gamma และ logistic ตลอดจนเครื่องมืออำนวยความสะดวกอื่นๆ (ทั้งนี้ เพื่อความชัดเจนstatrsไม่ได้เป็นส่วนหนึ่งของไลบรารี Rand อย่างเป็นทางการ)
ฟีเจอร์ของเครต
ขอแนะนำให้ตรวจสอบรายละเอียดฟีเจอร์ต่างๆ ได้โดยตรงจากไฟล์ Cargo.toml หรือ README.md ของแต่ละเครต
ทั้งนี้ตั้งแต่ rand v0.9 เป็นต้นมา เครตในเครือ rust-random ทั้งหมดได้เปลี่ยนมาใช้การประกาศฟีเจอร์อย่างชัดเจนเท่านั้น
(กล่าวคือ ทุกฟีเจอร์จะถูกระบุไว้อย่างครบถ้วนภายใต้ส่วน [features])
คุณสามารถดูไฟล์ Cargo.toml ของเวอร์ชันรีลีสต่างๆ ได้บน docs.rs:
- https://docs.rs/crate/rand/latest/source/Cargo.toml.orig
- https://docs.rs/crate/rand_core/latest/source/Cargo.toml.orig
- https://docs.rs/crate/rand_distr/latest/source/Cargo.toml.orig
- https://docs.rs/crate/chacha20/latest/source/Cargo.toml.orig
- https://docs.rs/crate/rand_xoshiro/latest/source/Cargo.toml.orig
- https://docs.rs/crate/rand_pcg/latest/source/Cargo.toml.orig
ฟีเจอร์ทั่วไป
ฟีเจอร์ต่อไปนี้ถือเป็นฟีเจอร์ร่วมที่พบได้ทั่วไปใน rand_core, rand, rand_distr รวมถึงในบางเครตของตระกูล RNG:
std: เปิดใช้งานความสามารถที่ขึ้นอยู่กับไลบรารีมาตรฐาน (std) โดยจะเปิดใช้งานเป็นค่าเริ่มต้นเสมอ ยกเว้นในrand_core(สำหรับการนำไปใช้งานในสภาพแวดล้อมแบบno_stdให้กำหนดdefault-features = false)alloc: เปิดใช้งานความสามารถที่จำเป็นต้องใช้ memory allocator (สำหรับการใช้งานในสภาพแวดล้อมno_std) โดยฟีเจอร์นี้จะถูกเปิดใช้งานโดยอัตโนมัติเมื่อเปิดใช้stdserde: เปิดใช้งานความสามารถในการแปลงข้อมูล (serialization) ผ่านเครตserdeเวอร์ชัน 1.0
ฟีเจอร์ของ rand_distr
เครตเลือกใช้ฟังก์ชันเลขทศนิยมจาก num_traits และ libm เพื่อให้สามารถทำงานในสภาพแวดล้อม no_std ได้
ตลอดจนรับประกันความสามารถในการทำซ้ำของผลลัพธ์ (reproducibility) แต่หากคุณต้องการใช้ฟังก์ชันเลขทศนิยมจากไลบรารีมาตรฐาน std
ซึ่งอาจให้ความแม่นยำและประสิทธิภาพที่สูงกว่า (แต่อาจส่งผลให้ค่าสุ่มที่ได้แตกต่างไปจากเดิมเล็กน้อย)
ก็สามารถเปิดใช้งานฟีเจอร์ std_math ได้ (ข้อสังเกต: หากมีเครตอื่นในโปรเจกต์ของคุณที่พึ่งพาฟีเจอร์ std
ของ num-traits ซึ่งเปิดใช้งานเป็นค่าเริ่มต้นอยู่แล้ว ก็จะส่งผลให้เข้าสู่โหมดนี้ด้วยเช่นกัน)
การรองรับแพลตฟอร์ม
ด้วยความร่วมมือและการมีส่วนร่วมอย่างต่อเนื่องจากชุมชนนักพัฒนา ส่งผลให้เครตต่างๆ ในตระกูล Rand สามารถรองรับแพลตฟอร์มได้อย่างครอบคลุมและหลากหลาย
no_std
เมื่อกำหนด default-features = false ทั้ง rand และ rand_distr จะสามารถ build และทำงานในสภาพแวดล้อมแบบ no_std ได้อย่างสมบูรณ์ โปรดดูรายละเอียดเพิ่มเติมที่ ฟีเจอร์ทั่วไป
getrandom
เครต getrandom มอบ API ระดับต่ำสำหรับดึงข้อมูลจากแหล่งเลขสุ่มเฉพาะของระบบปฏิบัติการและแพลตฟอร์มต่างๆ ซึ่งถือเป็นหัวใจและองค์ประกอบพื้นฐานที่สำคัญของทั้ง rand และ rand_core ตลอดจนไลบรารีด้านวิทยาการรหัสลับ (cryptography) อีกมากมาย โดยเครตนี้ไม่ได้ออกแบบมาสำหรับการเรียกใช้งานทั่วไปภายนอกไลบรารีระดับระบบ
WebAssembly
เนื่องจากเป้าหมายการคอมไพล์แบบ wasm32-unknown-unknown ไม่ได้ตั้งสมมติฐานล่วงหน้าเกี่ยวกับ JavaScript interface ของสภาพแวดล้อมปลายทาง ดังนั้นเครต getrandom จึงจำเป็นต้องมีการกำหนดค่าคอนฟิกเพิ่มเติม โปรดดูรายละเอียดที่ การรองรับ WebAssembly
ทั้งนี้ เป้าหมายการคอมไพล์อย่าง wasm32-wasi และ wasm32-unknown-emscripten จะไม่มีข้อจำกัดดังกล่าว
ความสามารถในการทำซ้ำ
ไลบรารีในเครือ rust-random ให้การรับประกันอย่างจำกัดเกี่ยวกับความสามารถในการทำซ้ำ (reproducibility) ของตัวสร้าง PRNG ที่ซีดได้ และอัลกอริทึมเชิงสโทแคสติก
เนื้อหาในบทนี้จะอธิบายถึงเสถียรภาพของค่าผลลัพธ์ (value-stability) ที่ได้จากกระบวนการแบบดีเทอร์มินิสติกเมื่อใช้งานไลบรารี rust-random
การเปลี่ยนแปลงที่ทำให้ API แตกหัก การเปลี่ยนแปลงค่าผลลัพธ์ และ SemVer
การเปลี่ยนแปลงโค้ดของไลบรารีจะถือว่าทำให้ API แตกหัก (API-breaking) หากการเปลี่ยนแปลงนั้นส่งผลให้โค้ดที่เคยใช้งานได้กับ API เวอร์ชันก่อนหน้าเกิดข้อผิดพลาดในการคอมไพล์ หรือเป็นการเปลี่ยนแปลงที่ไม่สามารถเข้ากันได้ย้อนหลังในรูปแบบใดๆ
เรายึดมั่นปฏิบัติตามข้อกำหนด SemVer อย่างเคร่งครัดเกี่ยวกับการเปลี่ยนแปลงที่ทำให้ API แตกหักและรูปแบบเวอร์ชัน MAJOR.MINOR.PATCH กล่าวคือ เมื่อพ้นเวอร์ชัน 1.0 ไปแล้ว เวอร์ชันไมเนอร์ใหม่จะต้องไม่นำการเปลี่ยนแปลงที่ทำให้ API แตกหักเข้ามา
ในขณะที่การเปลี่ยนแปลงจะถือว่าส่งผลกระทบต่อค่าผลลัพธ์ (value-breaking) หากการเปลี่ยนแปลงนั้นไม่ได้ทำให้โครงสร้าง API พัง แต่ทำให้ค่าเอาต์พุตที่ผลิตจากกระบวนการสโทแคสติกแบบดีเทอร์มินิสติกเปลี่ยนไป (แม้จะเรียกใช้เฉพาะส่วนของ API ใน rust-random ที่ไม่มีการแก้ไขก็ตาม)
การเปลี่ยนแปลงที่ส่งผลกระทบต่อค่าผลลัพธ์นี้ ได้รับอนุญาตให้เกิดขึ้นได้ในเวอร์ชันไมเนอร์
ไอเท็มดีเทอร์มินิสติกที่พอร์ตไม่ได้
ไอเท็มบางรายการใน API ของ rust-random (เช่น struct หรือฟังก์ชัน) อาจได้รับการประกาศไว้อย่างชัดแจ้งว่าพอร์ตไม่ได้ (non-portable) ซึ่งหมายความว่าไอเท็มนั้นจะไม่มีการรับประกันความสามารถในการทำซ้ำใดๆ ทั้งสิ้น ไอเท็มที่พอร์ตไม่ได้ยังคงทำงานแบบดีเทอร์มินิสติก (ให้ผลลัพธ์เดิมบนเครื่องเดียวกัน) แต่อาจให้ค่าผลลัพธ์ที่แตกต่างกันเมื่อรันข้ามแพลตฟอร์ม หรือเมื่อเปลี่ยนเวอร์ชันของไลบรารี (โดยอาจเกิดการเปลี่ยนแปลงที่ส่งผลกระทบต่อค่าผลลัพธ์ในรีลีสใดๆ ก็ได้)
นี่คือนโยบายใหม่ที่จะมีผลบังคับใช้กับ rand ตั้งแต่เวอร์ชัน 0.10 หรือ 1.0 เป็นต้นไป (แล้วแต่ว่าเวอร์ชันใดจะเผยแพร่ออกมาก่อน) จากเดิมในเวอร์ชัน 0.9 ที่ไม่อนุญาตให้ไอเท็มที่พอร์ตไม่ได้ทำการเปลี่ยนแปลงค่าผลลัพธ์ในรีลีสแพตช์
คำประกาศเรื่องการไม่รับประกันการพอร์ตนี้ จะต้องระบุไว้อย่างชัดเจนในเอกสาร โดยไอเท็มที่มีคำประกาศดังกล่าว ได้แก่:
ไอเท็มที่พอร์ตได้
ไอเท็มบางชนิดทำงานแบบนอนดีเทอร์มินิสติกอย่างชัดเจน (เช่น rand::rng) และบางชนิดเป็นดีเทอร์มินิสติกแต่พอร์ตไม่ได้ (ตามที่ระบุไว้ข้างต้น) ส่วนประกอบอื่นๆ ทั้งหมดใน API สาธารณะของเครต rust-random (รวมถึง PRNG การแจกแจง และอัลกอริทึมสโทแคสติกอื่นๆ) ล้วนคาดหวังให้สามารถพอร์ตได้อย่างสม่ำเสมอ:
- ผลลัพธ์ต้องสามารถทำซ้ำได้เหมือนเดิมข้ามแพลตฟอร์ม
- ผลลัพธ์ต้องสามารถทำซ้ำได้เหมือนเดิมข้ามรีลีสแพตช์
- รีลีสไมเนอร์ (รวมถึงหลังเวอร์ชัน 1.0) อาจมีการเปลี่ยนแปลงที่ส่งผลกระทบต่อค่าผลลัพธ์สำหรับไอเท็มที่พอร์ตได้ แต่การเปลี่ยนแปลงดังกล่าวจะต้องมีเหตุผลรองรับที่หนักแน่นเพียงพอ และต้องระบุไว้อย่างชัดเจนใน CHANGELOG
การทดสอบ
เราคาดหวังให้อัลกอริทึมสโทแคสติกที่พอร์ตได้ทั้งหมด ผ่านการทดสอบเสถียรภาพของค่าเอาต์พุตโดยใช้เวกเตอร์ทดสอบอ้างอิง (test vectors) รูปแบบใดรูปแบบหนึ่ง:
- PRNG ควรได้รับการทดสอบเทียบกับเวกเตอร์อ้างอิงมาตรฐานเมื่อมีให้ใช้งาน (ตัวอย่าง)
- อัลกอริทึมอื่นๆ ควรมีเวกเตอร์ทดสอบของตนเองบรรจุไว้ในการทดสอบ
value_stabilityหรือชุดทดสอบที่เทียบเท่ากัน (ตัวอย่าง)
การรองรับเวอร์ชันก่อนหน้า
เรามุ่งมั่นที่จะสนับสนุนผู้ใช้งานเครต rust-random ที่ยังคงใช้เวอร์ชัน MAJOR.MINOR ก่อนหน้า เพื่อประโยชน์ในการทำซ้ำผลลัพธ์ โดย:
- จัดเตรียมแพตช์แก้ไขช่องโหว่ด้านความปลอดภัยในเวอร์ชันแพตช์ตามความเหมาะสม
- ช่วยอำนวยความสะดวกในการพอร์ตฟีเจอร์เพิ่มเติมที่เข้ากันได้ย้อนหลัง (back-porting) จากเวอร์ชันในอนาคตกลับมาให้ เมื่อมีการร้องขอ
- การแก้ไขข้อผิดพลาดอื่นๆ อาจได้รับการพิจารณาพอร์ตย้อนกลับเป็นรายกรณี แต่หลายครั้งก็ไม่สามารถทำได้โดยไม่กระทบต่อโครงสร้าง API หรือค่าผลลัพธ์เดิม
ข้อจำกัด
ความสามารถในการพอร์ตของ usize
น่าเสียดายที่ภาษา Rust มีสิ่งหนึ่งที่เป็นข้อจำกัดเรื่อง portability ซึ่งฝังลึกอยู่ในแก่นของภาษา นั่นคือชนิดข้อมูล usize (และ isize) ตัวอย่างเช่น ขนาดของ Vec ว่างจะแตกต่างกันระหว่างระบบ 32 บิตกับ 64 บิต สำหรับงานทั่วไปสิ่งนี้ไม่ใช่ปัญหา แต่สำหรับการสร้างเลขสุ่มที่ต้องการผลลัพธ์ตรงกันข้ามแพลตฟอร์ม เรื่องนี้ถือเป็นเรื่องสำคัญอย่างยิ่ง
จึงมีกฎง่ายๆ ที่ควรปฏิบัติคือ: หากต้องการให้โค้ดสามารถพอร์ตข้ามแพลตฟอร์มได้ ห้าม สุ่มค่าชนิด usize หรือ isize โดยตรงเป็นอันขาด
ตั้งแต่ rand v0.9 เป็นต้นมา ชนิดข้อมูล isize และ usize จะไม่ได้รับการรองรับในหลายส่วนของ API สาธารณะ รวมถึงใน StandardUniform แต่ชนิด usize ยังคงได้รับการรองรับผ่าน SampleUniform และเมธอด Rng::random_range โดยระบบจะใช้วิธีการสุ่มแบบ u32 ทุกครั้งที่เป็นไปได้เพื่อเพิ่มความสามารถในการพอร์ตให้สูงสุด
ความสามารถในการพอร์ตของทศนิยม
ผลลัพธ์จากการคำนวณเลขทศนิยม (floating point) ขึ้นอยู่กับโหมดการปัดเศษและรายละเอียดเชิงลึกของขั้นตอนวิธีในแต่ละฮาร์ดแวร์ โดยเฉพาะผลลัพธ์จากฟังก์ชันอดิศัย (transcendental functions เช่น sin, cos, exp, log) มักจะมีความแตกต่างกันเล็กน้อยในแต่ละแพลตฟอร์ม ด้วยเหตุนี้ ผลลัพธ์จากการแจกแจงใน rand_distr ที่ใช้ชนิดข้อมูล f32 หรือ f64 จึงอาจไม่สามารถพอร์ตได้สมบูรณ์แบบ 100%
เพื่อลดปัญหาความแตกต่างดังกล่าว (หรืออาจเพิ่มความซับซ้อนขึ้นในบางมุม) เราจึงเลือกที่จะใช้การอิมพลีเมนต์ฟังก์ชันอดิศัยเหล่านี้จาก libm แทนไลบรารี std โปรดดูรายละเอียดเพิ่มเติมที่ ฟีเจอร์ของ rand_distr
คู่มือ
ส่วนนี้จะอธิบายแนวคิดหลักและหลักการทำงานสำคัญที่นำมาใช้ในไลบรารี Rand:
- เริ่มต้นใช้งานกับเครตใหม่
- ข้อมูลสุ่มคืออะไร และความสุ่มคืออะไรกันแน่?
- ตัวสร้างแบบสุ่มมีกี่ชนิด?
- Rand มีตัวสร้างเลขสุ่มอะไรให้ใช้บ้าง?
- การซีด PRNG และความสามารถในการทำซ้ำ
- RNG แบบขนาน
- การเปลี่ยนข้อมูลสุ่มให้เป็นค่าที่ใช้งานได้
- การแจกแจง: ควบคุมค่าสุ่มได้มากขึ้น
- กระบวนการสุ่ม: การสุ่มแบบไม่ใส่คืน
- ลำดับ
- การจัดการข้อผิดพลาด
- การทดสอบฟังก์ชันที่ใช้ RNG
การ import รายการต่างๆ (prelude)
วิธีที่สะดวกและง่ายที่สุดในการ import ไอเท็มจาก Rand คือการเรียกใช้โมดูล prelude
ซึ่งได้รวบรวมฟังก์ชันและเทรตที่สำคัญที่สุดของ Rand ไว้อย่างครบครัน โดยคัดเลือกเฉพาะรายการที่ไม่เสี่ยงต่อการเกิดปัญหาชื่อชนกัน (name conflicts)
โปรดทราบว่า Rand เวอร์ชัน 0.5 มีการปรับโครงสร้างโมดูลและจัดระเบียบเนื้อหาใหม่เป็นอย่างมากเมื่อเทียบกับเวอร์ชันก่อนหน้า แม้ว่าชื่อเดิมจะยังคงใช้งานได้อยู่ในหลายจุด (แต่ถูกซ่อนไว้ในเอกสาร) ทว่าชื่อเก่าเหล่านี้จะทยอยถูกตัดออกในอนาคต ดังนั้นเราจึงขอแนะนำอย่างยิ่งให้ปรับโค้ดของคุณมาใช้ prelude หรือระบุพาธตามโครงสร้างโมดูลใหม่ในการ import
ตัวอย่างเพิ่มเติม
หากคุณต้องการศึกษาโค้ดเพื่อเป็นแนวทางหรือแรงบันดาลใจ สามารถดูแอปพลิเคชันตัวอย่างต่อไปนี้ได้:
เริ่มต้นใช้งาน
หากคุณยังไม่ได้ติดตั้ง Rust ให้เริ่มต้นด้วยการติดตั้ง Rust ก่อนเป็นอันดับแรก
จากนั้น มาสร้างเครตใหม่และเพิ่ม rand เข้ามาเป็นดีเพนเดนซีกัน:
cargo new randomly
cd randomly
cargo add rand
ทีนี้ นำโค้ดต่อไปนี้ไปวางลงในไฟล์ src/main.rs:
use rand::prelude::*;
fn main() {
let mut rng = rand::rng();
println!("Random die roll: {}", rng.random_range(1..=6));
println!("Random UUID: 0x{:X}", rng.random::<u128>());
if rng.random() {
println!("You got lucky!");
}
}
เรียบร้อยแล้ว มาลองสั่งรันโปรแกรมกันเลย!
$ cargo run
Compiling [..]
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.99s
Running `target/debug/randomly`
Random die roll: 4
Random UUID: 0xEC3936A465339F8295EE11AB853CCDBF
You got lucky!
เครตอื่นๆ
ในคู่มือเล่มนี้ยังมีการเรียกใช้เครตอื่นๆ ประกอบด้วย เมื่อจำเป็นต้องใช้งาน คุณสามารถเลือกเพิ่มดีเพนเดนซีได้ทั้งการแก้ไขส่วน [dependencies] ในไฟล์ Cargo.toml ด้วยตนเอง หรือจะใช้คำสั่ง cargo add ก็ได้:
$ cargo add rand_distr
Updating crates.io index
Adding rand_distr v0.4.3 to dependencies
Features:
+ alloc
+ std
- serde
- serde1
- std_math
Updating crates.io index
ข้อมูลสุ่ม
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 จึงถูกจัดให้อยู่ในเทรตเดียวกัน (ในความเป็นจริง กระบวนการมักจะเกิดขึ้นในทิศทางตรงกันข้าม — ตัวสร้างเชิงอัลกอริทึมส่วนใหญ่จะประมวลผลภายในเป็นจำนวนเต็มก่อน แล้วค่อยแปลงผลลัพธ์ออกมาเป็นรูปแบบข้อมูลสุ่มตามที่ผู้ใช้ต้องการ)
ชนิดของตัวสร้าง
ในบทก่อนหน้า เราได้รู้จักกับ RngCore ซึ่งเป็นเทรตหลักที่แหล่งข้อมูลสุ่ม ทุกตัวจำเป็นต้องอิมพลีเมนต์ แต่คำว่าแหล่งข้อมูลสุ่มแท้จริงแล้วคืออะไร และมีรูปแบบใดบ้าง?
เนื้อหาในบทนี้จะเน้นทฤษฎีพื้นฐาน หากต้องการศึกษาตัวสร้างเฉพาะตัวที่ Rand มีให้ใช้งาน โปรดดูเพิ่มเติมได้ที่บท ตัวสร้างเลขสุ่ม
use rand::{RngExt, SeedableRng};
fn main() {
// prepare a non-deterministic random number generator:
let mut rng = rand::rng();
println!("{}", rng.random::<i32>()); // prints an unknown value
// prepare a deterministic generator:
let mut rng = rand::rngs::ChaCha8Rng::seed_from_u64(123);
println!("{}", rng.random::<i32>()); // prints -416273517
}
ตัวสร้างเลขสุ่มแท้
ตัวสร้างเลขสุ่มแบบแท้ หรือ TRNG (True Random Number Generator) คือกลไกที่สร้างตัวเลขสุ่มโดยการตรวจวัดสัญญาณทางกายภาพจากปรากฏการณ์ธรรมชาติ เช่น การสลายตัวของสารกัมมันตรังสี หรือสัญญาณรบกวนทางความร้อน (thermal noise) (ทั้งนี้ ไม่ว่าปรากฏการณ์เหล่านี้จะสุ่มอย่างแท้จริง หรือแท้จริงแล้วเป็นระบบดีเทอร์มินิสติก — เช่น ในสมมติฐานว่าจักรวาลนี้คือแบบจำลองคอมพิวเตอร์ — ก็ไม่ใช่ประเด็นสำคัญในที่นี้ เพราะสำหรับการใช้งานของเรา ขอเพียงผลลัพธ์ที่ได้ไม่สามารถแยกแยะออกจากความสุ่มแท้จริงได้ก็เพียงพอแล้ว)
ข้อควรทราบคือ ข้อมูลดิบที่ได้จากกระบวนการธรรมชาติเหล่านี้มักมีความลำเอียง (bias) ปะปนอยู่ จึงจำเป็นต้องผ่านขั้นตอนการขจัดความลำเอียง (debiasing) ก่อน เพื่อให้ได้ข้อมูลสุ่มที่เที่ยงตรงสม่ำเสมอตามที่เราต้องการ
ตัวสร้างเลขสุ่มเทียม
ซีพียู (CPU) ย่อมถูกออกแบบมาให้ประมวลผลแบบดีเทอร์มินิสติก (ให้ผลลัพธ์แน่นอนตามคำสั่ง) ทว่ามันกลับสามารถจำลองกระบวนการสุ่มได้อย่างยอดเยี่ยม โดยตัวสร้างเลขสุ่มเทียม หรือ PRNG (Pseudo-Random Number Generator) ส่วนใหญ่จะทำงานแบบดีเทอร์มินิสติก ซึ่งนิยามขึ้นจากองค์ประกอบหลักเพียงไม่กี่อย่าง ได้แก่:
- สถานะภายใน (internal state) เริ่มต้น
- ฟังก์ชันสำหรับคำนวณสร้างค่าสุ่มจากสถานะปัจจุบัน
- ฟังก์ชันสำหรับเลื่อนสถานะภายในก้าวไปยังสถานะถัดไป
- (ทางเลือก) ฟังก์ชันสำหรับแปลงค่า ซีด (seed) หรือ คีย์ (key) ให้กลายเป็นสถานะเริ่มต้น
คุณสมบัติความเป็นดีเทอร์มินิสติกนี้มีประโยชน์อย่างมหาศาลในหลายสถานการณ์ เช่น ช่วยให้การจำลองทางวิทยาศาสตร์ งานศิลปะเชิงคำนวณ หรือเกม สามารถเล่นซ้ำเหตุการณ์เดิมได้อย่างแม่นยำทุกประการ โดยผลลัพธ์ทั้งหมดจะขึ้นอยู่กับค่าซีดตั้งต้นเพียงอย่างเดียว สามารถศึกษาเพิ่มเติมได้ที่บท ความสามารถในการทำซ้ำ (อย่างไรก็ตาม พึงระลึกว่าความเป็นดีเทอร์มินิสติกเพียงอย่างเดียว ยังไม่เพียงพอที่จะรับประกันความสามารถในการทำซ้ำข้ามระบบ)
จุดเด่นสำคัญอีกประการของ PRNG คือความเร็วที่สูงมาก: ขั้นตอนวิธีบางตัวใช้คำสั่ง CPU เพียงไม่กี่คำสั่งต่อการสุ่มหนึ่งค่า จึงสามารถผลิตข้อมูลสุ่มตามต้องการได้เร็วกว่า TRNG ส่วนใหญ่หลายเท่าตัว
อย่างไรก็ดี PRNG ยังมีข้อจำกัดสำคัญหลายประการที่ต้องคำนึงถึง:
- ความปลอดภัยของมันขึ้นอยู่กับค่าซีดอย่างสิ้นเชิง: หากผู้ไม่หวังดีล่วงรู้หรือคาดเดาค่าซีดได้ และทราบขั้นตอนวิธีที่ใช้ ลำดับผลลัพธ์ที่จะเกิดขึ้นก็จะมีเพียงไม่กี่รูปแบบที่คาดเดาได้ทันที
- เนื่องจากขนาดสถานะภายในมักมีขนาดคงที่ จำนวนค่าเอาต์พุตที่เป็นไปได้จึงมีขอบเขตจำกัด ก่อนที่ตัวสร้างจะวนรอบกลับมาสร้างลำดับซ้ำเดิม (หมดคาบ/ความยาววัฏจักร)
- อัลกอริทึมหลายตัวสามารถถูกคำนวณทำนายค่าถัดไปได้ง่ายมากหลังจากสังเกตเห็นตัวเลขเพียงไม่กี่ค่า และยังมีอีกหลายอัลกอริทึม ที่ไม่มีหลักฐานยืนยันแน่ชัดว่าจะไม่ถูก “ถอดรหัส” ได้ในอนาคต
ตัวสร้างเลขสุ่มเทียมเชิงรหัสลับ
ตัวสร้างเลขสุ่มเทียมเชิงรหัสลับ หรือ CSPRNG (Cryptographically Secure Pseudo-Random Number Generator) คือกลุ่มย่อยของ PRNG ที่ผ่านเกณฑ์ความปลอดภัยระดับสูง กล่าวคือ:
- สถานะภายในมีขนาดใหญ่เพียงพอ จนทำให้การโจมตีแบบ brute-force (การไล่สุ่มเดาค่าเริ่มต้นที่เป็นไปได้ทั้งหมด) เป็นไปไม่ได้ในทางปฏิบัติที่จะแกะรอยหาสถานะเริ่มต้นจากลำดับค่าเอาต์พุตที่สังเกตเห็น
- และไม่มีขั้นตอนวิธีอื่นใดที่มีประสิทธิภาพเหนือกว่าการ brute-force อย่างมีนัยสำคัญ ที่จะทำให้สามารถคาดเดาค่าเอาต์พุตถัดไปได้จริง
การสร้างเลขสุ่มที่ปลอดภัยอย่างแท้จริง ไม่ได้อาศัยเพียงขั้นตอนวิธีที่มั่นคงปลอดภัย (CSPRNG) เท่านั้น แต่ยังต้องมีค่าซีดที่ปลอดภัยและมีขนาดใหญ่เพียงพอด้วย (โดยทั่วไปคือ 256 บิต) ตลอดจนมีระบบป้องกันการโจมตีผ่านช่องทางด้านข้าง (side-channel attacks เพื่อป้องกันไม่ให้ผู้โจมตีแอบอ่านสถานะภายใน)
นอกจากนี้ CSPRNG ชั้นดียังมีคุณสมบัติประการที่สามเพิ่มเติมด้วย นั่นคือ:
- มีความทนทานต่อการแกะรอยย้อนกลับ (backtracking resistant): กล่าวคือ ผู้โจมตีจะไม่สามารถ คำนวณย้อนหาค่าเอาต์พุตก่อนหน้าของ PRNG ได้ แม้ว่าจะสามารถล่วงรู้สถานะภายในปัจจุบัน ณ ขณะใดขณะหนึ่งได้แล้วก็ตาม (แม้ว่าเอาต์พุตทั้งหมดในอนาคตจะตกอยู่ในความเสี่ยงแล้วก็ตาม)
ตัวสร้างเลขสุ่มแบบฮาร์ดแวร์
ตัวสร้างเลขสุ่มแบบฮาร์ดแวร์ หรือ HRNG (Hardware Random Number Generator) ในทางทฤษฎีคืออุปกรณ์แปลงสัญญาณจาก TRNG ทางกายภาพมาเป็นข้อมูลดิจิทัล แต่ในทางปฏิบัติ อุปกรณ์เหล่านี้มักผนวกเอา PRNG เข้ามาช่วยขจัดความลำเอียง (debias) ของสัญญาณจาก TRNG ด้วย แม้ว่า HRNG จะอาศัยฐานจาก TRNG แต่ก็ไม่ได้แปลว่าจะปลอดภัยเสมอไป: เพราะตัว TRNG เองอาจผลิตเอนโทรปีได้ไม่เพียงพอ (ทำให้สุ่มเดาได้ง่ายเกินไป) หรือกระบวนการขยายสัญญาณและการขจัดความลำเอียงอาจมีข้อบกพร่อง
เราสามารถใช้ HRNG เพื่อสร้างค่าซีดตั้งต้นให้แก่ PRNG ได้ แม้ว่าโดยปกติจะไม่ใช่วิธีเดียวในการได้มาซึ่งซีดที่ปลอดภัย (ดูหัวข้อถัดไป) หรืออาจใช้ HRNG ทำหน้าที่แทน PRNG ทั้งหมดไปเลยก็ได้ แต่เนื่องจากปัจจุบันเรามีอัลกอริทึม PRNG ระดับซอฟต์แวร์ที่ทั้งเร็วและมั่นคงปลอดภัยสูงมาก อีกทั้งซอฟต์แวร์ยังตรวจสอบความถูกต้องได้ง่ายกว่าฮาร์ดแวร์มาก การใช้ HRNG ทำงานทดแทนทั้งหมดจึงมักไม่ใช่วิธีที่นิยมที่สุด
เนื่องจาก PRNG จำเป็นต้องมีค่าซีดที่สุ่มจริงจึงจะปลอดภัย การมี HRNG จึงช่วยป้อนค่าซีดดังกล่าวได้ ทว่าเป้าหมายส่วนใหญ่ของการใช้งานคือ “เพียงแค่” ต้องการค่าสุ่มที่ไม่สามารถทำนายล่วงหน้าได้ จึงมีทางเลือกอื่นที่ยอมรับได้และนำมาใช้ทดแทนตัวสร้างเลขสุ่มแท้ (ดูหัวข้อถัดไป)
เอนโทรปี
ดังที่ได้ระบุไว้ข้างต้น การที่ CSPRNG จะปลอดภัยได้นั้น ค่าซีดของมันก็ต้องมีความปลอดภัยด้วย คำว่า เอนโทรปี (entropy) สามารถใช้ได้ในสองบริบท:
- ในแง่การวัดปริมาณข้อมูลที่ไม่ทราบค่า (ความไม่แน่นอน) ที่บรรจุอยู่ในชุดข้อมูลนั้นๆ
- ในแง่ของก้อนข้อมูลที่ไม่ทราบค่าโดยตรง
ในทางอุดมคติ ค่าสุ่มแบบบูลีนหรือการโยนเหรียญหนึ่งครั้งจะมีเอนโทรปี 1 บิตเต็ม แต่หากเหรียญนั้นมีความลำเอียง ปริมาณเอนโทรปีก็จะลดลง โดยมีทฤษฎีเอนโทรปีของแชนนอน (Shannon Entropy) ทำหน้าที่วัดปริมาณความไม่แน่นอนนี้
ตัวอย่างเช่น ค่าเวลา Unix timestamp (จำนวนวินาทีนับตั้งแต่ต้นปี 1970) ประกอบด้วยทั้งข้อมูลความละเอียดต่ำและสูง โดยทั่วไปจะเป็นตัวเลขขนาด 32 บิต แต่ปริมาณเอนโทรปีที่แท้จริงจะขึ้นอยู่กับว่าผู้โจมตีในทางทฤษฎีสามารถคาดเดาตัวเลขนั้นได้แม่นยำเพียงใด หากผู้โจมตีสามารถเดาได้ใกล้เคียงในระดับนาที เอนโทรปีของมันอาจเหลือเพียงประมาณ 6 บิต (2^6 = 64) แต่หากผู้โจมตีสามารถเดาได้แม่นยำถึงระดับวินาที เอนโทรปีจะกลายเป็น 0 บิตทันที ทั้งนี้ เครต JitterRng ได้ประยุกต์ใช้แนวคิดนี้เพื่อรวบรวมเอนโทรปีโดยไม่ต้องพึ่งพา HRNG (โดยอาศัยตัวจับเวลาความละเอียดระดับนาโนวินาที และตั้งสมมติฐานแบบรัดกุมว่ามีเอนโทรปีเพียงไม่กี่บิตต่อหนึ่งค่าเวลา หลังจากผ่านการทดสอบคุณภาพของตัวจับเวลาหลายขั้นตอนแล้ว)
ตัวสร้างเลขสุ่มของเรา
RNG มีหลายประเภท ซึ่งแต่ละแบบมีข้อดีข้อเสียแตกต่างกันไป โดย Rand ได้รวบรวมตัวสร้างสำเร็จรูปที่สะดวกต่อการใช้งานไว้ใน โมดูล rngs โดยส่วนใหญ่แล้ว คุณสามารถเรียกใช้ rand::rng ได้ทันที ซึ่งเป็นฟังก์ชันที่จะสร้างและกำหนดค่าเริ่มต้นให้กับ RNG ประจำหน่วยความจำระดับเธรดโลคอลโดยอัตโนมัติ พร้อมทั้งคืนค่าอ้างอิงกลับมาให้ โดยตัวสร้างนี้ทำงานได้อย่างรวดเร็ว ให้คุณภาพความสุ่มสูง และมั่นคงปลอดภัยในเชิงรหัสลับ (ตามความรู้ทางวิทยาการรหัสลับในปัจจุบัน)
เนื้อหาในเอกสารนี้:
ตัวสร้างต่างๆ
ตัวสร้างเลขสุ่มเทียมพื้นฐาน (PRNG)
เป้าหมายหลักของ PRNG ที่ไม่ใช่เชิงรหัสลับแบบ “มาตรฐาน” คือการสร้างสมดุลที่ลงตัวระหว่างความเรียบง่าย คุณภาพทางสถิติ การประหยัดหน่วยความจำ และประสิทธิภาพความเร็ว ตัวสร้างที่ไม่ใช่เชิงรหัสลับได้รับการพัฒนาขึ้นมาก่อนตัวสร้างเชิงรหัสลับ และในหลายบริบทก็ถูกแทนที่ไปแล้ว แต่ถึงกระนั้น ตัวสร้างที่ไม่ใช่เชิงรหัสลับก็ยังมีข้อได้เปรียบเฉพาะตัวที่โดดเด่นอยู่หลายประการ ได้แก่: ขนาดสถานะภายในกะทัดรัด, เริ่มต้นทำงานได้อย่างรวดเร็ว, โครงสร้างเรียบง่าย, และประหยัดพลังงานเป็นพิเศษบนชิปซีพียูแบบฝังตัว (embedded) (แม้ว่าจะไม่ใช่ PRNG ที่ไม่ใช่เชิงรหัสลับทุกตัวจะมีข้อดีเหล่านี้ครบถ้วน เช่น Mersenne Twister ที่มีขนาดสถานะใหญ่มากแม้จะคาดเดาผลลัพธ์ได้ง่ายก็ตาม)
ขั้นตอนวิธีเหล่านี้มีความสำคัญอย่างยิ่งต่อการจำลองด้วยระเบียบวิธีมอนติคาร์โล (Monte Carlo simulations) ตลอดจนเหมาะกับงานอื่นๆ อีกมากมาย เช่น อัลกอริทึมแบบสุ่มและเกมคอมพิวเตอร์ ซึ่งการที่ผลลัพธ์สามารถทำนายได้นั้นไม่ได้ก่อให้เกิดปัญหา (อย่างไรก็ตาม โปรดทราบว่าสำหรับเกมการพนัน ความสามารถในการทำนายผลลัพธ์ย่อมส่งผลกระทบโดยตรงต่อความปลอดภัย จึงแนะนำให้เลือกใช้ PRNG เชิงรหัสลับเสมอ)
โปรเจกต์ Rand ได้จัดเตรียม PRNG ที่ไม่ใช่เชิงรหัสลับไว้ให้เลือกใช้หลายตัว ซึ่งสามารถสรุปตัวเด่นๆ ได้ดังตารางด้านล่างนี้ นอกจากนี้ คุณยังสามารถศึกษาเพิ่มเติมได้จากเว็บไซต์ pcg-random และ xoshiro
| ชื่อ | ชื่อเต็ม | ประสิทธิภาพ | หน่วยความจำ | คุณภาพ | คาบ | ฟีเจอร์ |
|---|---|---|---|---|---|---|
SmallRng | (ไม่ระบุ) | เร็ว | เล็ก | ★★★☆☆ | ≥ u32 * 264 | พอร์ตไม่ได้ |
Pcg32 | PCG XSH RR 64/32 (LCG) | 5 GB/s | 16 ไบต์ | ★★★☆☆ | u32 * 264 | ก้าวกระโดดลำดับ |
Pcg64 | PCG XSL 128/64 (LCG) | 7 GB/s | 32 ไบต์ | ★★★☆☆ | u64 * 2128 | ก้าวกระโดดลำดับ |
Pcg64Mcg | PCG XSL 128/64 (MCG) | 8 GB/s | 16 ไบต์ | ★★★☆☆ | u64 * 2126 | ก้าวกระโดดลำดับ |
XorShiftRng | Xorshift 32/128 | 7 GB/s | 16 ไบต์ | ★☆☆☆☆ | u32 * 2128 - 1 | — |
Xoshiro256PlusPlus | Xoshiro256++ | 11 GB/s | 32 ไบต์ | ★★★☆☆ | u64 * 2256 - 1 | ก้าวกระโดดลำดับ |
Xoshiro256Plus | Xoshiro256+ | 13 GB/s | 32 ไบต์ | ★★☆☆☆ | u64 * 2256 - 1 | ก้าวกระโดดลำดับ |
SplitMix64 | splitmix64 | 13 GB/s | 8 ไบต์ | ★☆☆☆☆ | u64 * 264 | — |
StepRng | counter | 35 GB/s | 16 ไบต์ | ☆☆☆☆☆ | u64 * 264 | — |
ตัวเลขประสิทธิภาพในตารางเป็นการวัดแบบคร่าวๆ สำหรับการสร้างเอาต์พุต u64 บนซีพียู
AMD Ryzen 9 9950X3D (โปรดทราบว่าตัวเลขนี้อาจแปรผันตามแอปพลิเคชัน โดยทั่วไปแล้ว RNG เชิงรหัสลับจะทำงานได้ดียิ่งขึ้นเมื่อสร้างเอาต์พุตเป็นลำดับไบต์) ส่วนคะแนนคุณภาพอิงตามการวิเคราะห์ทางทฤษฎีและข้อบกพร่องทางสถิติที่ตรวจพบ โดยมีเกณฑ์คร่าวๆ ดังนี้:
- ★☆☆☆☆ = เหมาะกับแอปพลิเคชันพื้นฐานทั่วไป แต่ยังมีข้อบกพร่องอย่างมีนัยสำคัญ
- ★★☆☆☆ = ไม่พบปัญหาสำคัญในการทดสอบคุณภาพทางสถิติ
- ★★★☆☆ = รากฐานทฤษฎีดี และไม่พบปัญหาสำคัญในการทดสอบคุณภาพ
- ★★★★★ = คุณภาพระดับวิทยาการรหัสลับ
ตัวสร้างเลขสุ่มเทียมเชิงรหัสลับ (CSPRNG)
CSPRNG มีมาตรฐานและข้อกำหนดที่เข้มงวดกว่า PRNG พื้นฐานอย่างมาก ปัจจัยหลักที่ต้องให้ความสำคัญสูงสุดคือความปลอดภัย ประสิทธิภาพและความเรียบง่ายยังคงสำคัญ แต่โดยทั่วไป CSPRNG จะมีความซับซ้อนมากกว่าและทำงานช้ากว่า PRNG ทั่วไป ส่วนเรื่องคุณภาพทางสถิตินั้นไม่ใช่ประเด็นที่ต้องกังวลอีกต่อไป เนื่องจากข้อกำหนดพื้นฐานของ CSPRNG ระบุว่าเอาต์พุตที่สร้างขึ้นจะต้องไม่สามารถแยกแยะออกจากความสุ่มแท้จริงได้ เพราะหากมีความลำเอียงหรือความสัมพันธ์ใดๆ ปรากฏขึ้น เอาต์พุตนั้นก็จะถูกคาดเดาได้ง่ายขึ้นทันที
CSPRNG มีความเชื่อมโยงอย่างแนบแน่นกับขั้นตอนวิธีการเข้ารหัส (cipher) โดยไซเฟอร์แบบบล็อก (block cipher) ใดๆ สามารถแปลงให้เป็น CSPRNG ได้ด้วยการเข้ารหัสตัวนับ ในขณะที่ไซเฟอร์แบบสตรีม (stream cipher) โดยแก่นแท้ก็คือ CSPRNG ที่ผนวกเข้ากับการดำเนินการผสมข้อมูล (ซึ่งมักเป็นการ XOR) หมายความว่าเราสามารถนำไซเฟอร์แบบสตรีมใดๆ มาประยุกต์ใช้เป็น CSPRNG ได้อย่างตรงไปตรงมา
ไลบรารีนี้มี CSPRNG ให้เลือกใช้งานดังตารางด้านล่าง (ทั้งนี้ เราไม่สามารถรับประกันข้ออ้างด้านความปลอดภัยใดๆ ได้อย่างสมบูรณ์แบบ) โดยตารางนี้ได้ละคอลัมน์ “คุณภาพ” ออกไป เนื่องจาก CSPRNG ที่ดีจะต้องไม่มีข้อบกพร่องทางสถิติใดๆ ที่สังเกตได้
| ชื่อ | ชื่อเต็ม | ประสิทธิภาพ | การเริ่มต้น | หน่วยความจำ | ความปลอดภัย (การทำนายผลลัพธ์) | การรักษาความลับไปข้างหน้า |
|---|---|---|---|---|---|---|
StdRng | (ไม่ระบุ) | เร็ว | เร็ว | (ไม่ระบุ) | ได้รับความเชื่อถืออย่างกว้างขวาง | ไม่ |
ChaCha20Rng | ChaCha20 | 2.6 GB/s | เร็ว | 320 ไบต์1 | ผ่านการวิเคราะห์อย่างเข้มงวด | ไม่ |
ChaCha12Rng | ChaCha12 | 4.1 GB/s | เร็ว | 320 ไบต์1 | มีระดับความปลอดภัยเผื่อไว้สูงมาก | ไม่ |
ChaCha8Rng | ChaCha8 | 5.8 GB/s | เร็ว | 320 ไบต์1 | มีระดับความปลอดภัยเผื่อไว้เพียงพอ | ไม่ |
Hc128Rng | HC-128 | 4.6 GB/s | ช้า | 4176 ไบต์ | แนะนำโดย eSTREAM | ไม่ |
IsaacRng | ISAAC | 2.1 GB/s | ช้า | 2072 ไบต์ | ไม่ทราบ | ไม่ทราบ |
Isaac64Rng | ISAAC-64 | 3.7 GB/s | ช้า | 4136 ไบต์ | ไม่ทราบ | ไม่ทราบ |
ข้อสังเกต: ตัวสร้าง ISAAC ถูกรวมไว้ด้วยเหตุผลทางประวัติศาสตร์เท่านั้น เนื่องจากอยู่คู่กับภาษา Rust มาตั้งแต่ยุคเริ่มต้น แม้ว่าจะให้เอาต์พุตคุณภาพดีและยังไม่พบช่องโหว่การโจมตีที่สัมฤทธิ์ผล แต่มันกลับได้รับความสนใจจากผู้เชี่ยวชาญด้านวิทยาการรหัสลับค่อนข้างน้อย
บันทึกเกี่ยวกับตัวสร้าง
ประสิทธิภาพ
สิ่งแรกที่ควรทำความเข้าใจคือ PRNG ส่วนใหญ่ทำงานได้เร็วมาก และแทบไม่เคยตกเป็นคอขวดด้านประสิทธิภาพของระบบ
ประสิทธิภาพของ PRNG พื้นฐานเป็นเรื่องที่ค่อนข้างละเอียดอ่อน ขึ้นอยู่กับสถาปัตยกรรมของซีพียู (32 บิต เทียบกับ 64 บิต), การอินไลน์โค้ด (inlining) และจำนวนรีจิสเตอร์ที่พร้อมใช้งานเป็นอย่างมาก ส่งผลให้ประสิทธิภาพมักได้รับอิทธิพลจากโค้ดที่อยู่แวดล้อมอันเนื่องมาจากการอินไลน์และการแย่งใช้รีจิสเตอร์ของซีพียู
เมื่อต้องการเลือก PRNG เพื่อเน้นประสิทธิภาพ สิ่งสำคัญคือการวัดประสิทธิภาพ (benchmark) ภายในแอปพลิเคชันของคุณเอง เนื่องจากผลลัพธ์จริงจะขึ้นอยู่กับปฏิสัมพันธ์ระหว่าง PRNG กับโค้ดโดยรอบ สถาปัตยกรรมซีพียู ตลอดจนขนาดของข้อมูลที่เรียกขอ ด้วยเหตุนี้ เราจึงไม่ระบุตัวเลขประสิทธิภาพแบบเจาะจง แต่ให้คะแนนเชิงคุณภาพแทน
ในทางกลับกัน CSPRNG จะทำงานแตกต่างออกไปเล็กน้อย โดยทั่วไปมันจะสร้างบล็อกของเอาต์พุตเก็บไว้ในแคช แล้วค่อยดึงข้อมูลจากแคชออกมาใช้งาน กลไกนี้ช่วยให้ประสิทธิภาพเฉลี่ยอยู่ในเกณฑ์ดี และช่วยลดหรือขจัดอิทธิพลของโค้ดโดยรอบที่มีต่อความเร็วของ CSPRNG ได้อย่างมีประสิทธิผล
ประสิทธิภาพกรณีแย่ที่สุด
PRNG แบบเรียบง่ายจะสร้างค่าสุ่มแต่ละค่าขึ้นมาทันทีเมื่อมีการร้องขอ ส่วน CSPRNG มักจะสร้างข้อมูลขึ้นมาทั้งบล็อกในคราวเดียว แล้วทยอยอ่านข้อมูลจากแคชนี้จนหมด ทำให้เมื่อมีการเรียกขอข้อมูลสุ่มในปริมาณน้อยๆ ความสม่ำเสมอของเวลาที่ใช้จึงอาจมีความผันผวนมากกว่า
การใช้หน่วยความจำ
PRNG แบบพื้นฐานมักใช้หน่วยความจำน้อยมาก โดยทั่วไปเพียงไม่กี่คำ (words) ของหน่วยความจำ โดยที่หนึ่ง คำ มักมีขนาดเท่ากับ u32 หรือ u64 อย่างไรก็ดี สิ่งนี้อาจไม่เป็นจริงสำหรับ PRNG ที่ไม่ใช่เชิงรหัสลับทุกตัว ตัวอย่างเช่น อัลกอริทึม Mersenne Twister MT19937 ที่มีชื่อเสียงในอดีต ต้องใช้พื้นที่เก็บสถานะถึง 2.5 kB
สำหรับ CSPRNG มักต้องการหน่วยความจำมากกว่า เนื่องจากมีข้อแนะนำว่าขนาดซีดควรมีอย่างน้อย 192 บิต และตัวอัลกอริทึมเองอาจต้องใช้พื้นที่เพิ่มเติมอีกเล็กน้อย โดยขนาด 256 บิตถือเป็นขนาดขั้นต่ำที่ปลอดภัยในทางปฏิบัติ และหลายตัวใช้มากกว่านั้นค่อนข้างมาก ส่วน ChaCha20Rng ถือว่ามีขนาดสถานะที่ค่อนข้างกะทัดรัดเพียง 136 ไบต์
เวลาในการเริ่มต้น
ระยะเวลาที่ใช้ในการเริ่มต้นสร้างอินสแตนซ์ใหม่มีความแตกต่างกันอย่างมีนัยสำคัญ PRNG แบบง่ายหลายตัว ตลอดจนตัวสร้างเชิงรหัสลับบางตัว (รวมถึง ChaCha20Rng) เพียงแค่คัดลอกค่าซีดและค่าคงที่บางค่าลงในสถานะ ทำให้เริ่มต้นทำงานได้เร็วมาก ในทางตรงกันข้าม CSPRNG ที่มีสถานะขนาดใหญ่อาจจำเป็นต้องผ่านกระบวนการขยายคีย์ (key expansion) ซึ่งต้องใช้เวลาประมวลผลสูงกว่า
คุณภาพ
PRNG พื้นฐานจำนวนมากเป็นเพียงการประมวลผลระดับบิตและการคำนวณทางคณิตศาสตร์สั้นๆ ไม่กี่ขั้นตอน ความเรียบง่ายนี้ช่วยให้ทำงานได้เร็วมาก แต่ก็หมายความว่าอาจมีรูปแบบซ้ำซ้อนเล็กๆ ซ่อนอยู่ภายในสตรีมของตัวเลขสุ่มที่ผลิตออกมา
รูปแบบซ้ำซ้อนที่ซ่อนอยู่เหล่านี้มีผลกระทบมากน้อยเพียงใด? เป็นเรื่องยากที่จะระบุได้อย่างตายตัว เพราะขึ้นอยู่กับลักษณะการนำ RNG ไปใช้งาน หากเกิดความสัมพันธ์เชิงสหสัมพันธ์ (correlation) ระหว่างตัวเลขสุ่มกับขั้นตอนวิธีของแอปพลิเคชันที่นำมันไปใช้ ผลลัพธ์ที่คำนวณได้ก็อาจคลาดเคลื่อนหรือผิดเพี้ยนไปอย่างสิ้นเชิง
ตัวสร้างเลขสุ่มที่ดีคือตัวสร้างที่สามารถให้ผลลัพธ์ที่ถูกต้องแม่นยำในแอปพลิเคชันที่หลากหลายมากที่สุดเท่าที่จะเป็นไปได้ โดยคุณภาพของอัลกอริทึม PRNG สามารถประเมินได้ในระดับหนึ่งผ่านการวิเคราะห์ทางทฤษฎี เพื่อหาความยาววัฏจักรและตัดรูปแบบสหสัมพันธ์บางประการออกไป จากนั้นจึงนำไปทดสอบด้วยชุดเครื่องมือทดสอบเชิงประจักษ์ (empirical test suites) เพื่อตรวจดูว่า PRNG นั้นผ่านการทดสอบในสถานการณ์จำลองต่างๆ ได้ดีเพียงใด ซึ่งชุดทดสอบที่ทันสมัยและครอบคลุมที่สุดในปัจจุบันคือ TestU01 และ PractRand
ส่วน CSPRNG จะมีความซับซ้อนสูงกว่า และมีข้อกำหนดบังคับที่ชัดเจนว่าเอาต์พุตจะต้องไม่สามารถคาดเดาได้ ซึ่งหมายความว่าจะต้องไม่มีความสัมพันธ์เชิงสหสัมพันธ์ใดๆ ปรากฏระหว่างค่าเอาต์พุตให้ตรวจจับได้เลย
ดาวคุณภาพ:
PRNG ที่ได้คะแนนระดับ 3 ดาวขึ้นไป ถือว่ามีคุณภาพดีเพียงพอสำหรับงานทั่วไปส่วนใหญ่ที่ไม่ใช่เชิงรหัสลับ ส่วนระดับ 1 หรือ 2 ดาวอาจเพียงพอสำหรับแอปพลิเคชันหรือเกมทั่วไป แต่อาจให้ผลลัพธ์ที่ไม่น่าพึงพอใจกับอัลกอริทึมเชิงคำนวณบางประเภท
คาบ
คาบ (Period) หรือ ความยาววัฏจักร (Cycle length) ของ PRNG คือจำนวนค่าสูงสุดที่ตัวสร้างสามารถผลิตออกมาได้ ก่อนที่มันจะเริ่มวนกลับมาสร้างลำดับตัวเลขสุ่มซ้ำเดิม PRNG หลายตัวมีขนาดคาบที่คงที่แน่นอน ในขณะที่บางตัว (เช่น “RNG แบบเคออติก”) ความยาววัฏจักรอาจขึ้นอยู่กับค่าซีดและอาจมีรอบวัฏจักรที่สั้นลงได้ในบางกรณี
ข้อพึงระวัง: คาบที่ยาวไม่ได้เป็นสิ่งการันตีว่าคุณภาพความสุ่มจะสูงเสมอไป (เช่น วงจรตัวนับที่นับค่า u128 ไปเรื่อยๆ ก็มีคาบที่ยาวมาก แต่ไม่มีความสุ่มเลย) ในทางกลับกัน คาบที่สั้นเกินไปย่อมก่อให้เกิดปัญหาแน่นอน โดยเฉพาะเมื่อมีการเรียกใช้ RNG หลายตัวพร้อมกัน ในทางปฏิบัติเราแนะนำให้เลือกใช้ PRNG ที่มีคาบอย่างน้อย 2128 (หรืออาจใช้ PRNG ที่มีคาบสั้นลงมาอย่างน้อย 264 แต่รองรับการแบ่งหลายสตรีมได้อย่างอิสระ ทว่าสำหรับ PCG นั้น สตรีมย่อยต่างๆ ยังคงมีความสัมพันธ์เชิงสหสัมพันธ์ต่อกันอย่างใกล้ชิด)
หลีกเลี่ยงการใช้ค่าซ้ำ!
บนฮาร์ดแวร์ยุคปัจจุบัน ตัวสร้าง RNG ที่ทำงานเร็วและมีความยาววัฏจักรเพียง 264 สามารถถูกเปิดใช้งานต่อเนื่องได้นานนับศตวรรษก่อนที่ลำดับจะวนซ้ำ ทว่าเมื่อนำ RNG หลายตัวมาทำงานร่วมกันแบบขนาน (โดยแต่ละตัวได้รับค่าซีดที่ต่างกัน) จะมีความเสี่ยงสูงอย่างมีนัยสำคัญที่ลำดับตัวเลขที่แต่ละตัวสร้างขึ้นจะเกิดการทับซ้อนกัน
สำหรับตัวสร้างที่มีคาบขนาดใหญ่ P เมื่อมีตัวสร้างที่ทำงานอิสระต่อกัน n ตัว และแต่ละตัวสร้างลำดับความยาว L โอกาสที่จะเกิดการทับซ้อนกันระหว่างลำดับใดๆ สามารถประมาณได้ด้วยสูตร Ln² / P (เมื่อ nL / P มีค่าเข้าใกล้ศูนย์) สำหรับรายละเอียดเชิงลึกในเรื่องนี้ สามารถอ่านเพิ่มเติมได้จาก
ข้อสังเกตของทีมผู้พัฒนา Xoshiro
การชนกันและปฏิทรรศน์วันเกิด!
สำหรับตัวสร้างที่ขนาดเอาต์พุตเท่ากับขนาดสถานะ มีคำแนะนำว่าไม่ควรเรียกใช้เอาต์พุตเกิน √P ค่า โดยหลักการทั่วไปสำหรับตัวสร้างขนาด w บิตที่มีสถานะ kw บิต คือควรดูแลให้ kL² < P เสมอ ซึ่งข้อกำหนดนี้มีที่มาจาก
ปัญหาวันเกิดแบบทั่วไป (generalised birthday problem) ที่ศึกษาว่าเราสามารถสุ่มตัวอย่างที่ไม่ลำเอียงจากเซตขนาด d = 2^w ได้กี่ค่าก่อนที่ความน่าจะเป็นที่จะพบค่าซ้ำจะมีค่าอย่างน้อยครึ่งหนึ่ง โปรดทราบว่าเมื่อ kL² > P ตัวสร้างที่มีการกระจายตัวแบบสมดุลมิติ kw จะไม่สามารถสร้างจำนวนตัวอย่างซ้ำได้ตรงตามทฤษฎีความน่าจะเป็นที่คาดไว้ ทว่าตัวสร้างที่ขาดคุณสมบัติดังกล่าวก็ไม่มีสิ่งใดรับประกันว่าจะสร้างจำนวนครั้งที่ซ้ำได้ตรงตามที่ควรจะเป็นเช่นกัน
ความปลอดภัย
ความสามารถในการทำนาย
ในบริบทของการวิเคราะห์ PRNG ใดๆ เราสามารถตั้งคำถามสำคัญได้ว่า: หากผู้โจมตีล่วงรู้ค่าเอาต์พุตก่อนหน้าบางส่วนของ PRNG แล้ว จะสามารถทำนายค่าเอาต์พุตที่จะเกิดขึ้นในลำดับถัดไปได้หรือไม่? นี่คือคุณสมบัติชี้ขาดในทุกสถานการณ์ที่มีฝ่ายตรงข้ามคอยจับตาดูระบบอยู่
PRNG ทั่วไปมักจะสามารถทำนายผลลัพธ์ล่วงหน้าได้ แม้ว่าระดับความยากง่ายจะแตกต่างกันไป ในบางกรณีการทำนายทำได้ง่ายดายมาก ตัวอย่างเช่น Xorshift แบบพื้นฐานจะส่งออกส่วนหนึ่งของสถานะภายในออกมาตรงๆ การทำนายผลลัพธ์จึงทำได้ง่ายเพียงแค่ใช้ค่าเอาต์พุต u32 สี่ค่ามาคำนวณย้อนตั้งเป็นค่าซีดใหม่ของตัวสร้างได้ทันที ส่วนตัวสร้างอื่นๆ เช่น
PCG และ Xorshift* แบบตัดทอน
จะทำนายได้ยากกว่า แต่ก็ไม่ได้เกินขีดความสามารถของการคำนวณทางคณิตศาสตร์ทั่วไปบนเครื่องคอมพิวเตอร์ตั้งโต๊ะ
เกณฑ์ความปลอดภัยขั้นพื้นฐานที่สุดที่ CSPRNG ต้องมี คือการไม่สามารถทำนายค่าเอาต์พุตได้อย่างเด็ดขาด ซึ่งข้อกำหนดนี้ได้รับการนิยามอย่างเป็นทางการในชื่อ next-bit test โดยมีใจความสำคัญว่า: เมื่อกำหนดให้ทราบข้อมูล k บิตแรกของลำดับสุ่ม ลำดับนั้นจะผ่านเกณฑ์ next-bit test ก็ต่อเมื่อไม่มีอัลกอริทึมใดๆ ที่สามารถทำนายบิตถัดไปได้อย่างถูกต้องด้วยการใช้ทรัพยากรการคำนวณที่สมเหตุสมผล
คุณสมบัติด้านความปลอดภัยอีกประการหนึ่งที่ CSPRNG บางตัว มอบให้ คือการรักษาความลับไปข้างหน้า (forward secrecy): หมายความว่าหากสถานะภายในของ CSPRNG เกิดรั่วไหลออกไป ณ ขณะใดขณะหนึ่ง ผู้โจมตีจะต้องไม่สามารถคำนวณย้อนกลับเพื่อกู้คืนสถานะหรือค่าเอาต์พุตในอดีตได้ ข้อควรระวังคือ CSPRNG จำนวนมาก ไม่ได้ มีคุณสมบัติการรักษาความลับไปข้างหน้านี้ในการกำหนดค่าตามปกติ
การตรวจสอบและยืนยันข้ออ้างด้านความปลอดภัยของขั้นตอนวิธีทางคณิตศาสตร์ถือเป็นเรื่องที่ ยากและซับซ้อนอย่างยิ่ง ซึ่งเราไม่สามารถรับประกันความปลอดภัยของอัลกอริทึมที่โปรเจกต์นี้นำมาใช้หรือแนะนำได้อย่างสมบูรณ์แบบ เราจึงขอแนะนำให้อ้างอิงมาตรฐานจากสถาบัน NIST และเครือข่ายวิจัย ECRYPT สำหรับคำแนะนำที่เป็นทางการ
สถานะและการซีด
จุดสำคัญที่ต้องเน้นย้ำคือ ความปลอดภัยของ CSPRNG ขึ้นอยู่กับการได้รับค่าซีดจากคีย์สุ่มที่มั่นคงปลอดภัยอย่างแท้จริง หากคีย์ตั้งต้นนั้นเป็นที่ล่วงรู้หรือสามารถคาดเดาได้ เอาต์พุตทั้งหมดของ CSPRNG ก็จะถูกถอดรหัสได้โดยง่าย ซึ่งหมายความว่าค่าซีดจะต้องมาจากแหล่งกำเนิดที่เชื่อถือได้เสมอ โดยทั่วไปคือระบบปฏิบัติการ (OS) หรือจาก CSPRNG ตัวอื่นที่มีความน่าเชื่อถือสูง เพื่อตอบโจทย์นี้ เราแนะนำให้ใช้เครต getrandom ซึ่งเชื่อมต่อกับอินเทอร์เฟซตัวสร้างเลขสุ่มที่ปลอดภัยของ OS โดยตรง หรืออีกทางหนึ่ง คุณสามารถใช้ฟังก์ชันระดับ user-space อย่าง rand::make_rng() หรือ ThreadRng เพื่อป้อนค่าซีดก็ได้ ตัวอย่างเช่น:
#![allow(unused)]
fn main() {
use rand::{rngs::ChaCha12Rng, rngs::SysRng, SeedableRng};
/// Seed explicitly from SysRng:
let mut rng1 = ChaCha12Rng::try_from_rng(&mut SysRng).unwrap();
/// Seed from ThreadRng (or SysRng if ThreadRng is not available):
let mut rng2: ChaCha12Rng = rand::make_rng();
}
นอกจากนี้ สถานะภายในของ CSPRNG จะต้องถูกเก็บรักษาไว้เป็นความลับอย่างเคร่งครัด ด้วยเหตุนี้ การอิมพลีเมนต์ของเราจึงไม่อนุญาตให้เข้าถึงสถานะภายในส่วนใหญ่โดยตรง และการอิมพลีเมนต์เทรต Debug ก็จะไม่มีการพิมพ์ค่าสถานะภายในออกมาให้เห็น อย่างไรก็ดี สิ่งนี้ไม่ได้เป็นการปกป้องสถานะของ CSPRNG ได้อย่างสมบูรณ์แบบ 100% เพราะโค้ดอื่นๆ ที่ทำงานอยู่ภายในโปรเซสเดียวกันยังคงสามารถเข้าถึงหน่วยความจำส่วนนี้ได้ (และเรายังเปิดให้สามารถโคลนหรือซีเรียลไลซ์ CSPRNG ได้เพื่อความสะดวกในการพัฒนา) ยิ่งไปกว่านั้น โปรเซสที่กำลังทำงานอยู่อาจถูกระบบปฏิบัติการทำกระบวนการ fork ซึ่งอาจส่งผลให้ทั้งสองโปรเซสถือครองสำเนาของตัวสร้างที่มีสถานะเหมือนกันทุกประการ
ไม่ใช่ไลบรารีสำหรับการเข้ารหัสข้อมูล
กระบวนการทางวิทยาการรหัสลับ เช่น การเข้ารหัสข้อมูล (encryption) และการรับรองความถูกต้อง (authentication) มีความซับซ้อนสูงมาก และต้องอาศัยการอิมพลีเมนต์ที่ประณีตระมัดระวังอย่างยิ่งเพื่อหลีกเลี่ยงข้อบกพร่องและป้องกันการโจมตีในรูปแบบต่างๆ ดังนั้นสำหรับงานด้านความปลอดภัยโดยตรง จึงแนะนำให้เลือกใช้ไลบรารีเฉพาะทาง เช่น openssl, ring และกลุ่มไลบรารี RustCrypto libraries
เครตของ Rand มุ่งมั่นจัดเตรียมแหล่งข้อมูลสุ่มที่ไม่อาจคาดเดาได้ แต่ก็มีข้อจำกัดที่ควรทราบ: ประการแรก ซอฟต์แวร์นี้เผยแพร่ให้ใช้งาน “ตามสภาพ (as is)” โดยไม่มีการรับประกันใดๆ ประการที่สอง ระบบตั้งสมมติฐานว่าหน่วยความจำของโปรแกรมเป็นพื้นที่ส่วนตัว หากคุณมีความกังวลในจุดนี้ อาจพิจารณาเลือกใช้ตัวสร้างระดับระบบภายนอกอย่าง getrandom แทน นอกจากนี้ แม้กระทั่งความเป็นส่วนตัวของหน่วยความจำหลังจากคืนพื้นที่แล้วก็มีความสำคัญ ซึ่งแม้ว่าเราอาจผนวกมาตรการป้องกันเพิ่มเติมอย่างเครต zeroize เข้ามาในอนาคต แต่วิธีดังกล่าวก็ยังไม่อาจครอบคลุมได้ทั้งหมด และโปรดทราบว่า Rand ไม่ได้มีกลไกป้องกันปัญหาการฟอร์กโปรเซสโดยสมบูรณ์ (เวอร์ชันก่อนหน้าจนถึง 0.8.x เคยมีมาตรการบรรเทาปัญหาเบื้องต้น แต่ก็ไม่สามารถป้องกันได้ทั้งหมด) สุดท้ายนี้ มีปัจจัยอีกมากมายที่อาจทำลายคุณสมบัติความปลอดภัยได้ ตั้งแต่ช่องโหว่ระดับฮาร์ดแวร์ที่ซับซ้อนอย่าง Spectre ไปจนถึงข้อผิดพลาดที่ดูไม่น่าจะเกิดขึ้น (เช่น การเผลอพิมพ์สถานะภายในของตัวสร้างลงในไฟล์ล็อกของระบบ)
ฟีเจอร์เพิ่มเติม
PRNG บางตัวอาจมีความสามารถพิเศษเพิ่มเติม เช่น:
- รองรับหลายสตรีม (stream) ซึ่งช่วยเพิ่มประสิทธิภาพในงานประมวลผลแบบขนาน
- ความสามารถในการก้าวกระโดดลำดับ (jump) หรือเลื่อนตำแหน่งในสตรีมของตัวเลขสุ่ม ซึ่งหากตัวสร้างมีขนาดคาบที่ใหญ่มาก กลไกนี้สามารถนำมาใช้แทนการแบ่งสตรีมได้
อ่านเพิ่มเติม
ยังมีเนื้อหาและรายละเอียดเชิงลึกเกี่ยวกับ PRNG อีกมากมาย โดยบทความ PCG paper เป็นเอกสารที่อ่านเข้าใจง่ายและอธิบายแนวคิดเพิ่มเติมไว้อย่างน่าสนใจ
นอกจากนี้ บทความคุณภาพอีกชิ้นหนึ่งที่กล่าวถึงคุณภาพของตัวสร้างเลขสุ่มคือ “Good random number generators are (not so) easy to find” เขียนโดย P. Hellekalek
การซีด RNG
ดังที่เราได้เห็นกันไปแล้ว เอาต์พุตของตัวสร้างเลขสุ่มเทียม (PRNG) จะถูกกำหนดขึ้นจากสถานะเริ่มต้นของมันเสมอ
ข้อกำหนดของขั้นตอนวิธี PRNG แต่ละตัวจะระบุวิธีสร้างสถานะเริ่มต้นจากคีย์ที่ป้อนเข้ามา โดยทั่วไปหากเป็นตัวสร้างเชิงรหัสลับ คีย์จะถูกกำหนดเป็นลำดับของไบต์ (byte sequence) หรือหากเป็น PRNG ขนาดเล็กก็มักจะใช้เพียงหนึ่งเวิร์ด (word) ซึ่งเราได้กำหนดรูปแบบมาตรฐานนี้ให้กับตัวสร้างทุกตัวผ่านเทรต SeedableRng
หมายเหตุ: การซีดไม่ได้หมายความว่าผลลัพธ์จะทำซ้ำได้ สำหรับสิ่งนั้นคุณต้องใช้ RNG ที่มีชื่อระบุและอัลกอริทึมคงที่ (เช่น ChaCha12Rng ไม่ใช่ StdRng) ดูเพิ่มเติมที่ ความสามารถในการทำซ้ำ
ชนิดข้อมูล Seed
เรากำหนดให้ RNG ที่สามารถซีดได้ทุกตัว ต้องระบุชนิดข้อมูล Seed ที่สอดคล้องกับข้อกำหนดเทรตบาวด์
AsMut<[u8]> + Default + Sized (โดยทั่วไปมักเป็น [u8; N] ที่มีขนาด N คงที่) เราแนะนำให้ใช้ [u8; 12] หรือใหญ่กว่าสำหรับ PRNG ที่ไม่ใช่เชิงรหัสลับ และ [u8; 32] สำหรับ PRNG เชิงรหัสลับ
คุณสามารถกำหนดค่าซีดให้กับ PRNG ได้โดยตรงจากค่าดังกล่าวผ่านเมธอด SeedableRng::from_seed
การซีดจาก…
เอนโทรปีใหม่
การใช้ซีดใหม่ทำได้ง่ายด้วย rand::make_rng():
use rand::prelude::*;
use rand::rngs::ChaCha20Rng;
fn main() {
let mut rng: ChaCha20Rng = rand::make_rng();
println!("{}", rng.random_range(0..100));
}
โปรดทราบว่าวิธีนี้จำเป็นต้องเปิดใช้งานฟีเจอร์ getrandom ในเครต rand_core ด้วย
RNG อีกตัว
แน่นอนว่าเราสามารถนำเอาต์พุตจาก RNG อีกตัวมาใช้เป็นค่าซีดได้ โดยเครตมีเมธอดอำนวยความสะดวกเตรียมไว้ให้ดังนี้:
use rand::prelude::*;
fn main() {
let mut rng = SmallRng::from_rng(&mut rand::rng());
println!("{}", rng.random_range(0..100));
}
แต่หากคุณต้องการบันทึกค่าคีย์หรือซีดนั้นเก็บไว้เพื่อนำมาใช้ซ้ำในภายหลัง คุณจะต้องเขียนโค้ดระบุรายละเอียดให้ชัดเจนขึ้นอีกเล็กน้อย:
use rand::prelude::*;
use rand::rngs::ChaCha8Rng;
fn main() {
let mut seed: <ChaCha8Rng as SeedableRng>::Seed = Default::default();
rand::rng().fill(&mut seed);
let mut rng = ChaCha8Rng::from_seed(seed);
println!("{}", rng.random_range(0..100));
}
คำเตือนสำคัญ: PRNG แบบเรียบง่ายบางตัว โดยเฉพาะ XorShiftRng จะทำงานแย่เมื่อถูกซีดจากตัวสร้างชนิดเดียวกัน (ในกรณีนี้ Xorshift สร้างสำเนาของตัวเอง) สำหรับ PRNG เชิงรหัสลับนี่ไม่ใช่ปัญหา สำหรับตัวอื่นๆ ขอแนะนำให้ซีดจากตัวสร้างต่างชนิดกัน โดย ChaCha8Rng ถือเป็นตัวเลือกที่ยอดเยี่ยมอย่างยิ่งในการนำมาทำเป็นตัวสร้างหลักแบบดีเทอร์มินิสติก (master generator) (แต่หากเป็นการใช้งานเชิงรหัสลับ ขอแนะนำให้เลือกใช้รุ่น 12 รอบขึ้นไป)
ตัวเลขง่ายๆ
สำหรับบางแอปพลิเคชัน โดยเฉพาะงานจำลองทางวิทยาศาสตร์ สิ่งที่คุณต้องการอาจเป็นเพียงลำดับของค่าซีดตัวเลขคงที่ที่ไม่ซ้ำกัน เช่น 1, 2, 3 เป็นต้น
เมธอด SeedableRng::seed_from_u64 ได้รับการออกแบบมาเพื่อตอบโจทย์นี้โดยเฉพาะ การทำงานภายในจะใช้ PRNG แบบง่ายในการกระจายบิตของตัวเลขอินพุตไปยังบิตต่างๆ ของซีด พร้อมทั้งมีคุณสมบัติ bit-avalanche ที่ดี (ส่งผลให้ตัวเลขที่ใกล้เคียงกัน เช่น 0 กับ 1 ถูกแปลงเป็นค่าซีดที่แตกต่างกันอย่างสิ้นเชิง และสร้างลำดับ RNG ที่เป็นอิสระต่อกัน)
use rand::prelude::*;
use rand::rngs::ChaCha8Rng;
fn main() {
let mut rng = ChaCha8Rng::seed_from_u64(2);
println!("{}", rng.random_range(0..100));
}
โปรดทราบว่าตัวเลขที่มีขนาดไม่เกิน 64 บิต ไม่สามารถมอบความปลอดภัยได้ จึงไม่ควรนำไปใช้กับงานด้านวิทยาการรหัสลับหรือเกมการพนันเป็นอันขาด
สตริง หรือข้อมูลที่แฮชได้ทั่วไป
สมมติว่าคุณต้องการเปิดให้ผู้ใช้งานป้อนข้อความสตริงเข้ามาเป็นค่าซีดของตัวสร้างเลขสุ่ม ในอุดมคติแล้ว ทุกส่วนของข้อความสตริงควรส่งอิทธิพลต่อผลลัพธ์ของตัวสร้าง และการเปลี่ยนแปลงข้อความเพียงเล็กน้อยก็ควรให้ลำดับตัวเลขสุ่มที่เป็นอิสระต่อกันโดยสิ้นเชิง
เราสามารถบรรลุสิ่งนี้ได้โดยการใช้ฟังก์ชันแฮช เพื่อบีบอัดข้อมูลอินพุตทั้งหมดให้กลายเป็นค่าแฮช จากนั้นจึงนำผลลัพธ์แฮชดังกล่าวไปใช้เป็นซีดของตัวสร้าง โดยเครต rand_seeder ได้รับการออกแบบมาเพื่อการนี้โดยเฉพาะ
use rand::prelude::*;
use rand::rngs::Xoshiro256PlusPlus;
use rand_seeder::{Seeder, SipHasher};
fn main() {
// In one line:
let mut rng: Xoshiro256PlusPlus = Seeder::from("stripy zebra").into_rng();
println!("{}", rng.random::<char>());
// If we want to be more explicit, first we create a SipRng:
let hasher = SipHasher::from("a sailboat");
let mut hasher_rng = hasher.into_rng();
// (Note: hasher_rng is a full RNG and can be used directly.)
// Now, we use hasher_rng to create a seed:
let mut seed: <Xoshiro256PlusPlus as SeedableRng>::Seed = Default::default();
hasher_rng.fill(&mut seed);
// And create our RNG from that seed:
let mut rng = Xoshiro256PlusPlus::from_seed(seed);
println!("{}", rng.random::<char>());
}
ข้อควรระวัง: เครต rand_seeder ไม่เหมาะสำหรับการใช้งานเชิงรหัสลับ และมัน ไม่ใช่เครื่องมือสำหรับแฮชรหัสผ่าน (password hasher) สำหรับงานด้านการจัดการรหัสผ่าน จำเป็นต้องใช้ฟังก์ชันสร้างคีย์เฉพาะทาง (key-derivation function) เช่น Argon2 เท่านั้น
RNG แบบขนาน
ทฤษฎี: RNG หลายตัว
หากคุณต้องการใช้ตัวสร้างแบบสุ่มในเธรดทำงานหลายตัวพร้อมกัน คุณจะต้องใช้ RNG หลายตัว วิธีที่แนะนำมีดังนี้:
- ใช้
rng()ในแต่ละเธรดทำงาน ตัวสร้างนี้จะถูกซีดโดยอัตโนมัติ (แบบประเมินเมื่อต้องการ/lazy และได้ค่าซีดที่ไม่ซ้ำกัน) ในแต่ละเธรดที่ใช้งาน - ใช้
rng()(หรือ RNG หลักตัวอื่น) เพื่อซีด RNG ที่กำหนดเองในแต่ละ เธรดทำงาน ข้อดีหลักคือความยืดหยุ่นในการเลือก RNG ที่ใช้ - ใช้ RNG ที่กำหนดเองต่อ ชิ้นงานย่อย (work unit) ไม่ใช่ต่อ เธรดทำงาน (worker thread) หาก RNG เหล่านี้ ถูกซีดอย่างดีเทอร์มินิสติก ก็จะได้ผลลัพธ์ที่กำหนดได้เช่นกัน น่าเสียดายที่ การซีด RNG ใหม่สำหรับแต่ละชิ้นงานย่อยจากตัวสร้างหลักไม่สามารถทำแบบขนานได้ จึงอาจช้า
- ใช้ซีดหลักเพียงค่าเดียว สำหรับแต่ละชิ้นงานย่อย ให้ซีด RNG ด้วยซีดหลัก แล้วตั้งสตรีมของ RNG เป็นหมายเลขชิ้นงานย่อย วิธีนี้อาจเร็วกว่า (3) และยังคงกำหนดผลลัพธ์ได้ แต่ไม่ใช่ RNG ทุกตัวรองรับ
หมายเหตุ: อย่าแค่โคลน RNG ให้เธรดทำงานหรือชิ้นงานย่อย สำเนาจะให้ลำดับเอาต์พุตเดิมเหมือนต้นฉบับ อย่างไรก็ตาม คุณใช้สำเนาได้หากตั้งสตรีมที่ไม่ซ้ำกันให้แต่ละตัว
สายธาร
ตระกูล RNG ใดรองรับหลายสตรีม?
- ChaCha: RNG ตระกูล ChaCha รองรับซีด 256 บิต สตรีม 64 บิต และตัวนับ 64 บิต (ต่อบล็อก 16 คำ) จึงรองรับ 264 สตรีม สตรีมละ 268 คำ
- Hc128 เป็น RNG เชิงรหัสลับที่ รองรับซีด 256 บิต; เราอาจสร้างซีดนี้จาก (เช่น) คีย์ 192 บิตที่เล็กกว่า บวกกับสตรีม 64 บิตได้
โปรดทราบว่าวิธีสร้างซีดจากคีย์ที่เล็กกว่าบวกกับตัวนับสตรีมข้างต้น แนะนำได้เฉพาะกับ PRNG เชิงรหัสลับเท่านั้น เนื่องจาก RNG แบบง่ายมักมีสหสัมพันธ์ในเอาต์พุตเมื่อใช้คีย์สองค่าที่คล้ายกัน และอาจต้องใช้ซีดที่ “ดูสุ่ม” เพื่อให้ได้เอาต์พุตคุณภาพสูง
PRNG ที่ไม่ใช่เชิงรหัสลับอาจยังรองรับหลายสตรีมได้ แต่น่าจะมีข้อจำกัดที่สำคัญ (โดยเฉพาะอย่างยิ่ง เมื่อคำแนะนำทั่วไปของ PRNG เหล่านี้คือไม่ควรใช้เกินรากที่สองของคาบของตัวสร้าง)
-
Xoshiro: RNG ตระกูล Xoshiro รองรับเมธอด
jumpและlong_jumpซึ่งใช้แบ่งเอาต์พุตของ RNG เดียว ออกเป็นหลายสตรีมได้อย่างมีประสิทธิผล ในทางปฏิบัติสิ่งนี้มีประโยชน์เฉพาะ เมื่อมีสตรีมจำนวนน้อย เพราะต้องเรียกjumpจำนวนnครั้งเพื่อเลือกสตรีมที่ n -
Pcg: RNG เหล่านี้รองรับ การสร้างด้วยพารามิเตอร์
stateและstreamอย่างไรก็ตาม โปรดทราบว่า RNG เหล่านี้ถูกวิจารณ์ว่าหลายสตรีมที่ใช้คีย์เดียวกันมักมีสหสัมพันธ์กันอย่างมาก ดูความเห็นของผู้เขียน PCG เองRNG ตระกูล PCG ยังรองรับเมธอด
fn advance(delta)ซึ่งอาจใช้แบ่ง สตรีมเดียวออกเป็นหลายสตรีมย่อยได้เช่นเดียวกับjumpของ Xoshiro (แต่ดีกว่าเพราะระบุออฟเซตได้)
ภาคปฏิบัติ: แบบหลายเธรดที่ไม่กำหนดได้
เราใช้อิเทอเรเตอร์แบบขนาน (parallel iterators) ของ Rayon โดยใช้ map_init เพื่อเริ่มต้น RNG ในแต่ละเธรดทำงาน หมายเหตุ: RNG นี้อาจถูกใช้ซ้ำข้ามหลายชิ้นงานย่อย ซึ่งอาจถูกแบ่งระหว่างเธรดทำงานแบบไม่กำหนดได้
use rand::distr::{Distribution, Uniform};
use rayon::prelude::*;
static SAMPLES: u64 = 1_000_000;
fn main() {
let range = Uniform::new(-1.0f64, 1.0).unwrap();
let in_circle = (0..SAMPLES)
.into_par_iter()
.map_init(|| rand::rng(), |rng, _| {
let a = range.sample(rng);
let b = range.sample(rng);
if a * a + b * b <= 1.0 {
1
} else {
0
}
})
.reduce(|| 0usize, |a, b| a + b);
// prints something close to 3.14159...
println!(
"π is approximately {}",
4. * (in_circle as f64) / (SAMPLES as f64)
);
}
ภาคปฏิบัติ: แบบหลายเธรดที่กำหนดได้
เราใช้วิธี (4) ข้างต้นเพื่อให้ได้ผลลัพธ์ที่กำหนดได้: เริ่มต้น RNG ทั้งหมดจากซีดเดียว แต่ใช้หลายสตรีม
เราใช้ ChaCha8Rng::set_stream เพื่อทำเช่นนี้
โปรดทราบเพิ่มเติมว่าเราจัดกลุ่มชิ้นงานย่อยหลายหน่วยด้วยกันตาม BATCH_SIZE ด้วยมือ สิ่งนี้สำคัญเพราะค่าใช้จ่ายในการเริ่มต้น RNG สูงเมื่อเทียบกับค่าใช้จ่ายของชิ้นงานย่อยเรา (สร้างค่าสุ่มสองค่าบวกการคำนวณเล็กน้อย) การจัดกลุ่มด้วยมืออาจช่วยเพิ่มประสิทธิภาพของการจำลองแบบไม่กำหนดได้ข้างต้นด้วย
(หมายเหตุ: ตัวอย่างนี้อยู่ที่ https://github.com/rust-random/rand/blob/master/examples/rayon-monte-carlo.rs)
use rand::distr::{Distribution, Uniform};
use rand::{SeedableRng, rngs::ChaCha8Rng};
use rayon::prelude::*;
static SEED: u64 = 0;
static BATCH_SIZE: u64 = 10_000;
static BATCHES: u64 = 1000;
fn main() {
let range = Uniform::new(-1.0f64, 1.0).unwrap();
let in_circle = (0..BATCHES)
.into_par_iter()
.map(|i| {
let mut rng = ChaCha8Rng::seed_from_u64(SEED);
rng.set_stream(i);
let mut count = 0;
for _ in 0..BATCH_SIZE {
let a = range.sample(&mut rng);
let b = range.sample(&mut rng);
if a * a + b * b <= 1.0 {
count += 1;
}
}
count
})
.reduce(|| 0usize, |a, b| a + b);
// prints 3.1409052 (deterministic and reproducible result)
println!(
"π is approximately {}",
4. * (in_circle as f64) / ((BATCH_SIZE * BATCHES) as f64)
);
}
ค่าสุ่ม
เมื่อเรามีเครื่องมือในการผลิตข้อมูลสุ่มดิบแล้ว คำถามถัดมาคือ เราจะแปลงข้อมูลเหล่านั้นให้กลายเป็นค่าของชนิดข้อมูลที่เราต้องการใช้งานได้อย่างไร?
นี่เป็นคำถามที่มีคำตอบสองชั้น: เพราะเราจำเป็นต้องทราบทั้ง ขอบเขตช่วงค่า (range) ที่ต้องการ และชนิดของ การแจกแจง (distribution) ของค่านั้นๆ (ซึ่งจะเป็นประเด็นหลักในบทถัดไป)
เทรต Rng
เพื่อความสะดวกในการพัฒนา ตัวสร้างเลขสุ่มทุกตัวจะอิมพลีเมนต์เทรต Rng ให้โดยอัตโนมัติ ซึ่งทำหน้าที่เป็นทางลัดสำหรับสร้างค่าสุ่มในรูปแบบต่างๆ มากมาย โดยมีฟังก์ชันอำนวยความสะดวกสำหรับการสร้างค่าที่มีการแจกแจงแบบสม่ำเสมอ (Uniform) ดังนี้:
-
Rng::randomสุ่มสร้างค่าที่ไม่ลำเอียง (แบบสม่ำเสมอ) จากช่วงค่าที่เหมาะสมตามแต่ละชนิดข้อมูล สำหรับจำนวนเต็มโดยทั่วไปจะครอบคลุมช่วงค่าทั้งหมดที่ชนิดข้อมูลนั้นแทนค่าได้ (เช่น จาก0u32ถึงstd::u32::MAX) สำหรับเลขทศนิยมจะอยู่ระหว่าง 0 ถึง 1 และยังรองรับชนิดข้อมูลอื่นๆ เช่น อาร์เรย์ และ ทูเพิลเมธอดนี้เป็น wrapper อำนวยความสะดวกที่ห่อหุ้มการแจกแจง
StandardUniformเอาไว้ ตามที่อธิบายไว้ในส่วนถัดไป -
Rng::random_rangeสุ่มสร้างค่าที่ไม่ลำเอียงภายในช่วงค่าที่ระบุ -
Rng::fillและRng::try_fillฟังก์ชันที่ได้รับการปรับแต่งประสิทธิภาพมาเป็นพิเศษสำหรับเติมค่าสุ่มลงในสไลซ์ของไบต์หรือสไลซ์ของจำนวนเต็มใดๆ
นอกจากนี้ยังมีฟังก์ชันอำนวยความสะดวกสำหรับการสร้างค่าบูลีนแบบไม่สม่ำเสมอ:
Rng::random_boolสุ่มค่าบูลีนตามความน่าจะเป็นที่กำหนดRng::random_ratioสุ่มค่าบูลีนเช่นกัน โดยกำหนดความน่าจะเป็นในรูปของเศษส่วน
และสุดท้าย มีฟังก์ชันสำหรับสุ่มค่าจากการแจกแจงใดๆ ก็ได้:
Rng::sampleสุ่มค่าโดยตรงจากการแจกแจง (distribution) ที่กำหนด
ตัวอย่าง:
use rand::RngExt;
fn main() {
let mut rng = rand::rng();
// an unbiased integer over the entire range:
let i: i32 = rng.random();
println!("i = {i}");
// a uniformly distributed value between 0 and 1:
let x: f64 = rng.random();
println!("x = {x}");
// simulate rolling a die:
println!("roll = {}", rng.random_range(1..=6));
}
นอกจากนี้ ฟังก์ชัน random ยังเป็นทางลัดไปยัง Rng::random บน rng():
use rand::Rng;
fn main() {
println!("Tossing a coin...");
if rand::random() {
println!("We got lucky!");
}
}
ชนิดข้อมูลสุ่มที่กำหนดเอง
จากตัวอย่างข้างต้น จะสังเกตเห็นว่าการเรียก rng.random() จะให้การแจกแจงของค่าที่แตกต่างกันไปตามชนิดข้อมูล:
- ค่า
i32จะถูกสุ่มขึ้นจากช่วงi32::MIN ..= i32::MAXแบบสม่ำเสมอ - ค่า
f32จะถูกสุ่มขึ้นจากช่วง0.0 .. 1.0แบบสม่ำเสมอ
นี่คือพฤติกรรมของการแจกแจง StandardUniform ซึ่งแม้ว่าเรื่องของ Distribution จะเป็นหัวข้อหลักในบทถัดไป แต่ด้วยความสำคัญของการแจกแจงแบบ StandardUniform เราจึงขอกล่าวถึงไว้ล่วงหน้า ณ ที่นี้ โดยตามธรรมเนียมทั่วไปแล้ว นิยามคำว่ามาตรฐานอาจดูเหมือนเป็นการกำหนดขึ้นเอง (somewhat arbitrary) แต่แท้จริงแล้วถูกคัดเลือกมาอย่างมีหลักการและมีเหตุผลรองรับเป็นอย่างดี:
- ค่าจะถูกสุ่มแบบสม่ำเสมอ: เมื่อพิจารณาช่วงย่อยสองช่วงใดๆ ที่มีขนาดเท่ากัน แต่ละช่วงย่อมมีโอกาสเท่ากันที่จะเป็นที่อยู่ของค่าสุ่มถัดไป
- โดยทั่วไปจะใช้ช่วงค่าทั้งหมดที่ชนิดข้อมูลเป้าหมายสามารถรองรับได้
- สำหรับ
f32และf64จะใช้ช่วง0.0 .. 1.0(ไม่นับรวม1.0) ด้วยเหตุผลสองประการ: (ก) เป็นแนวทางปฏิบัติมาตรฐานสากลของตัวสร้างเลขสุ่ม และ (ข) ในหลายแอปพลิเคชัน การรักษาการแจกแจงตัวอย่างให้สม่ำเสมอบนเส้นจำนวนจริง (Real number line) ถือเป็นเรื่องสำคัญยิ่ง ซึ่งสำหรับระบบเลขทศนิยมแล้ว สิ่งนี้จะเป็นไปได้ก็ต่อเมื่อจำกัดช่วงค่าไว้เท่านั้น
จากหลักการดังกล่าว เราสามารถอิมพลีเมนต์การแจกแจง StandardUniform ให้กับชนิดข้อมูลที่เราสร้างขึ้นเองได้เช่นกัน:
use rand::{Rng, RngExt};
use rand::distr::{Distribution, StandardUniform, Uniform};
use std::f64::consts::TAU; // = 2π
/// Represents an angle, in radians
#[derive(Debug)]
pub struct Angle(f64);
impl Angle {
pub fn from_degrees(degrees: f64) -> Self {
Angle(degrees * (std::f64::consts::TAU / 360.0))
}
}
impl Distribution<Angle> for StandardUniform {
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Angle {
// It would be correct to write:
// Angle(rng.random::<f64>() * TAU)
// However, the following is preferred:
Angle(Uniform::new(0.0, TAU).unwrap().sample(rng))
}
}
fn main() {
let angle: Angle = rand::rng().random();
println!("Random angle: {angle:?}");
}
การแจกแจงแบบสุ่ม
เพื่อมอบความยืดหยุ่นสูงสุดในการสุ่มสร้างค่า เราจึงได้นิยามเทรต Distribution ขึ้นมาดังนี้:
use rand::Rng;
// a producer of data of type T:
pub trait Distribution<T> {
// the key function:
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> T;
// a convenience function defined using sample:
fn sample_iter<R>(self, rng: R) -> rand::distr::Iter<Self, R, T>
where
Self: Sized,
R: Rng,
{
// [has a default implementation]
todo!()
}
}
การอิมพลีเมนต์เทรต Distribution ในทางคณิตศาสตร์ก็คือ การแจกแจงความน่าจะเป็น (Probability distribution): นั่นคือการจับคู่เชื่อมโยงระหว่างเหตุการณ์กับค่าความน่าจะเป็นที่จะเกิดขึ้น (เช่น สำหรับการทอยลูกเต๋า P(x = i) = ⅙ หรือสำหรับการแจกแจงแบบ Normal ที่มีค่าเฉลี่ย μ=0, P(x > 0) = ½)
ข้อควรทราบคือ แม้ว่าการแจกแจงความน่าจะเป็นในทางสถิติจะมีคุณสมบัติทางคณิตศาสตร์มากมาย เช่น ค่าเฉลี่ย (mean), ฟังก์ชันความหนาแน่นความน่าจะเป็น (PDF) ตลอดจนการสุ่มตัวอย่างผ่านการหาค่าผกผันของฟังก์ชันการแจกแจงสะสม (CDF) แต่สำหรับขอบเขตของ Rand เรามุ่งเน้นเฉพาะ การสุ่มดึงค่าตัวอย่าง (sampling) เท่านั้น หากคุณต้องการใช้งานคุณสมบัติทางคณิตศาสตร์และการวิเคราะห์สถิติเชิงลึกเหล่านั้น ขอแนะนำให้พิจารณาเลือกใช้เครต statrs แทน
ไลบรารี Rand มีการอิมพลีเมนต์การแจกแจงรูปแบบต่างๆ ไว้มากมาย โดยในบทนี้เราจะครอบคลุมการแจกแจงที่เป็นที่นิยมที่สุด แต่หากต้องการดูรายการการแจกแจงทั้งหมด สามารถศึกษาเพิ่มเติมได้จากโมดูล distr และเครต rand_distr
การแจกแจงแบบสม่ำเสมอ
การแจกแจงรูปแบบที่ตรงไปตรงมาที่สุดคือแบบที่เราได้กล่าวถึงไปแล้ว: นั่นคือรูปแบบที่ทุกช่วงย่อยขนาดเท่ากันจะมีโอกาสเท่ากันที่จะเป็นค่าสุ่มถัดไป ซึ่งเรียกว่าการแจกแจงแบบ สม่ำเสมอ (Uniform)
ในความเป็นจริง Rand ได้จัดเตรียมการแจกแจงแบบสม่ำเสมอไว้หลายรูปแบบ เพื่อรองรับช่วงค่าที่แตกต่างกัน:
StandardUniformไม่ต้องใช้พารามิเตอร์ และสุ่มค่าแบบสม่ำเสมอตาม ชนิดข้อมูล โดยRng::randomให้ทางลัดไปยังการแจกแจงนี้Uniformถูกกำหนดพารามิเตอร์ด้วยUniform::new(low, high)(รวมlowไม่รวมhigh) หรือUniform::new_inclusive(low, high)(รวมทั้งสองค่า) และสุ่มค่าแบบสม่ำเสมอภายในช่วงนี้Rng::random_rangeเป็นเมธอดอำนวยความสะดวกที่นิยามบนUniform::sample_singleซึ่งปรับแต่งสำหรับการใช้งานแบบสุ่มครั้งเดียวAlphanumericสุ่มแบบสม่ำเสมอเฉพาะค่าcharในกลุ่ม0-9A-Za-zOpen01และOpenClosed01ให้ช่วงการสุ่มทางเลือกสำหรับ ชนิดข้อมูลทศนิยม (ดูด้านล่าง)
การสุ่มแบบสม่ำเสมอตามชนิดข้อมูล
มาดูการแจกแจงตามชนิดข้อมูลกัน:
-
สำหรับ
boolStandardUniformสุ่มแต่ละค่าด้วยความน่าจะเป็น 50% -
สำหรับ
Option<T>การแจกแจงStandardUniformสุ่มNoneด้วย ความน่าจะเป็น 50% มิฉะนั้นจะสุ่มSome(value)ตามชนิดข้อมูลของมัน -
สำหรับจำนวนเต็ม (
u8จนถึงu128,usizeและชนิดi*ต่างๆ)StandardUniformสุ่มจากค่าที่เป็นไปได้ทั้งหมด ขณะที่Uniformสุ่มจากช่วงที่กำหนดพารามิเตอร์ -
สำหรับ
NonZeroU8และชนิด “ไม่เป็นศูนย์” อื่นๆStandardUniformสุ่มแบบสม่ำเสมอ จากค่าที่ไม่เป็นศูนย์ทั้งหมด (วิธีปฏิเสธ) -
ชนิดจำนวนเต็ม
Wrapping<T>ถูกสุ่มเหมือนชนิดจำนวนเต็มที่สอดคล้องกัน โดยการแจกแจงStandardUniform -
สำหรับทศนิยม (
f32,f64)StandardUniformสุ่มจากช่วงครึ่งเปิด[0, 1)ด้วยความแม่นยำ 24 หรือ 53 บิต (สำหรับf32และf64ตามลำดับ)OpenClosed01สุ่มจากช่วงครึ่งเปิด(0, 1]ด้วยความแม่นยำ 24 หรือ 53 บิตOpen01สุ่มจากช่วงเปิด(0, 1)ด้วยความแม่นยำ 23 หรือ 52 บิตUniformสุ่มจากช่วงที่กำหนดด้วยความแม่นยำ 23 หรือ 52 บิต
-
สำหรับชนิด
charการแจกแจงStandardUniformสุ่มจากรหัส Unicode ทั้งหมดที่มีอย่างสม่ำเสมอ; หลายค่าในนั้นอาจพิมพ์ไม่ได้ (ขึ้นอยู่กับการรองรับฟอนต์)Alphanumericสุ่มจาก เฉพาะ a-z, A-Z และ 0-9 แบบสม่ำเสมอ -
สำหรับทูเพิลและอาร์เรย์ แต่ละสมาชิกถูกสุ่มตามข้างต้นในกรณีที่รองรับ การแจกแจง
StandardUniformและUniformต่างรองรับชนิดข้อมูลเหล่านี้บางส่วน (ไม่เกินทูเพิล 12 สมาชิกและอาร์เรย์ 32 สมาชิก) ซึ่งรวมถึงทูเพิลว่าง()และอาร์เรย์ว่างด้วย เมื่อใช้rustc≥ 1.51 ให้เปิดใช้ฟีเจอร์min_const_genเพื่อรองรับ อาร์เรย์ที่มีสมาชิกมากกว่า 32 ตัว -
สำหรับชนิด SIMD แต่ละสมาชิกถูกสุ่มตามข้างต้น สำหรับ
StandardUniformและUniform(สำหรับแบบหลัง พารามิเตอร์lowและhighก็เป็น ชนิด SIMD เช่นกัน จึงสุ่มจากหลายช่วงพร้อมกันได้อย่างมีประสิทธิผล) การรองรับ SIMD ต้องใช้ฟีเจอร์แฟล็กsimd_supportและrustcเวอร์ชัน nightly -
สำหรับ enum คุณต้อง implement การสุ่มแบบสม่ำเสมอเอง ตัวอย่างเช่น คุณอาจใช้วิธีต่อไปนี้:
use rand::{Rng, RngExt, distr::{Distribution, StandardUniform}}; pub enum Food { Burger, Pizza, Kebab, } impl Distribution<Food> for StandardUniform { fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Food { let index: u8 = rng.random_range(0..3); match index { 0 => Food::Burger, 1 => Food::Pizza, 2 => Food::Kebab, _ => unreachable!(), } } }
การแจกแจงแบบไม่สม่ำเสมอ
เครต rand ให้เฉพาะการแจกแจงแบบไม่สม่ำเสมอสองแบบเท่านั้น:
- การแจกแจง
Bernoulliเพียงแค่สร้างค่าบูลีน โดยความน่าจะเป็นที่จะสุ่มได้trueนั้นเป็นค่าคงที่ (Bernoulli::new(0.5)) หรืออัตราส่วน (Bernoulli::from_ratio(1, 6)) - การแจกแจง
WeightedIndexใช้สุ่มจากลำดับของค่าที่ถ่วงน้ำหนักได้ ดูส่วน Sequences
การแจกแจงแบบไม่สม่ำเสมออื่นๆ อีกมากมีให้ในเครต rand_distr
จำนวนเต็ม
การแจกแจง Binomial เกี่ยวข้องกับ Bernoulli ตรงที่มันจำลองการทดลองอิสระ n ครั้ง แต่ละครั้งมีความน่าจะเป็น p ที่จะสำเร็จ แล้วนับจำนวนครั้งที่สำเร็จ
โปรดทราบว่าสำหรับ n ที่มาก การ implement การแจกแจง Binomial จะเร็วกว่าการสุ่ม n ครั้งทีละครั้งมาก
การแจกแจง Poisson แสดงจำนวนเหตุการณ์ที่คาดว่าจะเกิดขึ้นภายในช่วงเวลาคงที่ โดยที่เหตุการณ์เกิดขึ้นด้วยอัตราคงที่ λ การสุ่มจากการแจกแจง Poisson จะสร้างค่า Float เพราะการคำนวณการสุ่มใช้ Float และเราเลือกที่จะให้ผู้ใช้เป็นผู้ตัดสินใจเรื่องชนิดจำนวนเต็ม รวมถึงการแปลงที่เกี่ยวข้องซึ่งอาจสูญเสียข้อมูลและ panic ได้ด้วยตนเอง ตัวอย่างเช่น ค่า u64 หาได้ด้วย rng.sample(Poisson) as u64
โปรดทราบว่าการแปลงทศนิยมเป็นจำนวนเต็มที่อยู่นอกช่วงด้วย as ให้ผลเป็นพฤติกรรมที่นิยามไม่ได้สำหรับ Rust <1.45 และเป็นการแปลงแบบอิ่มตัวสำหรับ Rust >=1.45
การแจกแจงแบบไม่สม่ำเสมอต่อเนื่อง
การแจกแจงต่อเนื่องจำลองตัวอย่างที่ดึงมาจากเส้นจำนวนจริง ℝ หรือในบางกรณีเป็นจุดจากมิติที่สูงกว่า (ℝ², ℝ³ ฯลฯ) เรามีการ implement สำหรับเอาต์พุต f64 และ f32 ในกรณีส่วนใหญ่ แม้ว่าปัจจุบันการ implement สำหรับ f32 เพียงลดความแม่นยำของตัวอย่าง f64
การแจกแจงแบบเอกซ์โพเนนเชียล Exp จำลองเวลาจนถึงการสลายตัว โดยสมมติว่าอัตราการสลายตัวคงที่ (กล่าวคือ การสลายตัวแบบเอกซ์โพเนนเชียล)
การแจกแจง Normal (หรือที่รู้จักกันในชื่อการแจกแจงแบบเกาส์) จำลองการสุ่มจากการแจกแจง Normal (“เส้นโค้งระฆัง”) ด้วยค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐานที่กำหนด LogNormal เกี่ยวข้องกัน: สำหรับตัวอย่าง X จากการแจกแจงล็อกนอร์มัล log(X) จะแจกแจงแบบนอร์มัล; สิ่งนี้ทำให้การแจกแจงนอร์มัล “เบ้” เพื่อหลีกเลี่ยงค่าลบและมีหางบวกยาว
การแจกแจง UnitCircle และ UnitSphere จำลองการสุ่มแบบสม่ำเสมอจากเส้นรอบวงกลมหรือพื้นผิวทรงกลม
การแจกแจง Cauchy (หรือที่รู้จักกันในชื่อการแจกแจง Lorentz) คือการแจกแจงของจุดตัดแกน x ของรังสีจากจุด (x0, γ) ที่มีมุมแจกแจงแบบสม่ำเสมอ
การแจกแจง Beta เป็นการแจกแจงความน่าจะเป็นแบบสองพารามิเตอร์ ซึ่งค่าเอาต์พุตอยู่ระหว่าง 0 กับ 1 การแจกแจง Dirichlet เป็นการวางนัยทั่วไปเป็นจำนวนพารามิเตอร์บวกใดๆ
กระบวนการสุ่ม
คุณอาจสังเกตเห็นว่าเทรต Distribution ไม่อนุญาตให้มีการเปลี่ยนแปลงค่าสถานะภายในตัวเองเลย (ไม่มีเมธอดที่รับ &mut self) ซึ่งสิ่งนี้เกิดจากความตั้งใจในการออกแบบ: เนื่องจากการแจกแจงความน่าจะเป็นในทางคณิตศาสตร์ถูกนิยามว่าเป็นการจับคู่เชื่อมโยง (mapping) จากเหตุการณ์ไปยังค่าความน่าจะเป็นที่คงที่
ในทางตรงกันข้าม กระบวนการสโทแคสติก (Stochastic Process) คือแนวคิดที่ศึกษาเกี่ยวกับกลุ่มของตัวแปร (หรือสถานะของระบบ) ที่มีวิวัฒนาการเปลี่ยนแปลงไปตามเวลาในลักษณะสุ่ม
ไลบรารีนี้ไม่ได้มุ่งหมายที่จะนิยาม API ทั่วไปเพื่อครอบคลุมกระบวนการสุ่มทั้งหมด หรือจัดเตรียมเครื่องมือสำหรับจำลองโมเดลสโทแคสติกโดยตรง แต่ในบทนี้ เราจะมาพูดคุยถึงแง่มุมการประยุกต์ใช้ที่พบบ่อยบางประการ
การสุ่มแบบไม่ใส่คืน
ขอยกตัวอย่างคลาสสิก: สมมติว่ามีถุงใบหนึ่งบรรจุลูกแก้วสีแดง 10 ลูกและสีเขียว 30 ลูก ความน่าจะเป็นเริ่มต้นที่จะสุ่มหยิบได้ลูกแก้วสีแดงคือ 10/(10 + 30) = ¼ = 0.25 แต่หากลูกแก้วลูกแรกที่หยิบได้ เป็น สีแดง และ ไม่ใส่คืนกลับลงไปในถุง ความน่าจะเป็นที่การสุ่มหยิบลูกแก้วลูกที่สองจะได้สีแดงจะลดลงเหลือ 9/(9 + 30) = 3/13 ≅ 0.23
เครต rand ไม่ได้มีระบบสำเร็จรูปสำหรับรองรับการสุ่มแบบไม่ใส่คืนทีละขั้นตอน (step-wise) แต่สิ่งที่มีให้คือการรองรับการสุ่มเลือกสมาชิกที่ไม่ซ้ำกันหลายตัวจากลำดับข้อมูลในคราวเดียว ได้แก่:
IteratorRandom::choose_multiple และ SliceRandom::choose_multiple
หากคุณต้องการอิมพลีเมนต์การสุ่มแบบไม่ใส่คืนทีละขั้นตอนด้วยตนเอง นี่คือแนวทางที่สามารถนำไปปรับใช้ได้:
- ใส่สมาชิกทั้งหมดลงใน
Vecโดยในแต่ละขั้นตอนให้สุ่มเลือกดัชนีแล้วลบสมาชิกนั้นออก ข้อพึงระวังคือ หากชุดข้อมูลมีขนาดใหญ่มาก วิธีนี้จะไม่มีประสิทธิภาพ เนื่องจากคำสั่งVec::removeมีความซับซ้อนระดับO(n)อีกทั้งยังต้องเสียต้นทุนในการสร้างสมาชิกทั้งหมดขึ้นมาก่อน - ใส่สมาชิกทั้งหมดลงใน
Vecแล้วทำการสับเปลี่ยนลำดับ (shuffle) จากนั้นในแต่ละขั้นตอนก็เพียงแค่อ่านดึงสมาชิกตัวถัดไปออกมาเรื่อยๆ - สร้างเมธอดสุ่มค่าจากการแจกแจงตั้งต้น ควบคู่ไปกับการใช้
HashSetว่างเปล่าเพื่อบันทึกค่าที่ “ถูกเลือกไปแล้ว” โดยในแต่ละขั้นตอนให้สุ่มค่าขึ้นมา หากค่านั้นมีอยู่ในHashSetแล้ว ก็ให้ปฏิเสธค่านั้นแล้วสุ่มใหม่ แต่หากยังไม่มี ให้บันทึกสำเนาลงในHashSetแล้วคืนค่านั้นออกมา ทั้งนี้วิธีนี้จะไม่มีประสิทธิภาพเว้นแต่ว่าจำนวนสมาชิกที่ต้องการสุ่มจะมีสัดส่วนน้อยกว่า จำนวนสมาชิกทั้งหมดอย่างมาก - ศึกษาเพิ่มเติมจากไฟล์
src/seq/index.rs: ซึ่งมีอัลกอริทึมการสุ่มตัวอย่างหลายรูปแบบที่ใช้อยู่ ซึ่งอาจนำมาปรับใช้กับงานนี้ได้
ลำดับ
Rand implement การดำเนินการแบบสุ่มที่พบบ่อยบนลำดับหลายอย่างผ่านเทรต
IteratorRandom และ SliceRandom
การสร้างดัชนี
การสุ่ม:
- ดัชนีเดียวภายในช่วงที่กำหนด ใช้
Rng::random_range - ดัชนีที่แตกต่างกันหลายตัวจาก
0..lengthใช้index::sample - ดัชนีที่แตกต่างกันหลายตัวจาก
0..lengthพร้อมน้ำหนัก ใช้index::sample_weighted
การสับ
การสับสไลซ์:
SliceRandom::partial_shuffle: สับบางส่วน; มีประโยชน์ในการดึงสมาชิกamountตัวแบบสุ่มในลำดับแบบสุ่ม
การสุ่มตัวอย่าง
ต่อไปนี้เป็นวิธีที่สะดวกในการสุ่มค่าจากสไลซ์หรืออิเทอเรเตอร์:
IteratorRandom::choose_stable: สุ่มสมาชิกหนึ่งตัวจากอิเทอเรเตอร์ (แบบ value) โดยการเรียกใช้ RNG ไม่ได้รับผลกระทบจากsize_hintของอิเทอเรเตอร์IteratorRandom::choose_multiple_fill: สุ่มสมาชิกหลายตัว แล้วใส่ลงในบัฟเฟอร์IteratorRandom::choose_multiple: สุ่มสมาชิกหลายตัว แล้วคืนVec
โปรดทราบว่าการดำเนินการกับอิเทอเรเตอร์มักมีประสิทธิภาพน้อยกว่าการดำเนินการกับสไลซ์
การสุ่มแบบถ่วงน้ำหนัก
ตัวอย่างเช่น การสุ่มแบบถ่วงน้ำหนักอาจใช้จำลองสีของลูกแก้วที่สุ่มจากถังที่บรรจุสีเขียว 5 ลูก สีแดง 15 ลูก และสีน้ำเงิน 80 ลูก
แบบใส่คืน
การสุ่มแบบใส่คืนหมายความว่าค่าที่สุ่มได้ (ลูกแก้ว) ถูกใส่คืน (ดังนั้น ความน่าจะเป็นในการสุ่มแต่ละชนิดจึงไม่ได้รับผลกระทบจากการสุ่ม)
สิ่งนี้ถูก implement โดยการแจกแจงต่อไปนี้:
WeightedIndexตั้งค่าเริ่มต้นได้เร็วและสุ่มด้วยO(log N)WeightedAliasIndexตั้งค่าเริ่มต้นได้ช้าและสุ่มด้วยO(1)จึงอาจ เร็วกว่าเมื่อมีจำนวนตัวอย่างมาก
เพื่อความสะดวก คุณอาจใช้:
แบบไม่ใส่คืน
การสุ่มแบบไม่ใส่คืนหมายความว่าการสุ่มเปลี่ยนแปลงการแจกแจง เนื่องจากเทรต Distribution สร้างขึ้นบนแนวคิดของการแจกแจงที่ไม่เปลี่ยนแปลง เราจึงมีสิ่งต่อไปนี้:
SliceRandom::choose_multiple_weighted: สุ่มค่าที่แตกต่างกันamountตัว จากสไลซ์พร้อมน้ำหนักindex::sample_weighted: สุ่มดัชนีที่แตกต่างกันamountตัวจากช่วงพร้อม น้ำหนัก- implement เอง: ดูหัวข้อใน กระบวนการสุ่ม
การจัดการข้อผิดพลาด
การจัดการข้อผิดพลาดใน Rand เป็นการประนีประนอมที่ลงตัวระหว่างความเรียบง่ายกับความจำเป็นในทางปฏิบัติ เพราะตัวสร้าง RNG และฟังก์ชันการสุ่มค่าส่วนใหญ่จะไม่มีวันเกิดข้อผิดพลาดขึ้นเลย หากเราบังคับให้ทุกฟังก์ชันต้องจัดการกับข้อผิดพลาด ก็จะกลายเป็นการเพิ่มภาระส่วนเกิน (overhead) อย่างมหาศาล (ทั้งในแง่ความซับซ้อนของโค้ด ความสะดวกในการเขียนโค้ดเรียกใช้งาน ตลอดจนอาจกระทบต่อประสิทธิภาพการประมวลผลด้วย) อย่างไรก็ตาม ตัวสร้าง RNG ภายนอก (เช่น แหล่งเลขสุ่มจากระบบปฏิบัติการ) สามารถเกิดความล้มเหลวขึ้นได้จริง และการเปิดโอกาสให้ผู้ใช้สามารถดักจับข้อผิดพลาดดังกล่าวได้จึงยังคงเป็นเรื่องสำคัญ
ดังนั้นจึงตัดสินใจว่าเมธอดส่วนใหญ่ไม่ควรคืนค่าเป็นชนิด
Result ยกเว้นข้อยกเว้นสำคัญบางประการ ได้แก่:
ฟังก์ชันส่วนใหญ่ที่นำค่าสุ่มไปใช้งานจะไม่พยายามจัดการข้อผิดพลาดใดๆ และลดรูปเหลือการเรียกเมธอดแบบ “ไม่ล้มเหลว” (infallible) ของ RngCore เนื่องจาก RNG ส่วนใหญ่ไม่สามารถล้มเหลวได้อยู่แล้ว ปกติจึงไม่เป็นปัญหา แต่ตัวสร้างบางตัวที่ล้มเหลวได้อาจถูกบังคับให้ล้มเหลวในกรณีนี้:
OsRngเป็นตัวห่อหุ้มgetrandomจากเอกสารของตัวหลัง: “โดยทั่วไปแล้ว บนแพลตฟอร์มที่รองรับ ความล้มเหลวเกิดขึ้นได้ยากมาก แม้จะไม่ใช่เรื่องเป็นไปไม่ได้ก็ตาม”OsRngจะส่งต่อข้อผิดพลาดผ่านRngCore::try_fill_bytesขณะที่เมธอดอื่นๆ จะ panic เมื่อเกิดข้อผิดพลาดrngซีดตัวเองผ่านOsRngเมื่อใช้งานครั้งแรกและเป็นระยะๆ หลังจากนั้น จึงอาจล้มเหลวได้ แม้จะไม่น่าจะเกิดขึ้น หากการซีดครั้งแรก ล้มเหลว จะเกิด panic หากความล้มเหลวเกิดขึ้นระหว่างการซีดใหม่ (ซึ่งมีโอกาสน้อยกว่า) RNG จะทำงานต่อโดยไม่ซีดใหม่ และจะมีการส่งข้อความล็อก (ระดับเตือน) หากเปิดใช้การล็อกอยู่
การทดสอบฟังก์ชันที่ใช้ RNG
ในบางครั้ง ฟังก์ชันที่ใช้งานตัวสร้างเลขสุ่มอาจจำเป็นต้องได้รับการทดสอบ สำหรับฟังก์ชันที่ต้องทดสอบร่วมกับเวกเตอร์ทดสอบ (test vectors) เราสามารถประยุกต์ใช้วิธีการดังต่อไปนี้:
use rand::{TryCryptoRng, rngs::SysRng};
pub struct CryptoOperations<R: TryCryptoRng = SysRng> {
rng: R
}
impl<R: TryCryptoRng> CryptoOperations<R> {
#[must_use]
pub fn new(rng: R) -> Self {
Self {
rng
}
}
pub fn xor_with_random_bytes(&mut self, secret: &mut [u8; 8]) -> [u8; 8] {
let mut mask = [0u8; 8];
self.rng.try_fill_bytes(&mut mask).unwrap();
for (byte, mask_byte) in secret.iter_mut().zip(mask.iter()) {
*byte ^= mask_byte;
}
mask
}
}
fn main() {
let rng = SysRng;
let mut crypto_ops = <CryptoOperations>::new(rng);
let mut secret: [u8; 8] = *b"\x00\x01\x02\x03\x04\x05\x06\x07";
let mask = crypto_ops.xor_with_random_bytes(&mut secret);
println!("Modified Secret (XORed): {:?}", secret);
println!("Mask: {:?}", mask);
}
สำหรับการทดสอบ เราสามารถสร้าง MockCryptoRng ที่อิมพลีเมนต์ TryRngCore และ TryCryptoRng ขึ้นมาไว้ในโมดูลทดสอบได้ สังเกตว่า MockCryptoRng เป็นแบบ private และ #[cfg(test)] mod tests จะถูกจำกัดเงื่อนไข (cfg-gated) ให้อยู่เฉพาะในสภาพแวดล้อมการทดสอบเท่านั้น จึงมั่นใจได้ว่าจะไม่มีทางนำ MockCryptoRng ไปใช้งานบนโปรดักชันโดยไม่ได้ตั้งใจ
#[cfg(test)]
mod tests {
use super::*;
#[derive(Clone, Copy, Debug)]
struct MockCryptoRng {
data: [u8; 8],
index: usize,
}
impl MockCryptoRng {
fn new(data: [u8; 8]) -> MockCryptoRng {
MockCryptoRng {
data,
index: 0,
}
}
}
impl CryptoRng for MockCryptoRng {}
impl RngCore for MockCryptoRng {
fn next_u32(&mut self) -> u32 {
unimplemented!()
}
fn next_u64(&mut self) -> u64 {
unimplemented!()
}
fn fill_bytes(&mut self, dest: &mut [u8]) {
for byte in dest.iter_mut() {
*byte = self.data[self.index];
self.index = (self.index + 1) % self.data.len();
}
}
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
unimplemented!()
}
}
#[test]
fn test_xor_with_mock_rng() {
let mock_crypto_rng = MockCryptoRng::new(*b"\x57\x88\x1e\xed\x1c\x72\x01\xd8");
let mut crypto_ops = CryptoOperations::new(mock_crypto_rng);
let mut secret: [u8; 8] = *b"\x00\x01\x02\x03\x04\x05\x06\x07";
let mask = crypto_ops.xor_with_random_bytes(&mut secret);
let expected_mask = *b"\x57\x88\x1e\xed\x1c\x72\x01\xd8";
let expected_xored_secret = *b"\x57\x89\x1c\xee\x18\x77\x07\xdf";
assert_eq!(secret, expected_xored_secret);
assert_eq!(mask, expected_mask);
}
}
การอัปเดต
คู่มือนี้จัดทำขึ้นเพื่ออำนวยความสะดวกในการอัปเกรดไปยังเวอร์ชันไมเนอร์ (minor) หรือเมเจอร์ (major) ถัดไปของ Rand โปรดทราบว่าการอัปเดตไปยังเวอร์ชันแพตช์ (patch) ถัดไป (เช่น 0.5.1 ไปเป็น 0.5.2) จะต้องไม่จำเป็นต้องแก้ไขโค้ดใดๆ
คู่มือนี้ให้รายละเอียดเชิงลึกมากกว่า บันทึกการเปลี่ยนแปลง เล็กน้อย โดยเฉพาะอย่างยิ่งคำแนะนำในการใช้งานฟีเจอร์ใหม่ๆ ตลอดจนแนวทางการย้ายออกจากฟีเจอร์เก่าที่เลิกใช้แล้ว
การอัปเดตเป็น 0.5
ในเวอร์ชัน 0.5 มีการเปลี่ยนแปลงครั้งสำคัญค่อนข้างมากเมื่อเทียบกับ 0.4 จึงขอแนะนำให้อ่านรายละเอียดเกี่ยวกับการเปลี่ยนแปลงที่อาจส่งผลกระทบต่อโค้ดเดิม (breaking changes) ด้านล่างนี้อย่างถี่ถ้วน นอกจากนี้ เวอร์ชันนี้ยังมีการปรับปรุงประสิทธิภาพขนานใหญ่อีกหลายจุดที่ไม่ได้ระบุไว้ในรายละเอียดด้านล่าง
เครต
เราได้เพิ่มเครตใหม่คือ rand_core! เครตนี้รวบรวมเทรตหลักที่สำคัญ เช่น RngCore, BlockRngCore, SeedableRng และ CryptoRng, ประเภทข้อผิดพลาด (error type) ตลอดจนสองโมดูลตัวช่วยสำหรับการอิมพลีเมนต์ ได้แก่ le และ impls สำหรับผู้ที่ต้องการอิมพลีเมนต์ตัวสร้างเลขสุ่ม ขอแนะนำให้เรียกใช้เครต rand_core โดยตรง ส่วนผู้ใช้งานทั่วไปสามารถใช้เพียงเครต rand ซึ่งทำการ re-export รายการส่วนใหญ่จาก rand_core ให้อยู่แล้ว
เครต rand_derive ถูกยกเลิกการใช้งาน (deprecated) เนื่องจากมีอัตราการใช้งานต่ำมากและมีการเลิกใช้เทรต Rand ไปแล้ว
ฟีเจอร์
มีฟีเจอร์แฟล็กของ Cargo เพิ่มใหม่หลายตัว:
allocเปิดใช้งานเมื่อไม่ใช้stdเพื่อให้สามารถใช้งานBoxและVecได้serde1เพิ่มการรองรับการทำ serialization ให้กับ PRNG บางตัวlogเพิ่มการบันทึก log ในบางจุด (โดยหลักอยู่ที่OsRngและJitterRng)
Rng และเพื่อนๆ (เทรตหลัก)
เทรต Rng ถูกแยกออกเป็น 2 เทรต ได้แก่ RngCore ฝั่ง “แบ็กเอนด์” (อิมพลีเมนต์โดยตัวสร้างเลขสุ่ม) และ Rng ฝั่ง “ฟรอนต์เอนด์” ซึ่งมี extension method อำนวยความสะดวกอย่างครบครัน
ผู้พัฒนาที่ต้องการอิมพลีเมนต์ตัวสร้างเลขสุ่มจะต้องเปลี่ยนมา impl RngCore แทน ขอแนะนำให้ใช้ rand_core สำหรับการพัฒนา โดยโมดูล rand_core::{le, impls} จะมีตัวช่วยที่เป็นประโยชน์อย่างมาก
สำหรับผู้ใช้ Rng ที่ไม่จำเป็นต้องอิมพลีเมนต์ตัวสร้างเอง แทบไม่ต้องปรับแก้โค้ดเลย บ่อยครั้งคุณไม่จำเป็นต้องนึกถึง RngCore และเพียงแค่อิมพอร์ต Rng เข้ามาใช้งานเท่านั้น โดยแทนที่จะเรียก RngCore::next_u32() / next_u64() ให้เปลี่ยนมาใช้ Rng::gen() และแทนที่จะใช้ RngCore::fill_bytes(dest) ก็สามารถใช้ Rng::fill(dest) แทนได้
เมธอดของ Rng / RngCore
เพื่อรองรับการจัดการข้อผิดพลาดจากแหล่งกำเนิดที่อาจเกิดความผิดพลาดได้ (เช่น OsRng) จึงได้เพิ่มเมธอด RngCore::try_fill_bytes ขึ้นมาใหม่ ตัวอย่างเช่น EntropyRng จะใช้กลไกนี้เพื่อสลับไปใช้ JitterRng สำรองหาก OsRng ล้มเหลว และมีข้อความแจ้งข้อผิดพลาดที่ชัดเจนยิ่งขึ้น
ส่วนเมธอดอื่นๆ จะยังคง panic เมื่อเกิดข้อผิดพลาดเช่นเดิม แต่เนื่องจากเมธอดเหล่านั้นมักถูกใช้กับตัวสร้างเชิงอัลกอริทึมที่โดยปกติไม่มีทางทำงานล้มเหลว จึงถือเป็นแนวทางที่เหมาะสมและลงตัว
เมธอดบางตัวจาก Rng เดิมถูกนำออกหรือเลิกใช้:
next_f32และnext_f64: ตัวสร้างเลขสุ่มไม่สามารถอิมพลีเมนต์เมธอดเหล่านี้ได้โดยตรงอีกต่อไป ให้เปลี่ยนมาใช้genแทนgen_iter: ให้เปลี่ยนไปใช้อิเทอเรเตอร์มาตรฐานของ Rust ร่วมกับคลอเชอร์แทน:::std::iter::repeat(()).map(|()| rng.gen())gen_ascii_chars: ให้ใช้repeatตามแบบด้านบนร่วมกับrng.sample(Alphanumeric)gen_weighted_bool(n): ให้เปลี่ยนมาใช้gen_bool(1.0 / n)แทน
Rng มีเมธอดใหม่เพิ่มเติมเข้ามา:
sample(distr)เป็นทางลัดแทนการเรียกdistr.sample(rng)สำหรับDistributionใดๆgen_bool(p)สุ่มค่าบูลีนโดยมีความน่าจะเป็นเท่ากับpที่จะได้ผลลัพธ์เป็น truefillและtry_fillสอดคล้องกับfill_bytesและtry_fill_bytesตามลำดับ (ต่างกันตรงการส่งต่อข้อผิดพลาด) เมธอดเหล่านี้สามารถเติมข้อมูลลงในสไลซ์จำนวนเต็มหรืออาร์เรย์ได้โดยตรง และให้ประสิทธิภาพที่ดีกว่าgen()
การสร้าง PRNG
PRNG ที่สุ่มค่าตั้งต้นใหม่
มีการเพิ่มเทรตใหม่: FromEntropy เทรตนี้ได้รับการอิมพลีเมนต์โดยอัตโนมัติให้กับทุกประเภทข้อมูลที่รองรับ SeedableRng ช่วยให้สามารถสร้างตัวสร้างเลขสุ่มจากแหล่งเอนโทรปีที่สดใหม่และมั่นคงปลอดภัยได้โดยสะดวก:
extern crate rand_0_5 as rand;
use rand::{ChaChaRng, FromEntropy};
let mut rng = ChaChaRng::from_entropy();
การกำหนดซีดให้กับ PRNG
เทรต SeedableRng ได้รับการปรับปรุงให้กำหนดประเภทของซีดผ่าน associated type (SeedableRng::Seed) แทนที่จะใช้พารามิเตอร์เทมเพลต (SeedableRng<Seed>) ยิ่งไปกว่านั้น PRNG ทุกตัวในตอนนี้จะรับซีดเป็นอาร์เรย์ของไบต์ ([u8; N] โดยที่ N มีขนาดคงที่) ทำให้สามารถจัดการการกำหนดซีดให้กับ PRNG แบบเจเนอริกได้อย่างที่เคยทำไม่ได้มาก่อน
PRNG จะไม่สามารถสร้างขึ้นจาก PRNG อื่นผ่านการรองรับ Rand / gen() ได้อีกต่อไป แต่จะต้องทำผ่าน SeedableRng::from_rng ซึ่งรองรับการจัดการข้อผิดพลาดและมีความชัดเจนตรงไปตรงมา
SeedableRng::reseed ถูกนำออกไป เนื่องจากไม่ได้มีประโยชน์เพิ่มขึ้นเมื่อเทียบกับ from_seed และความได้เปรียบด้านประสิทธิภาพก็ยังไม่มีความชัดเจน
ผู้ที่อิมพลีเมนต์ SeedableRng อาจจำเป็นต้องเปลี่ยนประเภท Seed ของตนมาเป็นอาร์เรย์ของไบต์ ข้อกำหนดนี้กำหนดขึ้นเพื่อรับประกันความเข้ากันได้ของการจัดการลำดับไบต์ (Endianness) ข้ามแพลตฟอร์ม ทั้งนี้มีฟังก์ชันตัวช่วยใน rand_core::le สำหรับอ่านค่า u32 และ u64 จากอาร์เรย์ของไบต์ให้ใช้งาน
PRNG ที่ทำงานเป็นบล็อก
rand_core มีเทรตตัวช่วยใหม่ชื่อ BlockRngCore และโครงสร้างอิมพลีเมนต์ชื่อ BlockRng สิ่งเหล่านี้ออกแบบมาสำหรับตัวสร้างเลขสุ่มที่สร้างข้อมูลสุ่มออกมาทีละบล็อกแทนที่จะเป็นค่าขนาดเวิร์ด (word) การนำเทรตและโครงสร้างนี้ไปใช้มีข้อดี 2 ประการ ได้แก่ มีเมธอดบน RngCore ที่ได้รับการปรับแต่งประสิทธิภาพมาให้พร้อมใช้ และสามารถนำ PRNG ดังกล่าวไปใช้งานร่วมกับ ReseedingRng ได้โดยมี overhead ที่ต่ำมาก
RNG สำหรับงานวิทยาการรหัสลับ
มีการเพิ่มเทรตใหม่: CryptoRng เทรตนี้เป็น marker trait ล้วนๆ เพื่อระบุว่าตัวสร้างเลขสุ่มตัวใดน่าจะเหมาะสมกับการใช้งานด้านวิทยาการรหัสลับ เช่น
fn foo<R: Rng + CryptoRng>(rng: &mut R) ทั้งนี้ไม่สามารถรับประกันความเหมาะสมต่อการใช้งานเชิงรหัสลับได้อย่างสมบูรณ์
การจัดการข้อผิดพลาด
มีการเพิ่มประเภทข้อมูล Error ใหม่ ซึ่งออกแบบมาเพื่อรองรับสภาพแวดล้อม no-std โดยเฉพาะ โดยเน้นความเรียบง่ายและมีความยืดหยุ่นเพียงพอสำหรับการใช้งานของเรา (เก็บข้อมูลต้นเหตุหรือ cause ไว้ด้วยหากเป็นไปได้):
extern crate rand_0_5 as rand;
use rand::ErrorKind;
pub struct Error {
pub kind: ErrorKind,
pub msg: &'static str,
// some fields omitted
}
ประเภท ErrorKind ที่แนบมาด้วยจะช่วยจัดกลุ่มข้อผิดพลาดในภาพกว้าง ได้แก่ แบบถาวร (permanent), แบบไม่คาดคิด (unexpected), แบบชั่วคราว (transient) และแบบยังไม่พร้อมใช้งาน (not-yet-ready)
รายการฟังก์ชันต่อไปนี้จะใช้งานประเภทข้อผิดพลาดตัวใหม่:
RngCore::try_fill_bytesRng::try_fillOsRng::newJitterRng::new
ตัวสร้างจากภายนอก
เรามีตัวสร้างเลขสุ่มตัวใหม่คือ EntropyRng ซึ่งครอบการทำงานของ OsRng และ JitterRng ไว้ (โดยจะเลือกใช้งานตัวแรกก่อน แต่หากจำเป็นจะสลับไปใช้ตัวหลังเป็นตัวสำรอง) โครงสร้างนี้ช่วยให้สร้าง RNG พร้อมระบบสำรองได้ง่ายผ่าน SeedableRng::from_rng
เช่น IsaacRng::from_rng(EntropyRng::new())? ซึ่งทำงานเทียบเท่ากับการใช้ FromEntropy แตกต่างกันเพียงเรื่องการจัดการข้อผิดพลาด
ขอแนะนำให้เลือกใช้ EntropyRng แทน OsRng เพื่อป้องกันข้อผิดพลาดบนแพลตฟอร์มที่ตัวสร้างเลขสุ่มของระบบเสียหายหรือใช้การไม่ได้ แต่โปรดระลึกไว้ว่าการสลับไปพึ่งพา JitterRng นั้นจะทำงานได้ช้ามาก
PRNG
ตัวสร้างเลขสุ่มเทียม (PRNG หรือตัวสร้างเชิงอัลกอริทึมแบบดีเทอร์มินิสติก) มีการปรับเปลี่ยนหลายประการนับตั้งแต่ 0.4 โดยปัจจุบันได้ย้ายมาอยู่ในโมดูล prng (ชื่อเดิมยังคงใช้งานได้ชั่วคราวเพื่อรักษาความเข้ากันได้ย้อนหลัง แต่ท้ายที่สุดแล้วตัวสร้างเหล่านี้มีแนวโน้มจะย้ายออกไปอยู่นอกเครต rand)
PRNG ทุกตัวในตอนนี้จะไม่อิมพลีเมนต์ Copy เพื่อป้องกันการคัดลอกสถานะของตัวสร้างโดยไม่ตั้งใจ (ซึ่งอาจนำไปสู่การสร้างค่าสุ่มซ้ำเดิม) อย่างไรก็ตาม คุณยังสามารถโคลนสถานะได้อย่างโจ่งแจ้งผ่านเทรต Clone นอกจากนี้ PRNG ทุกตัวยังได้รับการปรับแต่งการอิมพลีเมนต์ Debug ไม่ให้พิมพ์สถานะภายในออกมา เพื่อป้องกันไม่ให้สถานะของตัวสร้างเชิงรหัสลับรั่วไหลลงไปในไฟล์บันทึก (log files) โดยไม่ได้ตั้งใจ แนะนำให้ผู้พัฒนา PRNG ภายนอกปฏิบัติตามแนวทางนี้เช่นกัน (ดูเพิ่มเติมในเอกสารประกอบของ RngCore)
SmallRng ถูกเพิ่มเข้ามาเป็นตัวครอบ wrapper โดยในปัจจุบันครอบการทำงานของ XorShiftRng ไว้ (และมีแนวโน้มจะเปลี่ยนเป็นอัลกอริทึมอื่นในอนาคตอันใกล้) เหมาะสำหรับการใช้งานที่ต้องการขนาดสถานะที่กะทัดรัดและการเริ่มต้นทำงานที่รวดเร็ว แต่ไม่ต้องการความปลอดภัยระดับวิทยาการรหัสลับ (ประสิทธิภาพการสร้างเลขจริงอาจแตกต่างกันไปตามการทดสอบ benchmark ทั้งนี้ขึ้นอยู่กับลักษณะการใช้งาน มันอาจจะใช่หรือไม่ใช่อัลกอริทึมที่เร็วที่สุด แต่รับรองว่าจะทำงานได้เร็วอย่างสม่ำเสมอ)
ReseedingRng
ตัวครอบ ReseedingRng ได้รับการปรับปรุงครั้งใหญ่เพื่อลด overhead ลงอย่างมาก อย่างไรก็ดี ReseedingRng แบบใหม่นี้ไม่สามารถทำงานร่วมกับ RNG ได้ทุกตัว แต่จะจำกัดเฉพาะตัวที่อิมพลีเมนต์ BlockRngCore เท่านั้น
ChaCha
เมธอด ChaChaRng::set_counter ถูกแทนที่ด้วยเมธอดใหม่ 2 ตัว ได้แก่ set_word_pos และ set_stream หากจำเป็น คุณสามารถจำลองพฤติกรรมการทำงานของเมธอดเดิมได้ดังนี้:
extern crate rand_0_5 as rand;
use rand::prelude::*;
use rand_chacha_0_1::ChaChaRng;
fn main() {
let lower = 88293;
let higher = 9300932;
// previously:
// let mut rng = rand::ChaChaRng::new_unseeded();
// rng.set_counter(lower, higher);
// now:
let mut rng = ChaChaRng::from_seed([0u8; 32]);
rng.set_word_pos(lower << 4);
rng.set_stream(higher);
assert_eq!(4060232610, rng.next_u32());
assert_eq!(2786236710, rng.next_u32());
}
PRNG ตระกูล ISAAC
PRNG IsaacRng และ Isaac64Rng มีเมธอดสร้างเพิ่มเติมเข้ามาคือ new_from_u64(seed) แม้ขนาดสถานะ 64 บิตจะไม่เพียงพอสำหรับงานวิทยาการรหัสลับ แต่ก็มีประโยชน์มากในงานจำลองสถานการณ์ (simulation) และการพัฒนาเกม ในอนาคตเมธอดนี้อาจถูกแทนที่ด้วยเมธอดสร้าง PRNG จากออบเจกต์ใดๆ ที่สามารถแฮชได้
HC-128
นี่คือตัวสร้างเลขสุ่มเชิงรหัสลับตัวใหม่ ซึ่งได้รับคัดเลือกจาก eSTREAM ให้เป็นหนึ่งใน “สตรีมไซเฟอร์ที่เหมาะสมสำหรับการนำไปใช้อย่างแพร่หลาย” โดยในตอนนี้ HC-128 ได้กลายเป็นตัวสร้างเชิงรหัสลับค่าเริ่มต้นที่ใช้งานโดย StdRng และ thread_rng()
ฟังก์ชันและเทรตตัวช่วย
เทรต Rand ถูกยกเลิกการใช้งาน (deprecated) โดยแนะนำให้เปลี่ยนมาใช้ Standard ซึ่งเป็นการแจกแจงที่แท้จริงและรองรับการสุ่มตัวอย่างได้เหมือนกับ Rand ทุกประการ ปัจจุบัน Rng::gen() จะเรียกใช้ Standard ภายในและยังคงทำงานได้เหมือนเดิมทุกประการ โปรดดูเอกสารประกอบของโมดูล distributions สำหรับวิธีอิมพลีเมนต์ Distribution<T> ของ Standard ให้กับประเภทข้อมูลที่ผู้ใช้กำหนดขึ้นเอง (T)
ฟังก์ชัน weak_rng() ถูกยกเลิกการใช้งาน ให้เปลี่ยนไปใช้ SmallRng::from_entropy() แทน
การแจกแจง
เทรต Sample และ IndependentSample ถูกรวมและแทนที่ด้วยเทรตเดียวคือ Distribution ซึ่งมีลักษณะเทียบเคียงกับ IndependentSample เป็นส่วนใหญ่ เพียงแต่เปลี่ยนจาก ind_sample มาเป็นชื่อ sample สั้นๆ สำหรับการรองรับการแจกแจงแบบแก้ไขค่าได้ (mutable distributions) นั้นได้ถูกยกเลิกไป แม้ว่าในทางปฏิบัติอาจมีกรณีการใช้งานจริงอยู่บ้าง แต่ก็ไม่ได้แพร่หลายเพียงพอที่จะสนับสนุนให้มีเทรตแยกกันถึงสองตัว หรือบังคับให้ต้องส่งการอ้างอิงแบบมิวเทเบิลไปยังออบเจกต์การแจกแจง ปัจจุบันทั้ง Sample และ IndependentSample ยังคงเปิดให้เรียกใช้ได้แต่ถูกทำเครื่องหมายเลิกใช้ (deprecated) แล้ว และจะถูกถอดออกในเวอร์ชันถัดไป
ตอนนี้ Distribution::sample (รวมถึงอีกหลายฟังก์ชัน) สามารถเรียกใช้งานบน RNG ที่เป็นแบบ unsized (เช่น trait object) ได้โดยตรง
RandSample ถูกถอดออกแล้ว (ดูรายละเอียดได้ที่หัวข้อการเลิกใช้ Rand และการแจกแจง Standard ตัวใหม่)
ตัวครอบ Closed01 ถูกถอดออก และได้เพิ่ม OpenClosed01 เข้ามาแทน
การแจกแจงแบบสม่ำเสมอ
มีการแจกแจงใหม่ 2 แบบ ได้แก่:
Standardทำการสุ่มตัวอย่างที่มีการกระจายตัวแบบสม่ำเสมอสำหรับประเภทข้อมูลที่หลากหลาย ทำหน้าที่ทดแทนRandAlphanumericสุ่มตัวอักษรcharจากช่วงa-z,A-Z,0-9
ช่วง
การแจกแจง Range ได้รับการปรับปรุงขนานใหญ่และเปลี่ยนชื่อเป็น Uniform:
Uniform::new(low, high)ยังคงมีอยู่ตามเดิม (ช่วงครึ่งเปิด[low, high))Uniform::new_inclusive(low, high)เพิ่มเข้ามาใหม่ โดยจะนับรวมขอบเขตบนhighเข้าไปในผลลัพธ์ด้วยUniform::sample_single(low, high, rng)เป็นทางเลือกที่เร็วกว่าสำหรับการสุ่มเพียงครั้งเดียวจากช่วง[low, high)
ปัจจุบันคุณสามารถอิมพลีเมนต์ Uniform ให้กับประเภทข้อมูลที่สร้างขึ้นเองได้แล้ว โดยดูรายละเอียดได้ในโมดูล uniform
การแจกแจงแบบไม่สม่ำเสมอ
มีการแจกแจงใหม่เพิ่มเข้ามา 2 แบบ ได้แก่:
- Poisson จำลองจำนวนเหตุการณ์ที่คาดหวังจากแหล่งที่มีอัตราคงที่ภายในช่วงเวลาคงที่ (เช่น การสลายตัวของนิวเคลียส)
- Binomial จำลองผลลัพธ์ของการทดลองแบบใช่-ไม่ใช่จำนวนคงที่ครั้ง
อัลกอริทึมการสุ่มตัวอย่างอ้างอิงตามระเบียบวิธีใน “Numerical Recipes in C”
การแจกแจงแบบเอกซ์โพเนนเชียลและ Normal
การแจกแจงหลัก Exp และ Normal ไม่เปลี่ยนแปลง อย่างไรก็ตามเวอร์ชัน “มาตรฐาน” คือ Exp1 และ StandardNormal ไม่ได้เป็นชนิดตัวห่อหุ้มอีกต่อไป แต่เป็นการแจกแจงเต็มรูปแบบ แทนที่จะเขียน let Exp1(x) = rng.gen(); ตอนนี้คุณเขียน
let x = rng.sample(Exp1);
การอัปเดตเป็น 0.6
ในระหว่างรอบการพัฒนา 0.6 นั้น Rand ได้ย้ายมาอยู่ภายใต้โครงการ rust-random อย่างเป็นทางการ พวกเรารู้สึกอบอุ่นเหมือนได้อยู่บ้าน และหากคุณต้องการร่วมตกแต่งบ้านใหม่กับเรา เรายินดีรับความช่วยเหลือด้าน โลโก้ใหม่ เป็นอย่างยิ่ง!
นอกจากนี้ เรายังได้สร้างบ้านหลังใหม่สำหรับเอกสารประกอบการใช้งานที่เน้นผู้ใช้เป็นศูนย์กลาง นั่นคือหนังสือคู่มือเล่มนี้นี่เอง!
PRNG
PRNG ทุกตัวใน โมดูล PRNG เดิมของเรา ได้ถูกแยกย้ายไปยังเครตใหม่โดยเฉพาะ นอกจากนี้เรายังได้เพิ่มเครตสำหรับอัลกอริทึม PCG รวมถึงเครตภายนอกสำหรับอัลกอริทึมตระกูล Xoshiro / Xoroshiro:
SmallRng
ในการอัปเดตครั้งนี้ เราได้สลับอัลกอริทึมเบื้องหลังของ SmallRng จากเดิมที่ใช้ Xorshift มาเป็นอัลกอริทึม PCG (ไม่ว่าจะเป็น Pcg64Mcg หรือที่รู้จักกันในชื่อ XSL 128/64 MCG หรือ Pcg32 หรือที่รู้จักในชื่อ XSH RR 64/32 LCG ซึ่งเป็นอัลกอริทึม PCG มาตรฐาน)
ลำดับ
โมดูล seq ได้รับการเขียนขึ้นใหม่ทั้งหมด โดยได้นำเมธอด choose และ shuffle ออกจากเทรต Rng โดยฟังก์ชันการทำงานส่วนใหญ่สามารถเรียกใช้งานได้ผ่านเทรต IteratorRandom และ SliceRandom
การเลือกแบบถ่วงน้ำหนัก
การแจกแจง WeightedChoice ถูกแทนที่ด้วย WeightedIndex ซึ่งช่วยแก้ไขข้อจำกัดหลายประการและทำให้รูปแบบการทำงานมีความเป็นเจเนอริกมากยิ่งขึ้น
เพื่อความสะดวก เมธอด SliceRandom::choose_weighted (รวมถึงตัวแปรแบบมิวเทเบิล _mut) ช่วยให้สามารถนำผลการสุ่มจาก WeightedIndex ไปใช้กับสไลซ์ได้โดยตรง
ฟีเจอร์อื่นๆ
ชนิด SIMD
ปัจจุบัน Rand มีการรองรับขั้นพื้นฐานสำหรับการสุ่มชนิด SIMD โดยเปิดใช้งานผ่านฟีเจอร์แฟล็ก simd_support
ชนิด i128 / u128
เนื่องจากชนิดข้อมูลเหล่านี้ได้รับการรองรับอย่างเป็นทางการบนคอมไพเลอร์รุ่น stable แล้ว จึงสามารถใช้งานได้โดยอัตโนมัติ (เมื่อใช้เวอร์ชันของ Rust ที่ใหม่เพียงพอ) ส่วนฟีเจอร์แฟล็ก i128_support ยังคงคงไว้เพื่อป้องกันโค้ดเดิมพัง แต่จะไม่มีผลการทำงานใดๆ อีกต่อไป
การอัปเดตเป็น 0.7
นับตั้งแต่การเปิดตัวเวอร์ชัน 0.6 โครงการ rust-random ได้รับโลโก้ประจำโครงการและมีเครตใหม่อีกหนึ่งตัว ได้แก่ getrandom!
ดีเพนเดนซี
เครตในระบบนิเวศของ Rand ในตอนนี้ต้องการ rustc เวอร์ชัน 1.32.0 ขึ้นไป ซึ่งช่วยให้เราสามารถตัดไฟล์ build.rs ออกไปได้ทั้งหมด ส่งผลให้การคอมไพล์ทำงานได้รวดเร็วยิ่งขึ้น
โดยภาพรวมแล้ว เครต Rand มีจำนวนดีเพนเดนซีลดลง แม้ว่าจะมีการเพิ่มดีเพนเดนซีใหม่เข้ามาบ้างก็ตาม
Getrandom
ดังที่ได้กล่าวไปแล้ว เรามีเครตใหม่คือ getrandom ซึ่งมอบ API ขนาดเล็กกะทัดรัดสำหรับการเข้าถึงแหล่งเอนโทรปีสดใหม่โดยไม่ขึ้นกับแพลตฟอร์ม เครตนี้เข้ามาแทนที่การอิมพลีเมนต์เดิมใน OsRng ซึ่งปัจจุบันกลายเป็นเพียงตัวครอบ (wrapper) บางๆ เท่านั้น
ฟีเจอร์หลัก
เทรต FromEntropy ถูกถอดออกไปแล้ว แต่ไม่ต้องกังวล เพราะเมธอด from_entropy ยังคงช่วยให้คุณเริ่มต้นสร้าง RNG ได้อย่างง่ายดายเช่นเดิม โดยย้ายไปสังกัดอยู่ในเทรต SeedableRng (ทั้งนี้ต้องให้ rand_core เปิดใช้งานฟีเจอร์ std หรือ getrandom ไว้ด้วย):
extern crate rand_0_7 as rand;
use rand::{SeedableRng, rngs::StdRng};
let mut rng = StdRng::from_entropy();
เมธอด SeedableRng::from_rng ในตอนนี้ถือว่ามีเสถียรภาพด้านค่าผลลัพธ์ (value-stable): การอิมพลีเมนต์ต่างๆ ควรให้ผลลัพธ์ที่เหมือนกันข้ามแพลตฟอร์ม (portable)
ประเภทข้อมูล Error ของ rand_core และ rand ได้รับการออกแบบใหม่ครั้งใหญ่ ทำให้การเรียกใช้งานประเภทข้อมูลนี้โดยตรงอาจจำเป็นต้องมีการปรับแก้โค้ด
PRNG
กลุ่มนี้มีการเปลี่ยนแปลงน้อยกว่าในเวอร์ชันก่อนหน้า แต่มีจุดสำคัญที่น่าจับตามอง ได้แก่:
rand_chachaได้รับการเขียนขึ้นใหม่ทั้งหมด ส่งผลให้ประสิทธิภาพดีขึ้นอย่างมาก (โดยอาศัยคำสั่งชุด SIMD)StdRngและThreadRngเปลี่ยนมาใช้อัลกอริทึม ChaCha ซึ่งถือเป็นการเปลี่ยนแปลงที่ส่งผลต่อค่าผลลัพธ์ (value-breaking change) สำหรับStdRngSmallRngปัจจุบันถูกควบคุมด้วยฟีเจอร์แฟล็กsmall_rng- เครต
xoshiroเปลี่ยนชื่อเป็นrand_xoshiro rand_pcgเพิ่มประเภทPcg64เข้ามาให้พร้อมใช้งาน
การแจกแจง
สำหรับการแจกแจงที่นิยมใช้งานมากที่สุดอย่าง Standard และ Uniform นั้น ไม่มีการเปลี่ยนแปลงที่สำคัญ แต่สำหรับส่วนที่เหลือเกือบทั้งหมด…
- เราได้เพิ่มเครตใหม่คือ
rand_distrเพื่อรวบรวมการแจกแจงทั้งหมดไว้ด้วยกัน (รวมทั้ง re-export รายการที่ยังคงอยู่ในrand::distributionsด้วย) หากคุณเคยใช้งานrand::distributions::Normalในตอนนี้จะต้องเปลี่ยนมาเรียกใช้rand_distr::Normalแทน - คอนสตรักเตอร์ของการแจกแจงหลายตัวเปลี่ยนมาคืนค่าเป็น
Resultแทนที่จะทำให้โปรแกรม panic เมื่อเกิดข้อผิดพลาด - การแจกแจงหลายตัวเปลี่ยนมาเป็นแบบเจเนอริกตามประเภทพารามิเตอร์ (โดยส่วนใหญ่จะรองรับทั้ง
f32และf64) ช่วยให้ใช้งานร่วมกับโค้ดแบบเจเนอริกได้สะดวกขึ้น และช่วยลดขนาดหน่วยความจำของการแจกแจงแบบมีพารามิเตอร์ลงได้ ทั้งนี้ อัลกอริทึมที่ซับซ้อนกว่าจะยังคงประมวลผลภายในด้วยf64เสมอ Standardสามารถสุ่มค่าประเภทNonZeroU*ได้แล้ว
นอกจากนี้ เรายังได้เพิ่มการแจกแจงใหม่อีกหลายรายการ ได้แก่:
rand::distributions::weighted::alias_method::WeightedIndexrand_distr::Pertrand_distr::Triangularrand_distr::UnitBallrand_distr::UnitDiscrand_distr::UnitSphere(เดิมใช้ชื่อว่าrand::distributions::UnitSphereSurface)
ลำดับ
เพื่อเพิ่มความเข้ากันได้ข้ามแพลตฟอร์ม (portability) การสุ่มค่าประเภท usize ทั้งหมดจะเปลี่ยนไปสุ่มค่าเป็น u32 แทนเมื่อขอบเขตบนมีค่าน้อยกว่า u32::MAX ซึ่งหมายความว่าการอัปเกรดเป็น 0.7 จะส่งผลให้ลำดับค่าสุ่มเปลี่ยนไป (value-breaking change) สำหรับฟังก์ชันการทำงานในกลุ่ม seq แต่ผลลัพธ์หลังการอัปเกรดเป็น 0.7 จะมีความสอดคล้องตรงกันเสมอในทุกสถาปัตยกรรม CPU
การอัปเดตเป็น 0.8
เนื้อหาส่วนนี้เป็นคำแนะนำสำหรับการปรับย้ายโค้ดของคุณจาก
rand 0.7 และ rand_distr 0.2 ไปเป็น rand 0.8 และ rand_distr 0.3
ดีเพนเดนซี
เครตในระบบของ Rand ต้องการคอมไพเลอร์ rustc เวอร์ชัน 1.36.0 ขึ้นไป
ซึ่งช่วยให้เราตัดโค้ดส่วน unsafe ออกไปได้บางส่วน และลดความซับซ้อนของตรรกะเงื่อนไข cfg ภายใน
ดีเพนเดนซีของ getrandom ได้รับการปรับขึ้นเป็นเวอร์ชัน 0.2 แม้ว่าสิ่งนี้จะไม่กระทบต่อ API ของ Rand โดยตรง แต่คุณอาจได้รับผลกระทบจากการเปลี่ยนแปลงที่ส่งผลต่อความเข้ากันได้ (breaking changes) บางประการ แม้ว่าจะใช้งาน getrandom ผ่านดีเพนเดนซีแบบสืบทอดก็ตาม:
- คุณอาจจำเป็นต้องอัปเดตฟีเจอร์แฟล็กของ
getrandomที่คุณเปิดใช้งานอยู่ โดยมีฟีเจอร์ต่อไปนี้ให้ใช้งาน:"rdrand": เรียกใช้คำสั่ง RDRAND บนเป้าหมายno_stdสถาปัตยกรรมx86/x86_64"js": เรียกใช้ JavaScript API บนเป้าหมายwasm32-unknown-unknownโดยฟีเจอร์นี้เข้ามาแทนที่ฟีเจอร์stdwebและwasm-bindgenที่ถูกถอดออกไปแล้ว"custom": ช่วยให้คุณสามารถระบุฟังก์ชันอิมพลีเมนต์ที่กำหนดขึ้นเองได้
- ทาร์เก็ตแพลตฟอร์มที่ไม่ได้รับการรองรับจะไม่สามารถคอมไพล์ผ่านได้อีกต่อไป หากคุณต้องการพฤติกรรมแบบเดิม (ให้เกิด panic ในขณะรันไทม์แทนที่จะคอมไพล์ไม่ผ่าน) คุณสามารถเปิดใช้ฟีเจอร์
customเพื่อให้อิมพลีเมนต์ฟังก์ชันที่มีพฤติกรรม panic ได้ - Windows XP และ
stdwebไม่ได้รับการรองรับอีกต่อไปตั้งแต่getrandomเวอร์ชัน 0.2.1 หากคุณจำเป็นต้องรองรับแพลตฟอร์มเหล่านี้ สามารถตรึงเวอร์ชันได้โดยเพิ่มดีเพนเดนซีgetrandom = "=0.2.0" - Hermit, L4Re และ UEFI ไม่ได้รับการรองรับอย่างเป็นทางการแล้ว คุณสามารถเปิดใช้ฟีเจอร์
rdrandบนแพลตฟอร์มเหล่านี้แทนได้ - เวอร์ชันเคอร์เนล Linux ขั้นต่ำที่รองรับในปัจจุบันคือ 2.6.32
หากคุณเรียกใช้งาน API ของ getrandom โดยตรง จะมีการเปลี่ยนแปลงที่ส่งผลกระทบต่อโค้ดเดิมเพิ่มเติม โปรดดูรายละเอียดใน บันทึกการเปลี่ยนแปลง ของเครตดังกล่าว
Serde ถูกนำกลับมาเป็นดีเพนเดนซีทางเลือกอีกครั้ง (เปิดใช้ผ่านฟีเจอร์แฟล็ก serde1) โดยรองรับกับประเภทข้อมูลหลายตัว (เท่าที่เหมาะสม) ทั้งนี้ได้ยกเว้น StdRng และ SmallRng ไว้อย่างตั้งใจ เนื่องจากประเภทข้อมูลเหล่านี้ไม่สามารถพอร์ตผลลัพธ์ข้ามแพลตฟอร์มได้
ฟีเจอร์หลัก
ThreadRng
ThreadRng จะไม่อิมพลีเมนต์ Copy อีกต่อไป การเปลี่ยนแปลงนี้จำเป็นอย่างยิ่งเพื่อแก้ไขปัญหาหน่วยความจำแบบ use-after-free ที่อาจเกิดขึ้นใน destructor ของ thread-local storage โค้ดใดก็ตามที่เคยพึ่งพาการคัดลอก ThreadRng จะต้องปรับแก้มาส่งการอ้างอิงแบบมิวเทเบิล (mutable reference) แทน ตัวอย่างเช่น
use rand_0_7::distributions::{Distribution, Standard};
let rng = rand_0_7::thread_rng();
let a: u32 = Standard.sample_iter(rng).next().unwrap();
let b: u32 = Standard.sample_iter(rng).next().unwrap();
สามารถปรับแก้เป็นโค้ดด้านล่างนี้:
extern crate rand_0_8 as rand;
use rand::prelude::*;
use rand::distributions::Standard;
fn main () {
let mut rng = thread_rng();
let a: u32 = Standard.sample_iter(&mut rng).next().unwrap();
let b: u32 = Standard.sample_iter(&mut rng).next().unwrap();
}
gen_range
Rng::gen_range เปลี่ยนมารับพารามิเตอร์เป็นช่วง Range แทนการรับตัวเลข 2 ตัวแยกกัน ดังนั้นให้เปลี่ยนจาก gen_range(a, b) เป็น gen_range(a..b) เราขอแนะนำให้ใช้นิพจน์เรกิวลาร์ (regular expression) ต่อไปนี้ในการค้นหาและแทนที่ทั่วทั้งโปรเจกต์:
- แทนที่
gen_range\(([^,]*),\s*([^)]*)\) - ด้วย
gen_range(\1..\2) - หรือด้วย
gen_range($1..$2)(หากเครื่องมือของคุณไม่รองรับ backreference)
โปรแกรมแก้ไขโค้ดหรือ IDE ส่วนใหญ่รองรับการค้นหาและแทนที่ข้ามไฟล์ หรือคุณอาจใช้เครื่องมือเฉพาะทางอย่าง Regexxer ก็ได้
การเปลี่ยนแปลงนี้ยังส่งผลสืบเนื่องอีก 2-3 ประการ:
- รองรับช่วงแบบปิด เช่น
gen_range(1..=6)หรือgen_range('A'..='Z') - อาจจำเป็นต้องทำการดีเรเฟอเรนซ์ (dereference) พารามิเตอร์บางตัวอย่างชัดเจน
- ไม่รองรับประเภทข้อมูล SIMD อีกต่อไป (แต่ยังสามารถเรียกใช้ประเภท
Uniformได้โดยตรง)
fill
เทรต AsByteSliceMut ถูกแทนที่ด้วยเทรต Fill การเปลี่ยนแปลงนี้น่าจะส่งผลกระทบเฉพาะโค้ดที่มีการอิมพลีเมนต์ AsByteSliceMut ให้กับประเภทข้อมูลที่ผู้ใช้สร้างขึ้นเองเท่านั้น เนื่องจาก Rng::fill และ Rng::try_fill ยังคงรองรับประเภทข้อมูลเดิมทั้งหมดตามปกติ
นอกจากนี้ Fill ยังรองรับประเภทสไลซ์เพิ่มเติมที่ AsByteSliceMut เคยทำไม่ได้ ได้แก่ [bool], [char], [f32], [f64]
adapter
โมดูล rand::rngs::adapter ทั้งหมดถูกจำกัดการใช้งานไว้ภายใต้ฟีเจอร์ std เท่านั้น แม้ว่าในทางเทคนิคจะถือเป็นการเปลี่ยนแปลงที่ส่งผลกระทบต่อโค้ดเดิม แต่ในทางปฏิบัติน่าจะกระทบเฉพาะโค้ดแบบ no_std ที่เรียกใช้ ReseedingRng ซึ่งแทบไม่มีการใช้งานจริงทั่วไป
ตัวสร้าง
StdRng เปลี่ยนจากอัลกอริทึม ChaCha20 แบบ 20 รอบมาเป็น ChaCha12 เพื่อเพิ่มประสิทธิภาพในการทำงาน แม้จะเป็นการลดจำนวนรอบลง แต่อัลกอริทึมแบบ 12 รอบยังคงถือว่ามีความปลอดภัยสูงตามมาตรฐานวิทยาการรหัสลับ (ดู rand#932) ทั้งนี้ ถือเป็นการเปลี่ยนแปลงที่ทำให้ค่าผลลัพธ์เปลี่ยนไปสำหรับ StdRng
SmallRng เปลี่ยนมาใช้อัลกอริทึม Xoshiro128++ บนแพลตฟอร์ม 32 บิต และ Xoshiro256++ บนแพลตฟอร์ม 64 บิต ซึ่งช่วยลดความสัมพันธ์ของข้อมูลสุ่มที่สร้างจากซีดที่คล้ายกัน พร้อมทั้งช่วยเพิ่มประสิทธิภาพ การเปลี่ยนแปลงนี้ส่งผลให้ลำดับค่าสุ่มเปลี่ยนไปเช่นกัน
ในตอนนี้เราได้อิมพลีเมนต์ PartialEq และ Eq ให้กับ StdRng, SmallRng และ StepRng เป็นที่เรียบร้อย
การแจกแจง
มีการปรับเปลี่ยนย่อยหลายจุดในระบบการแจกแจงของ Rand:
- การแจกแจง
Uniformเพิ่มการรองรับประเภทข้อมูลcharทำให้สามารถเขียนโค้ดอย่างrng.gen_range('a'..='f')ได้โดยตรง - เพิ่มฟังก์ชัน
UniformSampler::sample_single_inclusive - การแจกแจง
Alphanumericเปลี่ยนมาสุ่มค่าเป็นไบต์ (u8) แทนที่จะเป็นcharซึ่งสะท้อนประเภทข้อมูลที่ประมวลผลภายในได้อย่างตรงไปตรงมามากขึ้น แต่โค้ดเดิมอาจต้องปรับแก้เพื่อแปลงจากu8ไปเป็นcharตัวอย่างเช่น ใน Rand 0.7 คุณอาจเขียนว่า:
ใน Rand 0.8 โค้ดดังกล่าวจะเทียบเท่ากับการเขียนดังนี้:use rand_0_7::{distributions::Alphanumeric, Rng}; let mut rng = rand_0_7::thread_rng(); let chars: String = std::iter::repeat(()) .map(|()| rng.sample(Alphanumeric)) .take(7) .collect();extern crate rand_0_8 as rand; use rand::{distributions::Alphanumeric, Rng}; fn main() { let mut rng = rand::thread_rng(); let chars: String = std::iter::repeat(()) .map(|()| rng.sample(Alphanumeric)) .map(char::from) .take(7) .collect(); println!("chars = \"{chars}\""); } - โครงสร้างทางเลือกของ
WeightedIndexที่ใช้วิธี Alias Method ถูกย้ายจากเครตrandไปอยู่ที่rand_distr::weighted_alias::WeightedAliasIndexแม้ว่าวิธี Alias Method จะเร็วกว่ามากสำหรับข้อมูลขนาดใหญ่ แต่ก็มีข้อจำกัดตรงที่การสร้างค่าเริ่มต้นค่อนข้างช้า จึงมีความหลากหลายในการใช้งานทั่วไปน้อยกว่า
ใน rand_distr v0.4 มีการเปลี่ยนแปลงเพิ่มเติม (นับตั้งแต่ v0.2):
- เพิ่ม
rand_distr::weighted_alias::WeightedAliasIndexเข้ามา (ย้ายมาจากเครตrand) - เพิ่มการแจกแจง
rand_distr::InverseGaussianและrand_distr::NormalInverseGaussian - รองรับการแจกแจงเรขาคณิต (
Geometric) และการแจกแจงไฮเพอร์จีโอเมตริก (Hypergeometric) - เปลี่ยนไปใช้อัลกอริทึมใหม่สำหรับการแจกแจงบีตา (
Beta) ซึ่งช่วยปรับปรุงทั้งประสิทธิภาพและความแม่นยำ ส่งผลให้ลำดับค่าสุ่มเปลี่ยนไป - การแจกแจงแบบปกติ (
Normal) และการแจกแจงแบบล็อกนอร์มอล (LogNormal) รองรับคอนสตรักเตอร์from_mean_cvและเมธอดสุ่มตัวอย่างfrom_zscore rand_distr::Dirichletเปลี่ยนโครงสร้างภายในมาใช้ boxed slice แทนVecดังนั้นค่าน้ำหนักจึงส่งเข้ามาเป็นสไลซ์แทนVecตัวอย่างเช่น โค้ดในrand_distr 0.2:
สามารถแทนที่ด้วยโค้ดในuse rand_distr_0_2::Dirichlet; Dirichlet::new(vec![1.0, 2.0, 3.0]).unwrap();rand_distr 0.3ดังนี้:use rand_distr_0_4::Dirichlet; Dirichlet::new(&[1.0, 2.0, 3.0]).unwrap();rand_distr::Poissonไม่รองรับการสุ่มค่าu64ออกมาโดยตรงอีกต่อไป โค้ดเดิมอาจต้องปรับแก้เพื่อแปลงประเภทข้อมูลจากf64อย่างชัดเจน- เทรต
Floatที่กำหนดขึ้นเองในrand_distrถูกแทนที่ด้วยnum_traits::Floatการอิมพลีเมนต์เทรตFloatให้กับประเภทข้อมูลที่ผู้ใช้สร้างขึ้นจะต้องย้ายตามไปด้วย และด้วยฟังก์ชันคณิตศาสตร์จากnum_traits::Floatทำให้rand_distrรองรับสภาพแวดล้อมno_stdได้แล้ว
นอกจากนี้ยังมีการปรับปรุงเล็กๆ น้อยๆ เพิ่มเติม:
- ปรับปรุงการจัดการความคลาดเคลื่อนจากการปัดเศษและค่า NaN สำหรับการแจกแจง
WeightedIndex - การแจกแจง
rand_distr::Expรองรับการกำหนดค่าพารามิเตอร์lambda = 0แล้ว
ลำดับ
รองรับการสุ่มตัวอย่างแบบถ่วงน้ำหนักโดยไม่ใส่คืนแล้ว โปรดดู
rand::seq::index::sample_weighted และ
SliceRandom::choose_multiple_weighted
มีการปรับปรุงที่ส่งผลให้ลำดับค่าสุ่มเปลี่ยนไป
สำหรับ IteratorRandom::choose เพื่อเพิ่มความแม่นยำและประสิทธิภาพ นอกจากนี้ยังได้เพิ่ม
IteratorRandom::choose_stable เป็นอีกหนึ่งทางเลือกที่ยอมแลกประสิทธิภาพบางส่วนเพื่อไม่ให้ผลลัพธ์ขึ้นอยู่กับการคาดคะเนขนาด (size hint) ของอิเทอเรเตอร์
ฟีเจอร์แฟล็ก
StdRng ถูกควบคุมผ่านฟีเจอร์แฟล็กใหม่ std_rng ซึ่งเปิดใช้งานไว้เป็นค่าเริ่มต้น
ฟีเจอร์ nightly จะไม่เปิดใช้งานฟีเจอร์ simd_support ให้โดยอัตโนมัติอีกต่อไป หากคุณเคยพึ่งพาฟีเจอร์นี้สำหรับการรองรับ SIMD คุณจะต้องเปิดใช้ฟีเจอร์ simd_support โดยตรง
การทดสอบ
มีการเพิ่มชุดทดสอบความเสถียรของค่าผลลัพธ์ให้กับการแจกแจงทั้งหมด (rand#786) ซึ่งช่วยบังคับใช้กฎของเราเกี่ยวกับการเปลี่ยนแปลงที่ทำให้ค่าผลลัพธ์เปลี่ยนไป (ดูหัวข้อ Reproducibility)
การอัปเดตเป็น 0.9
เนื้อหาส่วนนี้เป็นคำแนะนำสำหรับการปรับย้ายโค้ดของคุณจาก
rand 0.8 และ rand_distr 0.4 ไปเป็น rand 0.9 และ rand_distr 0.5
คู่มือการย้ายเวอร์ชันนี้จะเน้นไปที่การเปลี่ยนแปลงที่ส่งผลกระทบต่อความเข้ากันได้ของโค้ดเดิม (breaking changes) สำหรับรายการการเปลี่ยนแปลงทั้งหมด สามารถตรวจสอบได้จากบันทึกการเปลี่ยนแปลงที่เกี่ยวข้อง:
ฟังก์ชันและเมธอดที่เปลี่ยนชื่อ
ใน Rust edition 2024 คำว่า gen ได้กลายเป็นคีย์เวิร์ดสงวน ทำให้การเรียกใช้ไวยากรณ์ดิบอย่าง r#gen() ดูไม่สะดวก จึงได้มีการเปลี่ยนชื่อเมธอดบางตัวใน rand::Rng:
gen->randomgen_range->random_rangegen_bool->random_boolgen_ratio->random_ratio
นอกจากนี้ rand::thread_rng() ได้รับการเปลี่ยนชื่อเป็น rng() ที่สั้นกระชับและเข้าใจง่ายขึ้น
ทั้งนี้ชื่อเดิมทั้งหมดยังคงมีอยู่ให้เรียกใช้ได้ แต่ถูกทำเครื่องหมายเลิกใช้งาน (deprecated) แล้ว
ความปลอดภัย
ใน #1514 ได้มีข้อสรุปที่ชัดเจนว่า “rand ไม่ใช่ไลบรารีสำหรับการเข้ารหัส” การเปลี่ยนแปลงนี้ชี้แจงให้เห็นว่า:
- ไลบรารี Rand เป็นโครงการพัฒนาโดยชุมชนที่ไม่มีการรับประกันผูกพันทางกฎหมายใดๆ ทั้งสิ้น
- ไลบรารี Rand มอบฟังก์ชันสำหรับสร้างตัวเลขสุ่มที่คาดเดาไม่ได้ แต่ไม่ได้เตรียมฟังก์ชันการทำงานด้านวิทยาการรหัสลับระดับสูงใดๆ ไว้ให้
rand::rngs::OsRngเป็นตัวสร้างเลขสุ่มแบบไร้สถานะ จึงไม่มีสถานะภายในที่จะรั่วไหล และไม่จำเป็นต้องกำหนดซีดหรือกำหนดซีดใหม่rand::rngs::ThreadRngเป็นตัวสร้างเลขสุ่มที่กำหนดซีดอัตโนมัติและมีการกำหนดซีดใหม่เป็นระยะโดยใช้อัลกอริทึมสุ่มเทียมที่มีความแข็งแกร่งเชิงรหัสลับ แต่ไม่มีกลไกป้องกันสถานะในหน่วยความจำ โดยเฉพาะอย่างยิ่งไม่มีการล้างหน่วยความจำเป็นศูนย์โดยอัตโนมัติเมื่อสิ้นสุดการทำงาน ยิ่งไปกว่านั้น การออกแบบของมันเกิดจากการประนีประนอม เพื่อให้เป็น “ตัวสร้างที่เร็วและปลอดภัยอย่างสมเหตุสมผล”
นอกจากนี้ กลไกป้องกันกระบวนการ fork ที่เคยมีอยู่อย่างจำกัดสำหรับ ReseedingRng และ ThreadRng ได้ถูกถอดออกไปใน #1379 โดยแนะนำให้การกำหนดซีดใหม่เป็นความรับผิดชอบของโค้ดส่วนที่สั่ง fork กระบวนการโดยตรง (ดูรายละเอียดเพิ่มเติมได้ในเอกสารของ ThreadRng):
fn do_fork() {
let pid = unsafe { libc::fork() };
if pid == 0 {
// Reseed ThreadRng in child processes:
rand::rng().reseed();
}
}
ดีเพนเดนซี
เครตในระบบของ Rand ต้องการ rustc เวอร์ชัน 1.63.0 ขึ้นไป
ดีเพนเดนซีของ getrandom ได้รับการปรับขึ้นเป็นเวอร์ชัน 0.3
ซึ่งใน เวอร์ชันนี้
มีการเปลี่ยนแปลงที่กระทบความเข้ากันได้ของบางแพลตฟอร์ม (โดยเฉพาะ WASM ที่ได้รับผลกระทบเป็นพิเศษ)
ฟีเจอร์
ฟีเจอร์แฟล็ก:
serde1ถูกเปลี่ยนชื่อเป็นserdegetrandomถูกเปลี่ยนชื่อเป็นos_rngthread_rngเป็นฟีเจอร์ใหม่ (เปิดใช้เป็นค่าเริ่มต้น) ซึ่งเป็นฟีเจอร์ที่rng()ต้องการ (ThreadRng)small_rngตอนนี้เปิดใช้เป็นค่าเริ่มต้นrand_chachaไม่ใช่ฟีเจอร์ (โดยนัย) อีกต่อไป; ให้ใช้std_rngแทน
เทรตหลัก
ใน #1424 ได้เพิ่มเทรตใหม่คือ TryRngCore เข้ามาใน rand_core:
pub trait TryRngCore {
/// The type returned in the event of a RNG error.
type Error: fmt::Debug + fmt::Display;
/// Return the next random `u32`.
fn try_next_u32(&mut self) -> Result<u32, Self::Error>;
/// Return the next random `u64`.
fn try_next_u64(&mut self) -> Result<u64, Self::Error>;
/// Fill `dest` entirely with random data.
fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Self::Error>;
// [Provided methods hidden]
}
เทรตนี้เป็นแบบเจเนอริกที่รองรับทั้ง RNG ที่อาจเกิดข้อผิดพลาดได้และไม่เกิดข้อผิดพลาด (กลุ่มหลังจะใช้ประเภทข้อผิดพลาด Error เป็น Infallible) ในขณะที่เทรต RngCore ในปัจจุบันจะใช้เป็นตัวแทนเฉพาะ RNG ที่ไม่เกิดข้อผิดพลาดเท่านั้น
เทรต CryptoRng ตอนนี้เป็นเทรตย่อยของ RngCore มีเทรตที่เข้าคู่กันชื่อ TryCryptoRng ไว้ใช้ทำเครื่องหมายผู้ที่ implement TryRngCore ซึ่งแข็งแกร่งเชิงรหัสลับ
การซีด RNG
เทรต SeedableRng มีการปรับเปลี่ยนบางประการ:
type Seedเพิ่ม trait bounds ได้แก่CloneและAsRef<[u8]>fn from_rngเปลี่ยนชื่อเป็นtry_from_rngพร้อมกับเพิ่มตัวแปรแบบไม่เกิดข้อผิดพลาดเป็นfrom_rngตัวใหม่fn from_entropyเปลี่ยนชื่อเป็นfrom_os_rngควบคู่ไปกับตัวแปรแบบอาจเกิดข้อผิดพลาดตัวใหม่คือfn try_from_os_rng
ตัวสร้าง
ThreadRng ตอนนี้เข้าถึงผ่าน rng() (เดิมคือ thread_rng())
ลำดับ
เทรตเดิม SliceRandom ถูกแยกออกเป็นสามเทรต: IndexedRandom, IndexedMutRandom และ SliceRandom สิ่งนี้ทำให้ฟังก์ชัน choose ใช้ได้กับคอนเทนเนอร์คล้าย Vec ที่เก็บข้อมูลไม่ต่อเนื่องได้ด้วย แม้ว่าฟังก์ชัน shuffle จะยังจำกัดอยู่แค่สไลซ์
การแจกแจง
โมดูล rand::distributions ถูกเปลี่ยนชื่อเป็น rand::distr เพื่อความกระชับและให้สอดคล้องกับ rand_distr
รายการหลายอย่างใน distr ก็ถูกเปลี่ยนชื่อหรือย้ายเช่นกัน:
- Struct
Standard->StandardUniform - Struct
Slice→slice::Choose - Struct
EmptySlice→slice::Empty - Trait
DistString→SampleString - Struct
DistIter→Iter - Struct
DistMap→Map - Struct
WeightedIndex→weighted::WeightedIndex - Enum
WeightedError→weighted::Error
รายการเพิ่มเติมบางอย่างถูกเปลี่ยนชื่อใน rand_distr:
- Struct
weighted_alias::WeightedAliasIndex→weighted::WeightedAliasIndex - Trait
weighted_alias::AliasableWeight→weighted::AliasableWeight
การแจกแจง StandardUniform ไม่รองรับการสุ่มชนิด Option<T> อีกต่อไป (สำหรับ T ใดๆ)
ชนิด isize และ usize ไม่ได้รับการรองรับโดย Fill, WeightedAliasIndex หรือ StandardUniform อีกต่อไป isize ก็ไม่ได้รับการรองรับโดย Uniform เช่นกัน ส่วน usize ยังได้รับการรองรับโดย Uniform ผ่าน UniformUsize และตอนนี้ให้ผลลัพธ์ที่พอร์ตได้ข้ามแพลตฟอร์ม 32 และ 64 บิต
คอนสตรัคเตอร์ fn new, fn new_inclusive ของ Uniform และ UniformSampler ตอนนี้คืนค่าเป็น Result แทนการ panic เมื่ออินพุตไม่ถูกต้อง นอกจากนี้ Uniform ยังรองรับ TryFrom (แทน From) สำหรับชนิดช่วง
ฟีเจอร์ nightly
SIMD
การรองรับ SIMD ตอนนี้มุ่งเป้าไปที่ std::simd
ความสามารถในการทำซ้ำ
ดูไฟล์ CHANGELOG.md สำหรับรายละเอียดของการเปลี่ยนแปลงที่ทำให้ความสามารถในการทำซ้ำเสียไป ซึ่งกระทบ rand และ rand_distr
การอัปเดตเป็น 0.10
ต่อไปนี้เป็นคำแนะนำสำหรับการพอร์ตโค้ดของคุณจาก
rand 0.9 ไปเป็น rand 0.10
ต่อไปนี้เป็นคู่มือการย้ายเวอร์ชันที่เน้นการเปลี่ยนแปลงซึ่งอาจทำให้โค้ดเดิมใช้ไม่ได้ สำหรับรายการการเปลี่ยนแปลงทั้งหมด ดูบันทึกการเปลี่ยนแปลงที่เกี่ยวข้อง:
เทรต [Try]Rng
เทรต RngCore, TryRngCore ใน rand_core ได้รับการเปลี่ยนชื่อเป็น Rng, TryRng และเทรต Rng ใน rand ได้รับการเปลี่ยนชื่อเป็น RngExt ตามลำดับ
ความสัมพันธ์ระหว่างเทรตเหล่านี้ได้รับการปรับเปลี่ยนเช่นกัน ในอดีตทุก R: RngCore จะอิมพลีเมนต์ TryRngCore แต่นอกเหนือจากนั้นทั้งสองเทรตถือเป็นอิสระจากกัน แต่ในปัจจุบัน Rng: TryRng<Error = Infallible> และทุก R: TryRng<Error = Infallible> + ?Sized จะอิมพลีเมนต์ Rng
นอกจากนี้ แม้ว่าก่อนหน้านี้เราจะเคยพยายามอิมพลีเมนต์ R: RngCore ให้กับทุก R: DerefMut where R::Target: RngCore แต่ก็ไม่สามารถทำได้เนื่องจากเกิดข้อผิดพลาดเรื่องเทรตขัดแย้งกัน (conflicting-trait errors ซึ่งต้องอาศัยฟีเจอร์ specialization หรือ negative trait bounds จึงจะแก้ได้) ในเวอร์ชันนี้เราได้อิมพลีเมนต์ R: TryRng ให้กับทุก R: DerefMut where R::Target: TryRng ส่งผลให้มี R: Rng สำหรับทุก R: DerefMut where R::Target: Rng ไปด้วยโดยปริยาย
ผลกระทบที่สำคัญที่สุดคือ PRNG ที่ทำงานโดยไม่มีข้อผิดพลาด (infallible) จะต้องเปลี่ยนมาอิมพลีเมนต์ TryRng ที่กำหนด Error = Infallible แทนที่จะอิมพลีเมนต์ RngCore
ผู้ใช้งานเครต rand บ่อยครั้งจะต้องอิมพอร์ต rand::RngExt และอาจต้องปรับย้าย trait bound จาก R: RngCore ไปเป็น R: Rng (โปรดทราบว่าในจุดเดิมที่เคยใช้ R: Rng ขอแนะนำให้คง R: Rng ไว้ตามเดิม แม้ว่าตัวแทนโดยตรงจะเป็น R: RngExt ก็ตาม ทั้งนี้ bound ทั้งสองแบบมีผลเทียบเท่ากันสำหรับ R: Sized)
SysRng
rand_core::OsRng ถูกแทนที่ด้วย getrandom::SysRng (และ re-export ไว้ใน rand::rngs::SysRng ด้วยเช่นกัน)
ด้วยเหตุนี้ เมธอด SeedableRng::from_os_rng และ try_from_os_rng จึงถูกถอดออกไป โดยมี rand::make_rng() เข้ามาทำหน้าที่ทดแทนในบางกรณี หรือมิฉะนั้นคุณสามารถเรียกใช้งาน SomeRng::try_from_rng(&mut SysRng).unwrap() แทนได้
PRNG
StdRng เปลี่ยนมาให้บริการผ่านเครต chacha20 แทน rand_chacha แม้ว่าในปัจจุบันทั้งสองแพ็กเกจจะยังคงได้รับการบำรุงรักษาอยู่ แต่ rand_chacha มีแนวโน้มที่จะหยุดการพัฒนาในอนาคต สำหรับประเภทข้อมูล ChaCha{8,12,20}Rng เป็นตัวแทนทดแทนโดยตรงของประเภทข้อมูลชื่อเดียวกันใน rand_chacha โดยยังคงรักษาความสามารถในการผลิตซ้ำของผลลัพธ์และมี API ที่ใกล้เคียงกัน
โปรดทราบว่าโมดูล rand::rngs ในปัจจุบันได้เตรียม PRNG ที่มีชื่อระบุชัดเจนไว้หลายตัว ช่วยให้เขียนโค้ดที่ผลิตซ้ำผลลัพธ์ได้ง่ายขึ้น ได้แก่ ChaCha{8,12,20}Rng และ Xoshiro{128,256}PlusPlus
เครต PRNG อื่นๆ ได้รับการอัปเดตโดยมีการปรับแก้เพียงเล็กน้อย (แต่อาจมีการเปลี่ยนแปลงในระยะยาว ดู rngs#98) และมีเครตใหม่เพิ่มเข้ามาหนึ่งรายการ ได้แก่ rand_sfc
การรองรับ Clone และการซีเรียลไลซ์
StdRng และ ChaCha{8,12,20}Rng จะไม่อิมพลีเมนต์ Clone หรือเทรตต่างๆ ของ serde อีกต่อไป นี่เป็นการตัดสินใจโดยเจตนาเพื่อป้องกันการทำสำเนาคีย์สตรีมโดยไม่ตั้งใจ หรือการบันทึกสถานะออกไปยังพื้นที่จัดเก็บภายนอก ทั้งนี้ คุณยังคงสามารถโคลนหรือทำ serialization ให้กับ RNG เหล่านี้ได้ โดยสร้างอินสแตนซ์ใหม่ขึ้นมาด้วยคีย์เดิม แล้วกำหนดค่าสตรีม (stream ถ้ามี) และตำแหน่งเวิร์ด (word position) เช่น:
#![allow(unused)]
fn main() {
use rand::{rngs::ChaCha8Rng, Rng, SeedableRng};
let mut rng1: ChaCha8Rng = rand::make_rng();
let _ = rng1.next_u64();
let mut rng2 = ChaCha8Rng::from_seed(rng1.get_seed());
rng2.set_stream(rng1.get_stream());
rng2.set_word_pos(rng1.get_word_pos());
assert_eq!(rng1.next_u64(), rng2.next_u64());
}
การเปลี่ยนแปลงอื่นๆ
TryRngCore::read_adapter ถูกแทนที่ด้วย rand::RngReader
ReseedingRng
ReseedingRng ถูกถอดออกไปโดยไม่มีตัวแทน เนื่องจากเท่าที่เราได้พิจารณา ThreadRng เป็นกรณีการใช้งานสำคัญเพียงกรณีเดียว เราจึงตัดสินใจย้ายฟังก์ชันการทำงานดังกล่าวเข้าไปไว้ภายใน ThreadRng เป็นรายละเอียดเชิงการอิมพลีเมนต์แทน
ดีเพนเดนซี
เครตในระบบของ Rand ต้องการ rustc เวอร์ชัน 1.85.0 ขึ้นไป
ดีเพนเดนซีของ getrandom ได้รับการปรับขึ้นเป็นเวอร์ชัน 0.4 ดูรายละเอียดได้ใน บันทึกการเปลี่ยนแปลงของ getrandom
ฟีเจอร์
ฟีเจอร์แฟล็กของ Cargo มีการเปลี่ยนแปลงดังนี้:
os_rngเปลี่ยนชื่อเป็นsys_rngsmall_rngถูกถอดออก เนื่องจากฟังก์ชันการทำงานของมันพร้อมให้เรียกใช้ได้เสมออยู่แล้วchachaเป็นแฟล็กใหม่ สำหรับเปิดใช้งานrand::rngs::ChaCha{8,12,20}Rng
ความสามารถในการทำซ้ำ
เท่าที่เราทราบ ไม่มีการเปลี่ยนแปลงที่ส่งผลต่อค่าผลลัพธ์ใน rand เวอร์ชัน 0.10
การมีส่วนร่วม
ขอขอบคุณสำหรับความสนใจในการร่วมพัฒนาโครงการ Rand!
เรายินดีต้อนรับผู้มีส่วนร่วมทุกคน แต่โปรดเข้าใจว่าทีมงานของเรามีทรัพยากรและเวลาจำกัด มักมีงานส่วนอื่นในโครงการที่กำลังดำเนินอยู่ และแม้กระทั่งการพิจารณารับ Pull Request (PR) ที่สมบูรณ์แล้วก็ยังต้องใช้เวลาค่อนข้างมาก (ทั้งการรีวิวโค้ดและการดูแลรักษาต่อเนื่องในระยะยาว) ดังนั้นเราอาจใช้เวลาพอสมควรในการตอบกลับคุณ
การมีส่วนร่วมทุกประเภท
-
ขอบเขต: โปรดพิจารณาว่า “ปัญหา” ที่คุณพบนั้นอยู่ในขอบเขตเดิมของโครงการหรือเป็นการขอเพิ่มความสามารถใหม่ ทั้งนี้ การมองว่าสิ่งใดเป็น ข้อบกพร่อง หรือไม่นั้นอาจขึ้นอยู่กับมุมมองของแต่ละบุคคล เราอาจจำเป็นต้องปฏิเสธข้อเสนอเพื่อหลีกเลี่ยงภาระงานที่เกินกำลัง
หากคุณต้องการขยายขอบเขตของโครงการ (เช่น การรองรับแพลตฟอร์มใหม่ หรือการเพิ่มชุดทดสอบบน CI) โปรดเตรียมพร้อมที่จะช่วยดูแลรักษาในส่วนนั้นอย่างต่อเนื่องในระยะยาว
-
การแก้ไขปัญหา: หากเป็นปัญหาที่คุณสามารถแก้ไขได้ด้วยตนเองได้ง่าย โปรดพิจารณาเปิดเป็น Pull Request แทนการเปิด Issue แต่หากเป็นปัญหาที่แก้ไขได้ยาก หรือดูเหมือนอาจขัดแย้งกับงานส่วนอื่นที่กำลังดำเนินการอยู่ ก็อย่าลังเลที่จะเปิดเป็น Issue เข้ามา
พูลรีเควสต์
-
บันทึกการเปลี่ยนแปลง: ยกเว้นในกรณีที่เป็นการเปลี่ยนแปลงเพียงเล็กน้อย โปรดเพิ่มบันทึกไว้ใน
CHANGELOG.mdของแต่ละเครตที่ได้รับผลกระทบ โดยใส่ไว้ใต้หัวข้อ[Unreleased]ด้านบนสุด (เพิ่มหัวข้อนี้หากยังไม่มี) พร้อมระบุหมายเลข PR ด้วย (ซึ่งหมายความว่าต้องเพิ่มบันทึกนี้ หลังจาก เปิด PR แล้ว) -
คอมมิต: หากเป็นการเปลี่ยนแปลงขนาดใหญ่ โปรดพิจารณาแบ่งออกเป็นหลายๆ คอมมิตย่อย โดยพยายามให้แต่ละคอมมิตสามารถคอมไพล์ผ่านได้เสมอ การทำ rebase คอมมิตอาจเป็นประโยชน์เมื่อมีการปรับปรุงโค้ดอย่างมีนัยสำคัญ
-
เอกสารประกอบ: เรากำหนดให้ทุกไอเท็มที่เป็นสาธารณะ (public items) ต้องมีเอกสารกำกับอย่างครบถ้วน พร้อมตัวอย่างโค้ดสั้นๆ ในจุดที่เหมาะสม
-
ความสามารถในการดูแลรักษา: สิ่งสำคัญยิ่งสำหรับเราคือ โค้ดต้องอ่านและเข้าใจง่าย ไม่ซับซ้อนเกินไปจนตรวจสอบความถูกต้องได้ยาก
-
ประสิทธิภาพ: เรามุ่งเน้นประสิทธิภาพที่ดีเสมอ และในบางครั้งก็ยอมลงแรงเพิ่มอย่างมากเพื่อให้ได้ประสิทธิภาพสูงสุด อย่างไรก็ตาม เราต้องคำนึงถึงความสามารถในการดูแลรักษาโค้ดควบคู่กันไปด้วย โดยต้องชั่งน้ำหนักว่าประสิทธิภาพที่เพิ่มขึ้นเพียงเล็กน้อยคุ้มค่ากับความซับซ้อนของโค้ดที่เพิ่มขึ้นหรือไม่ ใช้การวัดประสิทธิภาพ
-
รูปแบบโค้ด: จัดรูปแบบโค้ดให้เรียบร้อยสวยงาม โดยทั่วไป ควรจำกัดความยาวแต่ละบรรทัดไว้ที่ไม่เกิน 80 ตัวอักษร
-
Unsafe: ใช้เฉพาะเมื่อมีความจำเป็นจริงๆ เท่านั้น และหลีกเลี่ยงหากมีทางเลือกอื่นที่ดีกว่า โปรดตรวจสอบให้แน่ใจว่าโค้ด
unsafeนั้นสามารถตรวจสอบความถูกต้องได้อย่างชัดเจน -
สัญญาอนุญาตและการระบุที่มา: โครงการนี้เผยแพร่ภายใต้สัญญาอนุญาตแบบเสรีตามเงื่อนไขของ MIT และ Apache Public Licence v2 เราถือว่าการมีส่วนร่วมทั้งหมดอยู่ภายใต้ข้อกำหนดของสัญญาอนุญาตเหล่านี้ ทั้งนี้ ลิขสิทธิ์ยังคงเป็นของผู้มีส่วนร่วมแต่ละท่าน
ผลงานทั้งหมดจะระบุที่มาว่า “The Rand Project Developers” ซึ่งไม่ใช่ entity ทางกฎหมายอย่างเป็นทางการ แต่หมายถึงกลุ่มผู้มีส่วนร่วมทั้งหมดในโครงการนี้ ดูรายละเอียดเพิ่มเติมได้ในไฟล์
COPYRIGHT -
ขอบคุณ!
เอกสาร
สไตล์
เอกสารทั้งหมดจัดทำเป็นภาษาอังกฤษ โดยไม่ได้จำกัดว่าจะต้องใช้สำเนียงหรือรูปแบบภาษาของภูมิภาคใดเป็นพิเศษ
เอกสารควรจะเข้าถึงและเข้าใจได้ง่ายสำหรับผู้อ่านทุกระดับ ทั้งชาว Rustacean ผู้ช่ำชองและผู้ที่เพิ่งเริ่มต้นใช้งาน รวมถึงผู้ที่มีความเชี่ยวชาญด้านการสร้างแบบจำลองทางสถิติหรือวิทยาการรหัสลับ ตลอดจนผู้ที่เพิ่งเริ่มศึกษาศาสตร์เหล่านี้ เนื่องจากเป็นเรื่องยากที่จะเขียนเอกสารฉบับเดียวให้ตอบโจทย์ผู้อ่านทุกคนได้อย่างสมบูรณ์แบบ เราจึงมุ่งเน้นการเขียนเอกสารเชิงเทคนิคที่กระชับ พร้อมทั้งใส่ลิงก์อ้างอิงไปยังบทความหรือแหล่งข้อมูลเพิ่มเติมสำหรับกลุ่มผู้อ่านเฉพาะทาง
เอกสาร API
เครตของ Rand
ขอแนะนำให้ใช้คอมไพเลอร์ Rust เวอร์ชัน nightly เพื่อให้เครื่องมือสามารถประมวลผลลิงก์ต่างๆ ได้อย่างถูกต้อง
หากต้องการ build เอกสาร API ของทุกเครตในคลังเก็บโค้ด rust-random/rand ให้รันคำสั่ง:
# Optionally, enable some unstable but widely used doc features:
export RUSTDOCFLAGS="--cfg docsrs -Zunstable-options --generate-link-to-definition"
# Build doc for all crates in the workspace:
cargo doc --workspace --no-deps --all-features --open
(หรือตรวจสอบไฟล์ Cargo.toml ใต้หัวข้อ [package.metadata.docs.rs] ซึ่งอาจมีการระบุการตั้งค่าเฉพาะของ workspace หรือแต่ละเครตไว้)
บนระบบปฏิบัติการ Linux คุณสามารถตั้งค่าให้ rebuild เอกสารใหม่อัตโนมัติหลังการแก้ไขทุกครั้งได้ง่ายๆ:
while inotifywait -r -e close_write src/ rand_*/; do cargo doc; done
หลังจากแก้ไขเอกสาร API แล้ว ขอแนะนำให้ทดสอบโค้ดตัวอย่างในเอกสารด้วยคำสั่ง:
cargo test --doc
เครต Getrandom
คลังเก็บโค้ด rust-random/getrandom
มีเพียงเครตเดียว ดังนั้นการสั่ง cargo doc เพียงอย่างเดียวก็เพียงพอแล้ว
เอกสารเสริม
ไฟล์ README
ไฟล์ README จะประกอบด้วยบทนำสั้นๆ เกี่ยวกับเครต ป้าย shields ลิงก์ที่เป็นประโยชน์ เอกสารอธิบายฟีเจอร์แฟล็ก ข้อมูลสัญญาอนุญาต ตลอดจนตัวอย่างการใช้งาน
โดยทั่วไปแล้วไฟล์เหล่านี้จะไม่มีการทดสอบต่อเนื่อง
อย่างไรก็ตาม ในจุดที่มีตัวอย่างโค้ดรวมอยู่ด้วย (ปัจจุบันมีเฉพาะในเครต rand_jitter) เราจะเปิดใช้งานการทดสอบอย่างต่อเนื่องผ่าน doc_comment (ดูรายละเอียดได้ที่
lib.rs:62 เป็นต้นไป)
ไฟล์ CHANGELOG
รูปแบบของบันทึกการเปลี่ยนแปลงจะอ้างอิงตามรูปแบบ Keep a Changelog
การเปลี่ยนแปลงสำคัญทั้งหมดที่ถูก merge เข้ามานับตั้งแต่การเปิดตัวเวอร์ชันล่าสุด จะต้องถูกระบุไว้ภายใต้หัวข้อ [Unreleased] ที่ด้านบนสุดของบันทึก
หนังสือเล่มนี้
ซอร์สโค้ดของหนังสือเล่มนี้อยู่ในคลัง rust-random/book หนังสือเล่มนี้ถูกสร้างด้วย mdbook ซึ่งช่วยให้การ build และทดสอบเป็นเรื่องง่าย:
cargo install mdbook --version "^0.4"
mdbook build --open
mdbook test
# To automatically rebuild after any changes:
mdbook watch
โปรดทราบว่าลิงก์ในหนังสือเป็นแบบสัมพัทธ์และออกแบบให้ทำงานใน หนังสือที่เผยแพร่แล้ว หากคุณ build หนังสือในเครื่อง คุณอาจต้องการสร้าง symbolic link ชี้ไปยังเอกสาร API ที่คุณ build ไว้ในเครื่องดังนี้:
ln -s ../rand/target/doc rand
ขอบเขต
เมื่อเวลาผ่านไป ขอบเขตของโครงการ Rand ได้เติบโตขึ้นอย่างต่อเนื่อง และได้ปรับเปลี่ยนโครงสร้างจากเครตแบบโมโนลิธิก (monolithic) ขนาดใหญ่เพียงตัวเดียว มาเป็นการใช้เครต “หลัก” ควบคู่ไปกับเครตเฉพาะทางอีกหลายตัว ดังนั้น สำหรับฟังก์ชันการทำงานใหม่ๆ จึงจำเป็นต้องพิจารณาอย่างรอบคอบว่าฟังก์ชันนั้นเหมาะสมที่จะรวมเข้าไว้ในโครงการ Rand หรือไม่ และควรอยู่ ณ ตำแหน่งใด
การแยกเป็นเครตขนาดเล็กที่มุ่งเน้นเฉพาะเรื่องอาจมีประโยชน์ในบางกรณี แต่เราไม่ได้มีเป้าหมายที่จะซอยฟังก์ชันการทำงานออกเป็นเครตย่อยๆ ให้มากที่สุดโดยไม่จำเป็น ด้วยเหตุนี้ เหตุผลอันสมควรในการแยกฟีเจอร์ออกเป็นเครตเฉพาะจึงมีดังต่อไปนี้:
- เพื่อจัดโครงสร้างลำดับชั้นของดีเพนเดนซีให้ชัดเจนและเป็นระเบียบ (
rand_core) - เพื่อเปิดให้สามารถนำฟีเจอร์ดังกล่าวไปใช้งานแบบแยกเดี่ยวได้โดยสะดวก (เช่น
getrandom) - เพื่อแยกฟีเจอร์ที่มีอัตราการใช้งานต่ำแต่มีขนาดโค้ดค่อนข้างมาก ออกจากเครตหลักที่มีผู้ใช้งานอย่างแพร่หลาย (เช่น
rand_jitterและrand_distrซึ่งแยกฟังก์ชันการทำงานออกมาจากrand) - เพื่อมอบทางเลือกในการใช้งาน โดยไม่สร้างภาระให้ผู้ใช้ทุกคนต้องดาวน์โหลดโค้ดที่ไม่ได้ใช้งาน และในขณะเดียวกันก็ไม่สร้างเครตใหม่พร่ำเพรื่อจนเกินไป (เช่น เครตในกลุ่มตระกูล RNG อย่าง
rand_xoshiroและrand_isaac)
เทรต พื้นฐาน และ UI
อินเทอร์เฟซหลักสำหรับผู้ใช้งานทั่วไปของโครงการ Rand ยังคงเป็นเครตศูนย์กลางอย่าง rand โดยเป้าหมายของเครตนี้คือ:
- ความง่ายและสะดวกในการใช้งาน
- รวบรวมฟังก์ชันการทำงานที่ใช้บ่อยไว้ในที่เดียว
- เปิดให้สามารถเรียกใช้แหล่งความสุ่มเพิ่มเติมและตัวสุ่มจากการแจกแจงแบบอื่นๆ ได้
และเพื่อความเป็นโมดูลาร์ที่ดีขึ้น เทรตหลักพื้นฐานทั้งหมดจึงถูกแยกย้ายไปอยู่ในเครต rand_core โดยมีเป้าหมายคือ:
- จัดเตรียมเทรตหลักพื้นฐานโดยพึ่งพาดีเพนเดนซีน้อยที่สุด
- มอบเครื่องมือทั่วไปที่จำเป็นสำหรับการอิมพลีเมนต์แหล่งกำเนิดความสุ่มรูปแบบต่างๆ
แหล่งความสุ่มภายนอก
แหล่งความสุ่มภายนอกหลัก (และมักเป็นเพียงแหล่งเดียว) คือระบบปฏิบัติการ ซึ่งเชื่อมต่อผ่านเครต getrandom นอกจากนี้ เครตดังกล่าวยังรองรับการเรียกใช้คำสั่ง RDRAND บนเป้าหมาย no_std บางกลุ่มอีกด้วย
การรองรับเป้าหมาย no_std อื่นๆ เคยมีการหารือกันอยู่บ้าง แต่แทบยังไม่มีการพัฒนาอิมพลีเมนต์ขึ้นมาใช้งานจริง โปรดดูรายละเอียดใน
getrandom#4
สำหรับเครต rand_jitter นั้นมอบการอิมพลีเมนต์ตัวเก็บเกี่ยวเอนโทรปีแบบ
CPU Jitter ซึ่งยังคงคงไว้ใน Rand ด้วยเหตุผลทางประวัติศาสตร์เท่านั้น
ตัวสร้างเลขสุ่มเทียม
ไลบรารี Rand ได้รวบรวมตัวสร้างเลขสุ่มเทียมไว้หลายตัว ด้วยเหตุผลดังต่อไปนี้:
- เพื่อใช้อิมพลีเมนต์ตัวสร้างหลักอย่าง
StdRngและSmallRng - เพื่อจัดเตรียมตัวสร้างทางเลือกที่มีคุณภาพสูงไว้ให้ใช้งาน
- เพื่อรองรับการใช้งานเดิมในอดีต
ตัวสร้างเหล่านี้ได้รับการอิมพลีเมนต์อยู่ภายในเครตระดับ “ตระกูล” เช่น chacha20, rand_pcg,
rand_xoshiro
เราได้รับคำขออยู่บ่อยครั้งให้นำอัลกอริทึมใหม่ๆ เข้ามาบรรจุไว้ในไลบรารี ซึ่งในการประเมินคำขอเหล่านั้น เราจำเป็นต้องพิจารณาปัจจัยหลายประการ:
- วัตถุประสงค์ในการนำเข้ามาไว้ใน Rand
- PRNG ดังกล่าวมีความมั่นคงปลอดภัยเชิงรหัสลับหรือไม่ และหากอ้างว่าปลอดภัย ข้ออ้างเหล่านั้นมีความน่าเชื่อถือและผ่านการรับรองมากน้อยเพียงใด
- คุณภาพทางสถิติของข้อมูลสุ่มที่ผลิตออกมา
- ประสิทธิภาพและคุณสมบัติเด่นของตัวสร้าง
- การยอมรับและการตรวจสอบวิเคราะห์จากผู้เชี่ยวชาญอิสระภายนอกต่ออัลกอริทึมดังกล่าว
การแจกแจง
เทรต Distribution ได้รับการจัดเตรียมไว้โดยเครต rand พร้อมกับการแจกแจงที่นิยมใช้งานบ่อย (โดยส่วนใหญ่เป็นการแจกแจงเชิงเส้น)
สำหรับการแจกแจงเพิ่มเติมอื่นๆ จะถูกรวมไว้ในเครต rand_distr ซึ่งขึ้นอยู่กับ rand และทำการ re-export การแจกแจงทั้งหมดของมัน
การทดสอบ
ไลบรารี Rand มีชุดยูนิตเทสต์อยู่พอสมควร แม้ว่าจะยังไม่ครอบคลุมครบถ้วนทุกจุดหรือสมบูรณ์แบบที่สุด (เรายินดีต้อนรับการส่งชุดทดสอบเข้ามาปรับปรุงเพิ่มเติมเสมอ) ทั้งนี้ เราต้องการให้มีการเขียนชุดทดสอบกำกับสำหรับฟังก์ชันการทำงานใหม่ๆ ทุกรายการ
ขั้นตอนแรกสุดในการทดสอบคือการรันคำสั่ง cargo test จากไดเรกทอรีที่เกี่ยวข้อง และเนื่องจาก Rand รองรับสภาพแวดล้อมหลากหลายรูปแบบ ทั้ง no_std (เฉพาะ core), core+alloc และสภาพแวดล้อมแบบ std เต็มรูปแบบ จึงจำเป็นอย่างยิ่งที่จะต้องทดสอบทั้ง 3 รูปแบบนี้ (ขึ้นอยู่กับว่าโค้ดส่วนที่คุณแก้ไขเกี่ยวข้องกับฟีเจอร์ใดบ้าง):
# Test using std:
cargo test
# Test using only core:
cargo test --tests --no-default-features
# Test using core + alloc (requires nightly):
cargo +nightly test --tests --no-default-features --features=alloc
นอกจากนี้ ยังควรทดสอบร่วมกับฟีเจอร์แฟล็กอื่นๆ ทั้งหมดด้วย:
cargo test --all-features
โปรดทราบว่าคำสั่งเหล่านี้จะทดสอบเฉพาะแพ็กเกจปัจจุบันเท่านั้น (เช่น ไลบรารีหลักของ Rand เมื่อรันจากระดับบนสุดของคลังเก็บโค้ด) หากต้องการทดสอบไลบรารีหรือเครตอื่น ให้ใช้คำสั่ง cd ไปยังไดเรกทอรีของเครตนั้นๆ โดยตรง
เราไม่แนะนำให้ใช้แฟล็ก --package ของ Cargo เนื่องจากอาจก่อให้เกิด
ปฏิสัมพันธ์ที่น่าประหลาดใจ
กับตัวเลือก --feature และล้มเหลวเมื่อมีแพ็กเกจเวอร์ชันเดียวกันหลายตัวอยู่ใน build tree ในระบบ CI ของเราจะใช้แฟล็ก --manifest-path ในการเลือกแพ็กเกจแทน แต่ในระหว่างการพัฒนา การใช้คำสั่ง cd จะสะดวกและง่ายกว่า
การเขียนเทสต์
ชุดทดสอบสามารถเขียนได้หลากหลายรูปแบบ ไม่ว่าจะเป็นยูนิตเทสต์ภายในซับโมดูล test, ตัวอย่างโค้ดในเอกสาร, แอปพลิเคชันตัวอย่าง (ในไดเรกทอรี examples), การทดสอบแบบผสานรวม (ในไดเรกทอรี tests) หรือ benchmark (ในไดเรกทอรี benches)
โปรดทราบว่ามีเฉพาะยูนิตเทสต์และการทดสอบแบบผสานรวมเท่านั้นที่คาดว่าจะผ่านในรูปแบบ no_std (core เท่านั้น) และ core+alloc นี่เป็นทางเลือกโดยเจตนา; โค้ดตัวอย่างควรกำหนดเป้าหมายเฉพาะกรณีทั่วไป (std) เท่านั้น
ตัวสร้างเลขสุ่ม
บ่อยครั้งที่โค้ดทดสอบจำเป็นต้องเรียกใช้ RNG สำหรับประมวลผล แต่ไม่ได้เจาะจงว่าต้องเป็น RNG ตัวใดตัวหนึ่งเป็นพิเศษ ในกรณีนี้ เราแนะนำให้ใช้ ::test::rng ซึ่งเรียบง่าย เริ่มต้นได้เร็ว และเป็นดีเทอร์มินิสติก:
let mut rng = ::test::rng(528); // just pick some number
เทสต์หลายตัวเกี่ยวข้องกับคุณสมบัติที่น่าจะเป็นจริง แต่ไม่แน่นอน เราชอบให้เทสต์เช่นนั้นเป็นดีเทอร์มินิสติกเพื่อหลีกเลี่ยงความล้มเหลวที่ไม่จริง
การวัดประสิทธิภาพ
โครงการของเรามีชุดทดสอบวัดประสิทธิภาพ (benchmarks) จัดเตรียมไว้แล้วมากมาย:
cargo +nightly bench
# In a few cases, nightly features may use different code paths:
cargo +nightly bench --features=nightly
ชุดทดสอบประสิทธิภาพสำหรับการแจกแจงต่างๆ ในปัจจุบันจะแยกไปอยู่ในเครต rand_distr ส่วนชุดทดสอบประสิทธิภาพอื่นๆ ทั้งหมด (รวมถึง RNG ทั้งหมดของเรา) จะรวมอยู่ในเครตหลักอย่าง rand (ด้วยเหตุนี้จึงมี dev-dependencies อยู่หลายรายการ)
โค้ดจำนวนมากใน Rand มีความอ่อนไหวต่อประสิทธิภาพสูง และส่วนใหญ่มักถูกเรียกใช้งานซ้ำๆ ในลูปวิกฤต (hot loops) ของไลบรารีหรือแอปพลิเคชันต่างๆ ดังนั้นหากคุณทำการแก้ไขโค้ดใน rand_core, ในเครต PRNG หรือในโมดูล rngs หรือ distr (โดยเฉพาะเมื่อเป็น ‘การเก็บกวาดโค้ดที่ดูเหมือนชัดเจน’) โปรดตรวจสอบให้แน่ใจเสมอว่าผลการทดสอบ benchmark ไม่ด้อยลง
โปรดรายงานผลเปรียบเทียบก่อนและหลังสำหรับ benchmark ที่ได้รับผลกระทบเสมอ และหากคุณกำลังปรับปรุงประสิทธิภาพในส่วนที่ยังไม่เคยมี benchmark มาก่อน โปรดเพิ่ม benchmark ใหม่เข้าไปก่อนเป็นอันดับแรก จากนั้นจึงค่อยเพิ่มโค้ดที่แก้ไขในคอมมิตแยกต่างหาก (เพื่อให้สามารถวัดผลเปรียบเทียบก่อนและหลังได้ง่าย)