Random number generator
| Constructor | Description | 
| 
            new()
          
            Signature: unit -> Rnd | 
| Static member | Description | 
| 
            Choice(a, probs)
          
            Signature: (a:'a [] * probs:DV) -> 'a Type parameters: 'a | Select a random element of array  | 
| 
            Choice(a, probs)
          
            Signature: (a:'?109143 [] * probs:float32 []) -> '?109143 Type parameters: '?109143 | Select a random element of array  | 
| 
            Choice(a)
          
            Signature: (a:'?109141 []) -> '?109141 Type parameters: '?109141 | Select a random element of array  | 
| 
            Normal(mu, sigma)
          
            Signature: (mu:float32 * sigma:float32) -> float32 | Sample a  | 
| 
            Normal()
          
            Signature: unit -> float32 | Sample a  | 
| 
            NormalD(mu, sigma)
          
            Signature: (mu:D * sigma:D) -> D | Sample a  | 
| 
            NormalD()
          
            Signature: unit -> D | Sample a  | 
| 
            NormalDM(m, n, mu, sigma)
          
            Signature: (m:int * n:int * mu:D * sigma:D) -> DM | Sample a  | 
| 
            NormalDM(m, n)
          
            Signature: (m:int * n:int) -> DM | Sample a  | 
| 
            NormalDV(n, mu, sigma)
          
            Signature: (n:int * mu:D * sigma:D) -> DV | Sample a  | 
| 
            NormalDV(n)
          
            Signature: n:int -> DV | Sample a  | 
| 
            Permutation(n)
          
            Signature: n:int -> int [] | Generate a random permutation of a set of length  | 
| 
            Seed(seed)
          
            Signature: seed:int -> unit | Seed the random number generator with integer  | 
| 
            Uniform(min, max)
          
            Signature: (min:float32 * max:float32) -> float32 | Sample a  | 
| 
            Uniform(max)
          
            Signature: max:float32 -> float32 | Sample a  | 
| 
            Uniform()
          
            Signature: unit -> float32 | Sample a  | 
| 
            UniformD(min, max)
          
            Signature: (min:D * max:D) -> D | Sample a  | 
| 
            UniformD(max)
          
            Signature: max:D -> D | Sample a  | 
| 
            UniformD()
          
            Signature: unit -> D | Sample a  | 
| 
            UniformDM(m, n, min, max)
          
            Signature: (m:int * n:int * min:D * max:D) -> DM | Sample a  | 
| 
            UniformDM(m, n, max)
          
            Signature: (m:int * n:int * max:D) -> DM | Sample a  | 
| 
            UniformDM(m, n)
          
            Signature: (m:int * n:int) -> DM | Sample a  | 
| 
            UniformDV(n, min, max)
          
            Signature: (n:int * min:D * max:D) -> DV | Sample a  | 
| 
            UniformDV(n, max)
          
            Signature: (n:int * max:D) -> DV | Sample a  | 
| 
            UniformDV(n)
          
            Signature: n:int -> DV | Sample a  | 
| 
            UniformInt(min, max)
          
            Signature: (min:int * max:int) -> int | Sample a random integer between  | 
| 
            UniformInt(max)
          
            Signature: max:int -> int | Sample a non-negative random integer less than  | 
| 
            UniformInt()
          
            Signature: unit -> int | Sample a non-negative random integer |