Simplee.Intelligence.Common 1.0.6

Boole |> Bokko

Library which implements common operations on random numbers and sequences.

Sequence Extensions

The library adds the foldt function which implements the a fold operation which can be terminated before the source sequence is fully parsed. The distinctN function, also imlemented in by this library, is based on foldt, and returns a list of n distinct values from a given source.

open Simplee

let stp lst v = 
    match v::lst with
    | lst when lst |> List.length >= 3 -> Seq.FoldDone lst
    | lst                              -> Seq.FoldContinue lst

[1;2;3;4;5] |> Seq.foldt stp [] |> List.rev |> printfn "Res: %A"
// > Res: [1; 2; 3]

[1;2;1;2;3;1;4;5;6] |> Seq.distinctN 4 |> List.rev |> printfn "Res: %A"
// > Res: [1; 2; 3; 4]

Random Monad

The library implements under the Simplee.Intelligence.Random namespace the Rnd monad which allows you to easily create flows which involve computation using random values. The Simplee.Random namespaces provide the unfold function which generates lazy sequences based on random numbers.

open Simplee.Intelligence.Random
open Simplee.Intelligence.Random.Distributions
open Simplee.Intelligence.Random.Extensions

// The state is a pair of integer and string values.
// At each step we generate a random sequece of 5 bit-values, 
// while incrementing the integer value in the internal state.
// The true flag passed to unfold function indicates that at each
// step, the random uniform sequence is generated using a new random seed.
let step (i, s) =
    Rnd.discreteUniformSeq 0 1
    |> Rnd.map (fun xs -> xs |> Seq.take 5)
    |> Rnd.map (fun r -> r, (i + 1, s))
    |> Rnd.map Some

let test seed zero =
    zero
    |> Rnd.unfold true step
    |> Rnd.map (Seq.take 10)
    |> Rnd.evalWithSeed seed
    |> Seq.iteri (fun i xs -> printfn "%d: %A" i xs)

test 0 (0, "a")

// 0: seq [1; 1; 0; 0; ...]
// 1: seq [1; 1; 1; 1; ...]
// 2: seq [1; 0; 0; 0; ...]
// ...