rand64

แรนด์64

แพ็คเกจ rand64 จัดเตรียมตัวสร้างตัวเลขสุ่มหลอกซึ่งให้ผลลัพธ์เป็นตัวเลข 64 บิตที่ไม่ได้ลงนามในช่วง [0, 2 ⁶⁴ )

การใช้งานสำหรับตัวสร้างตัวเลขสุ่มหลอกต่อไปนี้มีให้ในแพ็คเกจของตัวเอง:

• splitmix64 ซึ่งเป็น SplittableRandom PRNG 64 บิต ส่วนใหญ่ใช้เป็นเครื่องหยอดสำหรับ PRNG อื่นๆ
• xoshiro256** และ xoshiro256+
• xoroshiro128** และ xoroshiro128+
• wrapper io.Reader สำหรับแหล่ง PRNG

เครื่องกำเนิดไฟฟ้าเหล่านี้ใช้ rand.Source64 ดังนั้นจึงสามารถใช้เป็นแหล่งที่มาสำหรับ rand.Rand (ณ Go 1.8)

โปรดทราบว่าอัลกอริธึมบางตัวใช้แพ็คเกจบิตจาก Go 1.9

การสร้าง PRNG มีลักษณะดังนี้:

 // create a source with the xoshiro256**
source := &xoshiro.Rng256SS{}

// use it as a source in rand.New
rng := rand.New(&source)

// Seed it from a single int64 (negative values are accepted)
rng.Seed(int64Seed)

อัลกอริทึม

แยกมิกซ์64

นี่คือเวอร์ชันที่เพิ่มขึ้นคงที่ของตัวสร้าง SplittableRandom ของ Java 8 ดูเพิ่มเติมที่หน้าเกี่ยวกับตัวสร้างตัวเลขสุ่มเทียมแบบแยกได้อย่างรวดเร็ว

ดำเนินการตามการใช้งานอ้างอิง C โดย Sebastiano Vigna

xoshiro256** และ xoshiro256+

ช่วงที่ 2 ²⁵⁶ -1

ตามผู้เขียนอัลกอริทึม:

xoshiro256** (XOR/shift/rotate) คือตัวสร้างอเนกประสงค์ที่แข็งแกร่งของเรา (แต่ไม่ใช่ตัวสร้างที่ปลอดภัยด้วยการเข้ารหัส) มีความเร็วที่ยอดเยี่ยม (sub-ns) พื้นที่สถานะ (256 บิต) ที่ใหญ่เพียงพอสำหรับแอปพลิเคชันแบบขนานใดๆ และผ่านการทดสอบทั้งหมดที่เราทราบ

อย่างไรก็ตาม หากเราต้องสร้างตัวเลขทศนิยม 64 บิตเท่านั้น (โดยแยก 53 บิตบนออก) xoshiro256+ เป็นตัวสร้างที่เร็วกว่าเล็กน้อย (ประมาณ 15%) พร้อมคุณสมบัติทางสถิติที่คล้ายคลึงกัน สำหรับการใช้งานทั่วไป เราต้องพิจารณาว่าบิตต่ำสุดนั้นมีความซับซ้อนเชิงเส้นต่ำ และจะไม่ผ่านการทดสอบความเป็นเชิงเส้น อย่างไรก็ตาม ความซับซ้อนเชิงเส้นต่ำแทบไม่มีผลกระทบใดๆ ในทางปฏิบัติ และแน่นอนว่าไม่มีผลกระทบใดๆ เลย หากคุณสร้างตัวเลขทศนิยมโดยใช้บิตบน (เราคำนวณค่าประมาณที่แม่นยำของความซับซ้อนเชิงเส้นของบิตต่ำสุด)

xoroshiro128** และ xoroshiro128+

ช่วงที่ 2 ¹²⁸ -1

ตามผู้เขียนอัลกอริทึม:

xoroshiro128** (XOR/rotate/shift/rotate) และ xoroshiro128+ มีความเร็วเท่ากันกับ xoshiro256 และใช้พื้นที่ครึ่งหนึ่ง ใช้ความคิดเห็นเดียวกัน เหมาะสำหรับการใช้งานแบบขนานขนาดต่ำเท่านั้น ยิ่งไปกว่านั้น xoroshiro128+ ยังแสดงการพึ่งพาเล็กน้อยในตุ้มน้ำหนัก Hamming ซึ่งทำให้เกิดความล้มเหลวหลังจากเอาต์พุต 5 TB ในการทดสอบของเรา เราเชื่อว่าความลำเอียงเล็กน้อยนี้ไม่สามารถส่งผลกระทบต่อการใช้งานใดๆ

ดำเนินการตามการใช้งานอ้างอิง C โดย David Blackman และ Sebastiano Vigna

สำหรับข้อมูลเพิ่มเติม โปรดไปที่เครื่องกำเนิด xoshiro / xoroshiro และหน้าการยิง PRNG

พีซีจี

ช่วงที่ 2 ¹²⁸

นี่คือตัวสร้างคอนกรูเชียลที่มีการเรียงสับเปลี่ยนตามที่กำหนดไว้ใน

PCG: กลุ่มอัลกอริธึมที่ดีทางสถิติอย่างง่ายและรวดเร็วสำหรับการสร้างตัวเลขสุ่ม

เมลิสซา อี. โอนีล วิทยาลัยฮาร์วีย์ มัดด์

https://www.cs.hmc.edu/tr/hmc-cs-2014-0905.pdf

