tinyrand
1.0.0
tinyrand Spesifikasi RNG ringan dan beberapa implementasi ultrafast di Rust. tinyrand adalah no_std dan tidak menggunakan pengalokasi tumpukan.
tinyrand ?std , artinya disematkan-berjalan pada mikrokontroler dan lingkungan telanjang-logam (tanpa OS).Mock untuk kode pengujian yang tergantung pada angka acak. Yaitu, jika Anda peduli dengan cakupan kode.Di bawah ini adalah perbandingan beberapa PRNG terkenal.
| Prng | Algoritma | Bandwidth (GB/S) | |
|---|---|---|---|
rand | Chacha12 | 2.4 | |
tinyrand | Splitmix | 6.5 | |
tinyrand | Xorshift | 6.7 | |
fastrand | Wyrand | 7.5 | |
tinyrand | Wyrand | 14.6 |
TL; DR: tinyrand 2x lebih cepat dari fastrand dan 6x lebih cepat dari rand .
Tidak mungkin untuk mengetahui dengan pasti apakah PRNG tertentu baik; Jawabannya probabilistik. Ketiga algoritma berdiri dengan baik melawan rentetan tes dieharder, tetapi Wyrand dan SplitMix sedikit lebih baik daripada Xorshift. (Diuji pada 30,8 miliar sampel.) Ini berarti tinyrand menghasilkan angka yang tampak cukup acak dan kemungkinan cocok untuk digunakan di sebagian besar aplikasi.
Algoritma tinyrand tidak aman secara kriptografis, yang berarti mungkin untuk menebak angka acak berikutnya dengan mengamati urutan angka. (Atau angka sebelumnya, dalam hal ini.) Jika Anda membutuhkan CSPRNG yang kuat, sangat disarankan agar Anda menggunakan rand . CSPRNGs umumnya jauh lebih lambat dan kebanyakan orang tidak membutuhkannya.
cargo add tinyrand Instance Rand diperlukan untuk menghasilkan angka. Di sini, kami menggunakan StdRand , yang merupakan alias untuk RNG default/yang direkomendasikan. (Saat ini diatur ke Wyrand , tetapi dapat berubah di masa depan.)
use tinyrand :: { Rand , StdRand } ;
let mut rand = StdRand :: default ( ) ;
for _ in 0 .. 10 {
let num = rand . next_u64 ( ) ;
println ! ( "generated {num}" ) ;
}Demikian pula, kita dapat menghasilkan jumlah jenis lain:
use tinyrand :: { Rand , StdRand } ;
let mut rand = StdRand :: default ( ) ;
let num = rand . next_u128 ( ) ;
println ! ( "generated wider {num}" ) ; Metode next_uXX menghasilkan angka di seluruh rentang yang tidak ditandatangani dari jenis yang ditentukan. Seringkali, kami menginginkan angka dalam rentang tertentu:
use tinyrand :: { Rand , StdRand , RandRange } ;
let mut rand = StdRand :: default ( ) ;
let tasks = vec ! [ "went to market" , "stayed home" , "had roast beef" , "had none" ] ;
let random_index = rand . next_range ( 0 ..tasks . len ( ) ) ;
let random_task = tasks [ random_index ] ;
println ! ( "This little piggy {random_task}" ) ; Kasus penggunaan umum lainnya adalah menghasilkan bool . Kami mungkin juga ingin memberikan bobot pada hasil biner:
use tinyrand :: { Rand , StdRand , Probability } ;
let mut rand = StdRand :: default ( ) ;
let p = Probability :: new ( 0.55 ) ; // a slightly weighted coin
for _ in 0 .. 10 {
if rand . next_bool ( p ) {
// expect to see more heads in the (sufficiently) long run
println ! ( "heads" ) ;
} else {
println ! ( "tails" ) ;
}
}Ada saat -saat ketika kita membutuhkan utas kita untuk tidur sebentar, menunggu suatu kondisi. Ketika banyak utas sedang tidur, umumnya disarankan mereka mundur secara acak untuk menghindari penyerbuan.
use tinyrand :: { Rand , StdRand , RandRange } ;
use core :: time :: Duration ;
use std :: thread ;
use tinyrand_examples :: SomeSpecialCondition ;
let mut rand = StdRand :: default ( ) ;
let condition = SomeSpecialCondition :: default ( ) ;
let base_sleep_micros = 10 ;
let mut waits = 0 ;
while !condition . has_happened ( ) {
let min_wait = Duration :: ZERO ;
let max_wait = Duration :: from_micros ( base_sleep_micros * 2u64 . pow ( waits ) ) ;
let random_duration = rand . next_range ( min_wait..max_wait ) ;
println ! ( "backing off for {random_duration:?}" ) ;
thread :: sleep ( random_duration ) ;
waits += 1 ;
} Memanggil Default::default() pada Rand menginisialisasi dengan benih konstan. Ini bagus untuk pengulangan tetapi menghasilkan angka "acak" yang sama, yang bukan yang dibutuhkan kebanyakan orang.
tinyrand adalah peti no_std dan, sayangnya, tidak ada cara yang baik dan portabel untuk menghasilkan entropi ketika seseorang tidak dapat membuat asumsi tentang platform yang mendasarinya. Di sebagian besar aplikasi, orang mungkin satu jam, tetapi sesuatu yang sepele seperti SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) mungkin tidak selalu tersedia.
Jika Anda memiliki sumber entropi yang Anda miliki, Anda bisa menyemai Rrnd seperti itu:
use tinyrand :: { Rand , StdRand , Seeded } ;
let seed = tinyrand_examples :: get_seed_from_somewhere ( ) ; // some source of entropy
let mut rand = StdRand :: seed ( seed ) ;
let num = rand . next_u64 ( ) ;
println ! ( "generated {num}" ) ; Anda mungkin juga mempertimbangkan untuk menggunakan getrandom , yang merupakan metode lintas platform untuk mengambil data entropi.
Jika seseorang tidak peduli tentang no_std , mereka tidak boleh terikat oleh keterbatasannya. Untuk menyemai dari jam sistem, Anda dapat memilih ke std :
cargo add tinyrand-std Sekarang, kami memiliki ClockSeed yang kami miliki, yang juga mengimplementasikan sifat Rand . ClockSeed memperoleh u64 dengan xoring 64 bit atas cap waktu nanosecond (dari SystemTime ) dengan 64 bit yang lebih rendah. Ini tidak cocok untuk penggunaan kriptografi tetapi akan cukup untuk sebagian besar aplikasi tujuan umum.
use tinyrand :: { Rand , StdRand , Seeded } ;
use tinyrand_std :: clock_seed :: ClockSeed ;
let seed = ClockSeed :: default ( ) . next_u64 ( ) ;
println ! ( "seeding with {seed}" ) ;
let mut rand = StdRand :: seed ( seed ) ;
let num = rand . next_u64 ( ) ;
println ! ( "generated {num}" ) ; Peti tinyrand-std juga mencakup implementasi Rand yang diunggulkan dan lokal:
use tinyrand :: Rand ;
use tinyrand_std :: thread_rand ;
let mut rand = thread_rand ( ) ;
let num = rand . next_u64 ( ) ;
println ! ( "generated {num}" ) ; Cakupan pengujian yang baik terkadang sulit dicapai; dua kali lipat ketika aplikasi bergantung pada keacakan atau sumber nondeterminisme lainnya. tinyrand hadir dengan mock RNG yang menawarkan kontrol berbutir halus atas pelaksanaan kode Anda.
Mock menggunakan alloc Crate, karena membutuhkan alokasi penutupan penutupan. Dengan demikian, tiruan didistribusikan sebagai paket opt-in:
cargo add tinyrand-alloc Pada tingkat akar rumput, Mock dikonfigurasi dengan beberapa delegasi . Delegasi adalah penutupan yang dipanggil oleh tiruan ketika metode sifat tertentu disebut oleh sistem yang diuji. Mock ini juga mempertahankan keadaan doa internal yang melacak berapa kali delegasi tertentu dilakukan. Jadi, Anda tidak hanya dapat mengejek perilaku sifat Rand , tetapi juga memverifikasi jumlah jenis kelompok tertentu dari metode sifat terkait disebut.
Delegasi ditentukan oleh uji kasus, sedangkan contoh tiruan diteruskan ke sistem yang diuji sebagai implementasi Rand . Saat ini, tiga jenis delegasi didukung:
FnMut(&State) -> u128 -dipanggil ketika salah satu metode next_uXX() dipanggil pada tiruan. ( uXX Menjadi salah satu dari u16 , u32 , u64 , u128 atau usize .) Delegasi mengembalikan nomor "acak" berikutnya, yang mungkin hingga 128 bit lebar. Lebar ini dirancang untuk mengakomodasi u128 - tipe terluas yang didukung oleh Rand . Jika salah satu jenis yang lebih sempit diminta, tiruan hanya mengembalikan bit yang lebih rendah. (Misalnya, untuk u32 , nilai yang diejek dipotong menggunakan as u32 di bawah kap.)FnMut(Surrogate, Probability) -> bool -dipanggil ketika metode next_bool(Probability) dipanggil.FnMut(Surrogate, u128) -> u128 -Ketika next_lim atau next_range dipanggil. Dimulai dengan dasar -dasar absolut, mari kita mengejek next_uXX() untuk mengembalikan konstan. Kami kemudian akan memeriksa berapa kali tiruan kami dipanggil.
use tinyrand :: Rand ;
use tinyrand_alloc :: Mock ;
let mut rand = Mock :: default ( ) . with_next_u128 ( |_| 42 ) ;
for _ in 0 .. 10 {
assert_eq ! ( 42 , rand.next_usize ( ) ) ; // always 42
}
assert_eq ! ( 10 , rand.state ( ) .next_u128_invocations ( ) ) ; Meskipun sangat sederhana, skenario ini sebenarnya cukup umum. Hal yang sama dapat dicapai dengan fungsi fixed(uXX) .
use tinyrand :: Rand ;
use tinyrand_alloc :: { Mock , fixed } ;
let mut rand = Mock :: default ( ) . with_next_u128 ( fixed ( 42 ) ) ;
assert_eq ! ( 42 , rand.next_usize ( ) ) ; // always 42Karena delegasi adalah penutupan reguler, kami dapat berikatan dengan variabel dalam ruang lingkup yang melampirkan. Ini memberi kita kendali yang hampir tidak terbatas atas perilaku tiruan kita.
use tinyrand :: Rand ;
use tinyrand_alloc :: Mock ;
use core :: cell :: RefCell ;
let val = RefCell :: new ( 3 ) ;
let mut rand = Mock :: default ( ) . with_next_u128 ( |_| * val . borrow ( ) ) ;
assert_eq ! ( 3 , rand.next_usize ( ) ) ;
// ... later ...
* val . borrow_mut ( ) = 17 ;
assert_eq ! ( 17 , rand.next_usize ( ) ) ;Delegasi dapat dipindahkan pada titik mana pun, bahkan setelah tiruan telah dibuat dan dilakukan:
use tinyrand :: Rand ;
use tinyrand_alloc :: { Mock , fixed } ;
let mut rand = Mock :: default ( ) . with_next_u128 ( fixed ( 42 ) ) ;
assert_eq ! ( 42 , rand.next_usize ( ) ) ;
rand = rand . with_next_u128 ( fixed ( 88 ) ) ; // the mock's behaviour is now altered
assert_eq ! ( 88 , rand.next_usize ( ) ) ; Tanda tangan delegasi next_u128 mengambil referensi State , yang menangkap berapa kali tiruan itu dipanggil. (Hitungan bertambah hanya setelah doa selesai.) Mari kita tulis tiruan yang mengembalikan angka "acak" yang berasal dari keadaan doa.
use tinyrand :: Rand ;
use tinyrand_alloc :: Mock ;
let mut rand = Mock :: default ( ) . with_next_u128 ( |state| {
// return number of completed invocations
state . next_u128_invocations ( ) as u128
} ) ;
assert_eq ! ( 0 , rand.next_usize ( ) ) ;
assert_eq ! ( 1 , rand.next_usize ( ) ) ;
assert_eq ! ( 2 , rand.next_usize ( ) ) ; Ini berguna ketika kita mengharapkan tiruan akan dipanggil beberapa kali dan setiap doa harus mengembalikan hasil yang berbeda. Hasil yang serupa dapat dicapai dengan fungsi counter(Range) , yang bersepeda melalui kisaran angka yang ditentukan, dengan mudah membungkus batas:
use tinyrand :: Rand ;
use tinyrand_alloc :: { Mock , counter } ;
let mut rand = Mock :: default ( ) . with_next_u128 ( counter ( 5 .. 8 ) ) ;
assert_eq ! ( 5 , rand.next_usize ( ) ) ;
assert_eq ! ( 6 , rand.next_usize ( ) ) ;
assert_eq ! ( 7 , rand.next_usize ( ) ) ;
assert_eq ! ( 5 , rand.next_usize ( ) ) ; // start again Dengan menyediakan hanya delegasi next_u128 , kita dapat mempengaruhi hasil dari setiap metode lain dalam sifat Rand , karena mereka semua berasal dari sumber keacakan yang sama dan pada akhirnya akan memanggil delegasi kita di bawah kap ... secara teori! Dalam praktiknya, segalanya jauh lebih rumit.
Metode Rand yang diturunkan, seperti next_bool(Probability) , next_lim(uXX) dan next_range(Range) didukung oleh distribusi probabilitas yang berbeda. next_bool , misalnya, menarik dari distribusi Bernoulli, sedangkan next_lim dan next_range menggunakan distribusi seragam berskala dengan lapisan debiasing tambahan. Selain itu, pemetaan antara berbagai distribusi adalah detail implementasi internal yang dapat berubah. Lapisan debiasing saja memiliki beberapa implementasi, dioptimalkan untuk jenis lebar yang bervariasi. Dengan kata lain, pemetaan dari next_u128 ke next_bool , next_lim dan next_range dan nontrivial; Ini bukan sesuatu yang ingin Anda kejar tanpa kalkulator dan beberapa pengetahuan tentang aritmatika modular.
Untungnya, Rand memungkinkan kita "memotong" fungsi pemetaan ini. Di sinilah dua delegasi lainnya masuk. Dalam contoh berikut, kami mengejek hasil next_bool .
use tinyrand :: { Rand , Probability } ;
use tinyrand_alloc :: Mock ;
let mut rand = Mock :: default ( ) . with_next_bool ( |_ , _| false ) ;
if rand . next_bool ( Probability :: new ( 0.999999 ) ) {
println ! ( "very likely" ) ;
} else {
// we can cover this branch thanks to the magic of mocking
println ! ( "very unlikely" ) ;
} Delegasi next_bool diserahkan struct Surrogate , yang merupakan implementasi Rand dan penjaga keadaan doa. Surrogate memungkinkan kita mendapatkan bool s, seperti halnya:
use tinyrand :: { Rand , Probability } ;
use tinyrand_alloc :: Mock ;
let mut rand = Mock :: default ( ) . with_next_bool ( |surrogate , _| {
surrogate . state ( ) . next_bool_invocations ( ) % 2 == 0
} ) ;
assert_eq ! ( true , rand.next_bool ( Probability ::new ( 0.5 ) ) ) ;
assert_eq ! ( false , rand.next_bool ( Probability ::new ( 0.5 ) ) ) ;
assert_eq ! ( true , rand.next_bool ( Probability ::new ( 0.5 ) ) ) ;
assert_eq ! ( false , rand.next_bool ( Probability ::new ( 0.5 ) ) ) ;Pengganti juga memungkinkan delegasi memanggil metode yang diejek dari dalam tiruan.
Delegasi terakhir digunakan untuk mengejek metode next_lim dan next_range , karena isomorfisme mereka. Di bawah kap, next_range mendelegasikan ke next_lim , sehingga, untuk setiap batas batas batas ( M , N ), M < N , next_range(M..N) = M + next_lim(N - M) . Beginilah semua itu diejek dalam praktik:
use tinyrand :: { Rand , RandRange } ;
use tinyrand_alloc :: Mock ;
enum Day {
Mon , Tue , Wed , Thu , Fri , Sat , Sun
}
const DAYS : [ Day ; 7 ] = [ Day :: Mon , Day :: Tue , Day :: Wed , Day :: Thu , Day :: Fri , Day :: Sat , Day :: Sun ] ;
let mut rand = Mock :: default ( ) . with_next_lim_u128 ( |_ , _| 6 ) ;
let day = & DAYS [ rand . next_range ( 0 .. DAYS . len ( ) ) ] ;
assert ! ( matches! ( day, Day :: Sun ) ) ; // always a Sunday
assert ! ( matches! ( day, Day :: Sun ) ) ; // yes!!!tinyrand diuji? Bagian ini secara singkat menjelaskan pendekatan pengujian tinyrand . Itu ditujukan untuk mereka yang -
Proses pengujian tinyrand dibagi menjadi empat tingkatan:
tinyrand . Dengan kata lain, setiap baris kode dilakukan setidaknya sekali, harapan mendasar ditegakkan dan kemungkinan tidak ada cacat sepele.tinyrand . Ini adalah tes hipotesis formal yang mengasumsikan bahwa sumbernya acak (hipotesis nol), dan mencari bukti untuk menghilangkan asumsi ini (hipotesis alternatif).Tes unit tidak ditujukan untuk menyatakan kualitas numerik; mereka murni fungsional di alam. Tujuan termasuk -
tinyrand dibangun di atas filosofi bahwa jika baris kode tidak terbukti dilakukan, itu harus dihapus. Tidak ada pengecualian untuk aturan ini.true versus false dalam generasi bool s. Fungsi untuk pemetaan dari distribusi seragam ke kustom yang tidak nontrivial dan membutuhkan lapisan debiasing. tinyrand menggunakan metode debiasing yang berbeda tergantung pada lebar kata. Tujuan dari tes transformasi domain adalah untuk memverifikasi bahwa fungsi ini berfungsi seperti yang diharapkan dan pengambilan sampel penolakan sedang terjadi. Namun, itu tidak memverifikasi sifat numerik dari debiasing. Tolok ukur sintetis digunakan untuk melatih jalur panas dari tinyrand PRNGs, membandingkan hasilnya dengan pustaka peer. Benchmark menguji generasi angka pada berbagai panjang kata, transformasi/debiasing dan generasi bool tertimbang. Subset dari tolok ukur ini juga termasuk dalam tes CI, membuatnya sedikit lebih mudah untuk membandingkan kinerja tinyrand di seluruh versi komit.
tinyrand datang dibundel dengan suite pengujian statistik terintegrasi, terinspirasi oleh orang-orang seperti diehard, dieharder dan NIST SP 800-22. tinyrand Suite memang jauh lebih kecil dari tes ini; Tujuannya bukan untuk mereplikasi pekerjaan yang sudah substansial dan mudah diakses di bidang ini, tetapi untuk membuat jaring pengaman yang keduanya sangat efektif dalam mendeteksi anomali umum dan cukup cepat untuk dijalankan di setiap komit.
Tes berikut disertakan.
Rand dengan menutupi nilai satu bit, memverifikasi bahwa berapa kali bit diatur ke 1 berada dalam kisaran yang diharapkan. Untuk setiap persidangan berikutnya, topeng digeser oleh satu ke kiri dan hipotesis diuji ulang. Tes berlangsung selama beberapa siklus; Setiap siklus yang terdiri dari 64 uji coba Bernoulli (satu untuk setiap bit u64 ).bool dengan probabilitas yang dipilih dari kata 64-bit yang tidak ditandatangani. Tes ini terdiri dari serangkaian uji coba Bernoulli dengan bobot yang berbeda (dipilih secara acak) pada setiap percobaan, mensimulasikan serangkaian flip koin. Dalam setiap percobaan, H0 menegaskan bahwa sumbernya acak. (Yaitu, jumlah 'kepala' berada dalam interval yang dapat diterima secara statistik.)u64 S dalam uji coba terpisah. Dalam setiap percobaan, kami mengasumsikan bahwa nilai -nilai bit individu adalah IID dengan probabilitas 0,5, memverifikasi bahwa berapa kali bit diatur ke 1 berada dalam kisaran yang diharapkan. Untuk sumber acak, jumlah 1s (dan 0s) mengikuti proses Bernoulli. Setiap tes tinyrand dilakukan tidak hanya terhadap PRNG -nya sendiri, tetapi juga terhadap implementasi yang salah, yang digunakan untuk memverifikasi kemanjuran tes. Tes harus secara konsisten gagal untuk menolak H0 untuk PRNG yang benar dan menerima H1 untuk yang salah.
Tes statistik itu sendiri diunggulkan dari nilai acak. Keacakan digunakan untuk menyemai PRNG yang diuji (setiap percobaan diunggulkan secara independen), menetapkan bobot untuk percobaan Bernoulli, memilih rentang integer untuk pengujian fungsi transformasi dan debiasing, nilai kontrol untuk pengujian tabrakan, dan sebagainya. Kami menggunakan paket rand sebagai kontrol PRNG sehingga cacat di tinyrand tidak dapat secara tidak sengaja menumbangkan tes dengan cara yang menutupi itu sendiri. Tes diunggulkan sehingga, sementara mereka tampak pada perjalanan acak melalui ruang parameter, pilihan parameter mereka sepenuhnya deterministik dan karenanya dapat diulang. Ini sangat penting karena kemungkinan kesalahan tipe I (secara tidak benar menolak hipotesis nol), yang tidak boleh diizinkan terjadi sesekali, terutama di lingkungan CI. Dengan kata lain, pengujian keacakan tidak dapat dibiarkan kebetulan .
Salah satu cara menguji hipotesis keacakan adalah dengan memilih satu set parameter (misalnya, kisaran generasi integer M .. N atau probabilitas mendapatkan true dari distribusi Bernoulli) dan untuk melakukan jangka panjang, mencari anomali dalam sampel acak yang besar besar dalam sampel besar yang besar dalam besar acak besar besar besar besar besar besar besar yang besar) . Alasannya adalah bahwa semakin besar sampel, semakin besar kemungkinannya akan mengandung anomali yang terdeteksi. Ini umumnya tidak terlalu efektif untuk menemukan jenis anomali tertentu yang dapat mempengaruhi PRNG hanya dalam kondisi yang sangat spesifik. Misalnya, fungsi debiasing yang ditulis dengan buruk mungkin masih berkinerja baik untuk sebagian besar rentang bilangan bulat kecil dan bahkan beberapa yang besar (yang dekat dengan kekuatan dua). Jika parameter memilih tes secara tidak menguntungkan, itu mungkin tidak menemukan anomali tidak peduli seberapa mendalamnya menguji parameter tersebut.
Cara pengujian PRNG yang jauh lebih baik adalah dengan memperkenalkan keragaman ke dalam rezim pengujian - melakukan sejumlah besar uji coba kecil dengan parameter yang berbeda daripada uji coba yang sangat besar. Inilah tepatnya apa yang dilakukan tes statistik tinyrand - melakukan beberapa uji coba dengan parameter yang dipilih secara acak (tetapi deterministik). Ini segera memaparkan masalah perbandingan berganda. Pertimbangkan prng ideal a priori . Ini akan sering menghasilkan angka yang akan muncul "acak" sesuai dengan beberapa ukuran yang disepakati. Tetapi kadang -kadang, itu akan menghasilkan output yang akan muncul non -acak dengan ukuran yang sama. Bahkan sumber yang ideal akan menghasilkan yang sangat panjang atau nol, misalnya. Faktanya, gagal melakukannya juga akan menjadikannya nonrandom. Sayangnya, ini akan menghasilkan nilai-p yang akan gagal bahkan tes yang paling santai ... di beberapa titik. Ini adalah masalah untuk pengujian hipotesis tunggal, tetapi secara proporsional diperburuk dalam beberapa pengujian hipotesis.
Tes bawaan tinyrand mengatasi masalah ini menggunakan metode koreksi sekuensial Holm-Bonferroni. Koreksi Holm-Bonferroni menekan kesalahan tipe I sambil mempertahankan kekuatan statistik yang baik-penindasan kesalahan tipe II. Tampaknya berkinerja baik untuk kebutuhan tinyrand , terutama melihat bahwa uji coba angka umumnya disimpan dalam kisaran 100-1000. (Tes tinyrand dirancang agar sangat cepat, yang menempatkan terikat praktis pada jumlah uji coba - idealnya, semua tes statistik harus diselesaikan dalam beberapa detik agar mereka diamanatkan sebagai bagian dari aliran pengembangan rutin.)
Dieharder Test Suite memperluas baterai tes diehard asli Marsaglia. Ini dibundel dengan sejumlah besar tes dan membutuhkan waktu lama (~ 1 jam) untuk diselesaikan. tinyrand memiliki utilitas untuk memompa output acak ke dieharder, yang biasanya dijalankan berdasarkan ad hoc. Baterai dieharder harus dijalankan ketika PRNG mengalami perubahan material, yang jarang terjadi - setelah algoritma PRNG diimplementasikan, umumnya tetap tidak tersentuh kecuali jika ditemukan kembali atau beberapa cacat ditemukan. Dieharder bisa dibilang lebih berguna untuk membangun dan menguji PRNG eksperimental dengan tinyrand . Tiga tingkatan tes lainnya cukup untuk pemeliharaan paket tinyrand .
Untuk menjalankan tinyrand melawan dieharder:
cargo run --release --bin random -- wyrand 42 binary 1T | dieharder -g 200 -a Perintah di atas menggunakan Wyrand Prng, diunggulkan dengan angka 42, menghasilkan output biner lebih dari 1 triliun kata 64-bit. stdout dipompa ke dieharder . (Dalam praktiknya, Dieharder akan mengkonsumsi di bawah 31 miliar angka.)
Kata hati -hati: Dieharder tidak memiliki mekanisme untuk menangani kesalahan tipe I dalam beberapa pengujian hipotesis - sebagian karena tes berbeda dalam jenis, bukan hanya dalam parameter. Dieharder membatasi pengujian hipotesis dengan ruang lingkup tes individu; Tidak ada hipotesis menyeluruh yang mengklasifikasikan PRNG sebagai kesesuaian atau tidak layak berdasarkan jumlah tes yang dilewatkan, atau dengan sebaliknya menyesuaikan tingkat kepercayaan untuk memperhitungkan kesalahan tipe I.
