Add PCG64DXSM variant of the PCG64 bitgenerator.

Author: Pass Automated Testing Suite

lib/bitgen.ml

@@ -29,6 +29,7 @@ module SeedSequence = Seed.SeedSequence
 
 module SFC64 = Sfc.SFC64
 module PCG64 = Pcg.PCG64
+module PCG64DXSM = Pcg.PCG64DXSM
 module Xoshiro256 = Xoshiro.Xoshiro256StarStar
 module Philox4x64 = Philox.Philox
 module ChaCha = Chacha.ChaCha128Counter

lib/pcg.ml

@@ -6,7 +6,7 @@
 open Stdint
 
 
-module PCG64 : sig
+module type PCG_TYPE = sig
     (** PCG-64 is a 128-bit implementation of O'Neill's permutation congruential
         generator. PCG-64 has a period of {m 2^{128}} and supports advancing an arbitrary
         number of steps as well as {m 2^{127}} streams.
@@ -27,7 +27,19 @@ module PCG64 : sig
     val next_bounded_uint64 : uint64 -> t -> uint64 * t
     (** [next_bounded_uint64 bound t] returns an unsigned 64bit integers in the range
         (0, bound) as well as the state of the generator advanced one step forward. *)
-end = struct
+end
+
+
+module type FUNCTOR_SIG = sig
+    type t = {s : setseq; ustore : uint32 option}
+    and setseq = {state : uint128; increment : uint128}
+    val multiplier : uint128
+    val output : uint128 -> uint64
+    val next : setseq -> uint64 * setseq
+end
+
+
+module PCG64Impl = struct
     type t = {s : setseq; ustore : uint32 option}
     and setseq = {state : uint128; increment : uint128}
 
@@ -45,11 +57,38 @@ end = struct
     let next {state; increment} =
         let state' = Uint128.(state * multiplier + increment) in
         output state', {state = state'; increment}
+end
+
+
+module PCG64DXSMImpl = struct
+    type t = {s : setseq; ustore : uint32 option}
+    and setseq = {state : uint128; increment : uint128}
+
+    let cheap_multiplier = Uint64.of_string "0xda942042e4dd58b5"
+    let const128bit hi lo = Uint128.(shift_left (of_uint64 hi) 64 + of_uint64 lo)
+    let multiplier = const128bit Uint64.zero cheap_multiplier
+
+
+    let output state =
+        let hi0 = Uint128.(shift_right state 64 |> to_uint64) in
+        let hi1 = Uint64.(shift_right hi0 32 |> logxor hi0) in
+        let hi2 = Uint64.(hi1 * cheap_multiplier) in
+        let hi3 = Uint64.(shift_right hi2 48 |> logxor hi2) in
+        Uint64.(Uint128.(logor state one |> to_uint64) * hi3)
+
+
+    let next {state; increment} =
+        output state, {state = Uint128.(state * multiplier + increment); increment}
+end
+
+
+module Make (M : FUNCTOR_SIG) = struct
+    include M
 
 
     let next_uint64 t = match next t.s with
         | u, s -> u, {t with s}
-    
+
 
     let next_uint32 t =
         match Common.next_uint32 ~next:next t.s t.ustore with
@@ -83,3 +122,7 @@ end = struct
     let initialize seed =
         {s = set_seed (Seed.SeedSequence.generate_64bit_state 4 seed); ustore = None}
 end
+
+
+module PCG64DXSM : PCG_TYPE = Make (PCG64DXSMImpl)
+module PCG64 : PCG_TYPE = Make (PCG64Impl)

test/test_pcg.ml

@@ -18,7 +18,13 @@ let test_pcg_datasets _ =
         (Sys.getcwd () ^ "/../../../test/data/pcg64-testset-1.csv");
     Testconf.bitgen_groundtruth
         (module PCG64)
-        (Sys.getcwd () ^ "/../../../test/data/pcg64-testset-2.csv")
+        (Sys.getcwd () ^ "/../../../test/data/pcg64-testset-2.csv");
+    Testconf.bitgen_groundtruth
+        (module PCG64DXSM)
+        (Sys.getcwd () ^ "/../../../test/data/pcg64dxsm-testset-1.csv");
+    Testconf.bitgen_groundtruth
+        (module PCG64DXSM)
+        (Sys.getcwd () ^ "/../../../test/data/pcg64dxsm-testset-2.csv")
 
 
 let test_bounded_u64 _ = Testconf.test_bounded_u64 (module PCG64)