ภาษาที่ใช้งานได้จัดการกับตัวเลขสุ่มอย่างไร

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

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

ฉันหมายความว่าสิ่งนี้ดูเหมือนจะขัดแย้งกับหนึ่งในสิ่งที่ดีเกี่ยวกับฟังก์ชั่นใช่มั้ย หรือว่าฉันขาดอะไรบางอย่างที่นี่อย่างสมบูรณ์?

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

มาจากพื้นหลังที่จำเป็นคุณอาจคาดหวังว่าสุ่มมีประเภทดังนี้:

random :: () -> Integer

แต่สิ่งนี้ได้ถูกตัดออกไปแล้วเพราะการสุ่มไม่สามารถทำหน้าที่บริสุทธิ์ได้

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

เห็นได้ชัดว่าการสุ่มไม่สามารถสร้างค่าจำนวนเต็มได้ แต่จะสร้างตัวแปรสุ่มจำนวนเต็ม ประเภทของมันอาจเป็นแบบนี้:

random :: () -> Random Integer

ยกเว้นว่าผ่านการโต้แย้งไม่จำเป็นครบถ้วน, ฟังก์ชั่นที่บริสุทธิ์ดังนั้นหนึ่งเป็นดีอีกrandom () random ()ฉันจะให้สุ่มจากนี้ไปประเภทนี้:

random :: Random Integer

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

นี่ทำให้เกิดคำถามที่น่าสนใจ มีฟังก์ชั่นใดที่ควรจัดการกับตัวแปรสุ่ม

ฟังก์ชั่นนี้ไม่สามารถอยู่ได้:

bad :: Random a -> a

ในวิธีที่มีประโยชน์เพราะคุณสามารถเขียน:

badRandom :: Integer
badRandom = bad random

ซึ่งแนะนำความไม่ลงรอยกัน badRandom เป็นค่าที่คาดคะเน แต่ก็เป็นตัวเลขสุ่มด้วยเช่นกัน ความขัดแย้ง

บางทีเราควรเพิ่มฟังก์ชั่นนี้:

randomAdd :: Integer -> Random Integer -> Random Integer

แต่นี่เป็นกรณีพิเศษของรูปแบบทั่วไปที่มากกว่า คุณควรจะสามารถใช้ฟังก์ชั่นใด ๆ กับสิ่งที่สุ่มเพื่อรับสิ่งอื่น ๆ ที่เป็นเช่น

randomMap :: (a -> b) -> Random a -> Random b

แทนที่จะเขียนrandom + 42เราสามารถเขียนrandomMap (+42) randomได้

หากทั้งหมดที่คุณมีคือ RandomMap คุณจะไม่สามารถรวมตัวแปรสุ่มเข้าด้วยกันได้ คุณไม่สามารถเขียนฟังก์ชันนี้ได้เช่น:

randomCombine :: Random a -> Random b -> Random (a, b)

คุณอาจลองเขียนแบบนี้:

randomCombine a b = randomMap (\a' -> randomMap (\b' -> (a', b')) b) a

แต่มันก็มีประเภทที่ไม่ถูกต้อง แทนที่จะลงท้ายด้วย a Random (a, b)เราจะจบด้วย aRandom (Random (a, b))

สิ่งนี้สามารถแก้ไขได้โดยการเพิ่มฟังก์ชั่นอื่น:

randomJoin :: Random (Random a) -> Random a

แต่ด้วยเหตุผลที่ชัดเจนในที่สุดฉันจะไม่ทำเช่นนั้น ฉันจะเพิ่มสิ่งนี้แทน:

randomBind :: Random a -> (a -> Random b) -> Random b

ไม่ชัดเจนในทันทีว่านี่จะแก้ปัญหาได้จริง แต่ก็เป็นเช่นนั้น:

randomCombine a b = randomBind a (\a' -> randomMap (\b' -> (a', b')) b)

ในความเป็นจริงมันเป็นไปได้ที่จะเขียน randomBind ในแง่ของ randomJoin และ randomMap นอกจากนี้ยังเป็นไปได้ที่จะเขียน randomJoin ในแง่ของ randomBind แต่ฉันจะออกไปทำแบบนี้เป็นการออกกำลังกาย

เราสามารถทำให้มันง่ายขึ้นได้เล็กน้อย อนุญาตให้ฉันกำหนดฟังก์ชันนี้:

randomUnit :: a -> Random a

randomUnit เปลี่ยนค่าเป็นตัวแปรสุ่ม ซึ่งหมายความว่าเราสามารถมีตัวแปรสุ่มที่ไม่ได้สุ่มจริง แม้ว่าจะเป็นเช่นนี้เสมอ เราสามารถทำrandomMap (const 4) randomมาก่อน เหตุผลที่กำหนด randomUnit เป็นความคิดที่ดีคือตอนนี้เราสามารถกำหนด randomMap ในแง่ของ randomUnit และ randomBind:

randomMap :: (a -> b) -> Random a -> Random b
randomMap f x = randomBind x (randomUnit . f)

ตกลงตอนนี้เรากำลังเดินทางไปที่อื่น เรามีตัวแปรสุ่มที่เราสามารถจัดการได้ อย่างไรก็ตาม:

