Random number sequence un Haskell and State Monad, what am I doing wrong?

Question

As part of my Haskell journey, I am implementing a raytracer and I need to be able to draw sequences of random numbers at several places in the code. Typically I would like to be able to get say 64 samples for each pixels and pixels are computed in parallel.

I was looking at the state monad to achieve that and I was guided by this answer Sampling sequences of random numbers in Haskell but the code I wrote does not terminate and it's memory consumption explodes.

Here is the abstracted part of the code: I was hopping to be able to call sampleUniform several time in the code to get new lists of random numbers but if I do runhaskell test.hs, it outputs the first character of the lis [ and then it is stuck in an apparently infinite loop.

module Main (main
            , computeArray) where

import Control.Monad
import Control.Monad.State (State, evalState, get, put)
import System.Random (StdGen, mkStdGen, random)
import Control.Applicative ((<$>))

type Rnd a = State StdGen a

runRandom :: Rnd a -> Int -> a
runRandom action seed = evalState action $ mkStdGen seed

rand :: Rnd Double
rand = do
  gen <- get
  let (r, gen') = random gen
  put gen'
  return r

{- Uniform distributions -}
uniform01 :: Rnd [Double]
uniform01 = mapM (\_ -> rand) $ repeat ()

{- Get n samples uniformly distributed between 0 and 1 -}
sampleUniform :: Int -> Rnd [Double]
sampleUniform n = liftM (take n) uniform01

computeArray :: Rnd [Bool]
computeArray = do
  samples1 <- sampleUniform 10
  samples2 <- sampleUniform 10
  let dat = zip samples1 samples2
  return $ uncurry (<) <$> dat

main :: IO ()
main = do
  let seed = 48
  let res = runRandom computeArray seed
  putStrLn $ show res

See also [Why the Haskell sequence function can't be lazy or why recursive monadic functions can't be lazy](http://stackoverflow.com/q/31892418/1333025).. — Petr, Aug 08 '15 at 12:07

Ørjan Johansen · Accepted Answer · 2015-08-08T11:21:55.890

5

uniform01 threads your state through an infinite number of computations, which means that although it produces its result lazily, there is no hope of retrieving a final state at the end to use for the next sampling. liftM (take n) only affects the final value, not the state effects used to compute it. Therefore as written, you can only use uniform01/sampleUniform once.

Instead you can thread the state through only as many rand actions as you use, e.g. with

sampleUniform n = mapM (\_ -> rand) $ replicate n ()

or simpler

sampleUniform n = sequence $ replicate n rand

edited Aug 08 '15 at 11:21

answered Aug 08 '15 at 11:15

Ørjan Johansen

18,119
3
43
53

2

Or even `replicateM n rand` – chi Aug 08 '15 at 12:09
Great, thanks for the explanation and the correct solution! – overlii Aug 08 '15 at 12:23
Now I can do antialiazing :) Next question is, can I use this State Monad in parallel? Or would it be better to have on state per thread? Might be for another week end :) – overlii Aug 08 '15 at 12:44
@olivelarouille If you want to do random numbers in parallel, you can look at the `split` function, which lets you turn one generator into several. (Which BTW could have given an alternative solution to your original problem.) – Ørjan Johansen Aug 08 '15 at 12:57

Random number sequence un Haskell and State Monad, what am I doing wrong?

1 Answers1