แม้ว่า PCG จะอ้างถึงอัลกอริธึมทั้งตระกูล (ดู http://pcg-random.org ด้วย) อัลกอริธึมเดียวที่มีให้คือ PCG XSL RR 128/64 LCG

ดำเนินการตามการใช้งานอ้างอิง C โดย Melissa O'Neill และผู้ร่วมโครงการ PCG

MT19937-64

ช่วงที่ 2 ¹⁹⁹³⁷ -1

นี่เป็นการใช้งาน Go ล้วนๆ โดยอิงจากการใช้งาน mt19937-64.c C โดย Makoto Matsumoto และ Takuji Nishimura

ข้อมูลเพิ่มเติมเกี่ยวกับอัลกอริทึม Mersenne Twister และการใช้งานอื่นๆ มีอยู่ที่ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html

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

กระดาษห่อ io.Reader

ไม่ใช่ PRNG ที่แท้จริง

แพ็คเกจ IoRand เป็น wrapper อย่างง่ายสำหรับการอ่านไบต์สตรีมผ่าน io.Reader สามารถใช้เป็น wrapper รอบ crypto/rand เพื่อสร้าง rand.Source64 สำหรับแพ็คเกจ math/rand:

 package main

import (
    "bufio"
    crand "crypto/rand"
    "encoding/binary"
    "math/rand"

    "github.com/db47h/rand64/v3/iorand"
)

// Wrap crypto/rand in an IoRand
func main () {
    // first, wrap crypto/rand.Reader in a buffered bufio.Reader
    bufferedReader := bufio . NewReader ( crand . Reader )
    // Create the new IoRand Source
    ior := iorand . New ( bufferedReader , binary . LittleEndian )
    // use it as rand.Source64
    rng := rand . New ( ior )
    // get random numbers...
    for i := 0 ; i < 4 ; i ++ {
        _ = rng . Uint64 ()
    }
}

เกณฑ์มาตรฐาน

การวัดประสิทธิภาพเหล่านี้ทำได้ด้วย go 1.12.5

อัลกอริทึม	เอเอ็มดี FX-6300	คอร์ i5 6200U	ARM Cortex-A7 @ 900MHz
xoshiro256**	5.53ns/ปฏิบัติการ		106.0ns/ปฏิบัติการ
xoshiro256+	5.48ns/ปฏิบัติการ		86.1ns/ปฏิบัติการ
โซโรชิโร128**	5.16ns/ปฏิบัติการ		79.2ns/ปฏิบัติการ
xoroshiro128+	5.15ns/ปฏิบัติการ		62.7ns/ปฏิบัติการ
พีซีจี XSL RR 128/64 แอลซีจี	5.29ns/ปฏิบัติการ		254.0ns/ปฏิบัติการ
แยกมิกซ์64	4.30 น./ปฏิบัติการ		77.5ns/ปฏิบัติการ
เมอร์เซน ทวิสเตอร์ 19937	8.82ns/ปฏิบัติการ		136.0ns/ปฏิบัติการ
ไปคณิต/แรนด์	7.01ns/ปฏิบัติการ		68.4ns/ปฏิบัติการ

โปรดทราบว่าการวัดประสิทธิภาพแสดงประสิทธิภาพที่ช้ากว่าเมื่อเทียบกับรุ่นก่อนหน้า นี่เป็นเพราะความจริงที่ว่าเราได้เรียก Rng.Uint64 โดยตรงแทนที่จะผ่านอินเทอร์เฟซ rand.Rand64 เพื่อที่จะทำการเปรียบเทียบอย่างยุติธรรมกับ rng ของไลบรารีมาตรฐาน Go ตอนนี้การวัดประสิทธิภาพทั้งหมดจะต้องผ่านอินเทอร์เฟซ rand.Source64

อัลกอริทึมใดที่จะเลือก

อยู่ห่างจาก splitmix64 และ Mersenne-Twister ผู้มีเกียรติ 19937

ไม่ค่อยมีใครรู้เกี่ยวกับคณิตศาสตร์/แรนด์ของ Go (ดู ที่นี่ ที่นี่ ) และมีข้อเสนอให้แทนที่ด้วยเครื่องกำเนิด PCG

PCG, xoshiro256** และ xoroshiro128** ที่ให้มานั้นขึ้นชื่อว่าผ่านการทดสอบที่ทราบทั้งหมด ตามผู้เขียนตามลำดับ ระวังประสิทธิภาพที่ไม่ดีของอัลกอริธึม PCG นี้บนแพลตฟอร์ม 32 บิต (ส่งผลกระทบต่อทั้ง ARM และ x86)

ไปสนับสนุนโมดูล

rand64 รองรับโมดูล go เวอร์ชันก่อนหน้า 1.x และ 2.x ได้ถูกย้ายไปยังสาขาที่เกี่ยวข้องแล้ว เนื่องจากแท็ก semver ที่ไม่มี go.mod ดูเหมือนจะทำให้โมดูล go ไม่พอใจ แท็กสำหรับเวอร์ชันเหล่านี้จึงถูกรีเซ็ตแล้ว

ใบอนุญาต

แพ็คเกจนี้เผยแพร่ภายใต้เงื่อนไขของใบอนุญาต ISC (ดูไฟล์ใบอนุญาตที่รากของพื้นที่เก็บข้อมูล) นอกจากนี้ การใช้อัลกอริทึมต่อไปนี้ยังอยู่ภายใต้ใบอนุญาตเพิ่มเติม:

• PCG: MIT (ดู LICENSE-pcg)
• MT 19937: ใบอนุญาต BSD 3 ข้อ (ดู LICENSE-mt19937)