• ไม่ชัดเจนว่าเราจะใช้ฟังก์ชันเหล่านี้อย่างไร
• มันค่อนข้างยุ่งยาก

การดำเนินงาน

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

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

runRandom :: Seed -> Random a -> a

ฉันจะกำหนดประเภทแบบสุ่มเช่นนี้:

data Random a = Random (Seed -> (Seed, a))

จากนั้นเราเพียงแค่ต้องทำการใช้งานของ randomUnit, randomBind, runRandom และ random ซึ่งค่อนข้างตรงไปตรงมา:

randomUnit :: a -> Random a
randomUnit x = Random (\seed -> (seed, x))

randomBind :: Random a -> (a -> Random b) -> Random b
randomBind (Random f) g =
  Random (\seed ->
    let (seed', x) = f seed
        Random g' = g x in
          g' seed')

runRandom :: Seed -> Random a -> a
runRandom seed (Random f) = (snd . f) seed

สำหรับการสุ่มฉันจะสมมติว่ามีฟังก์ชั่นของประเภท:

psuedoRandom :: Seed -> (Seed, Integer)

Random psuedoRandomซึ่งในกรณีนี้เป็นเพียงการสุ่ม

ทำสิ่งที่ยุ่งยากน้อยลง

Haskell มีน้ำตาลประโยคเพื่อทำสิ่งต่าง ๆ เช่นนี้ดีกว่าในสายตา มันเรียกว่าการทำเครื่องหมายและใช้ทุกอย่างที่เราต้องทำเพื่อสร้างตัวอย่างของ Monad สำหรับการสุ่ม

instance Monad Random where
  return = randomUnit
  (>>=) = randomBind

เสร็จสิ้น randomCombineก่อนหน้านี้สามารถเขียนได้:

randomCombine :: Random a -> Random b -> Random (a, b)
randomCombine a b = do
  a' <- a
  b' <- b
  return (a', b')

ถ้าฉันทำสิ่งนี้เพื่อตัวฉันเองฉันจะก้าวไปอีกขั้นหนึ่งไกลกว่านี้และสร้างตัวอย่างของการใช้งาน (ไม่ต้องกังวลหากไม่มีเหตุผล)

instance Functor Random where
  fmap = liftM

instance Applicative Random where
  pure = return
  (<*>) = ap

จากนั้น RandomCombine สามารถเขียนได้:

randomCombine :: Random a -> Random b -> Random (a, b)
randomCombine a b = (,) <$> a <*> b

ตอนนี้เรามีอินสแตนซ์เหล่านี้เราสามารถใช้>>=แทน randomBind เข้าร่วมแทน randomJoin, fmap แทน randomMap กลับมาแทน randomUnit นอกจากนี้เรายังรับฟังก์ชั่นโหลดฟรีมากมาย

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

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

เราสันนิษฐานว่าเราต้องการเพียงตัวอย่างเดียวจากตัวแปรสุ่มแต่ละตัวที่เราสร้าง แต่หากปรากฎว่าในอนาคตเราต้องการเห็นการกระจายตัวมากขึ้นนี่เป็นเรื่องเล็กน้อย คุณสามารถใช้ runRandom ได้หลายครั้งในตัวแปรสุ่มเดียวกันกับเมล็ดที่แตกต่างกัน แน่นอนว่าเป็นไปได้ในภาษาที่จำเป็น แต่ในกรณีนี้เราสามารถมั่นใจได้ว่าเราจะไม่ดำเนินการ IO ที่ไม่คาดคิดทุกครั้งที่เราสุ่มตัวอย่างตัวแปรแบบสุ่มและเราไม่ต้องระมัดระวังเกี่ยวกับสถานะเริ่มต้น

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

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

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

วิธีหนึ่งคือคิดว่ามันเป็นลำดับสุ่มของอนันต์ตัวเลข:

IEnumerable<int> randomNumberGenerator = new RandomNumberGenerator(seed);

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

ดังนั้นตัวสร้างตัวเลขสุ่มที่ไม่เปลี่ยนรูป (ที่มีการประเมินผลที่ขี้เกียจ) อาจมีลักษณะดังนี้:

class RandomNumberGenerator
{
    private readonly int nextSeed;
    private RandomNumberGenerator next;

    public RandomNumberGenerator(int seed)
    {
        this.nextSeed = this.generateNewSeed(seed);
        this.RandomNumber = this.generateRandomNumberBasedOnSeed(seed);
    }

    public int RandomNumber { get; private set; }

    public RandomNumberGenerator Next
    {
        get
        {
            if(this.next == null) this.next = new RandomNumberGenerator(this.nextSeed);
            return this.next;
        }
    }

    private static int generateNewSeed(int seed)
    {
        //...
    }

    private static int generateRandomNumberBasedOnSeed(int seed)
    {
        //...
    }
}

นั่นเป็นหน้าที่

มันเหมือนกันสำหรับภาษาที่ไม่สามารถใช้งานได้ ไม่สนใจปัญหาที่แยกกันเล็กน้อยของตัวเลขสุ่มที่นี่

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