[m-rev.] RNGs

Mark Brown mark at mercurylang.org
Tue Aug 27 13:55:53 AEST 2019


On Tue, Aug 27, 2019 at 10:59 AM Julien Fischer <jfischer at opturion.com> wrote:
> >  Are the names "gen_uint8", etc, okay instead?
>
> I would prefer "generate_uint8" etc to the abbrevated form.  Rationale:
> we already have array.generate and I don't want to add to the situation
> we already have in the stdlib with "rev" and "reverse".

Fixed. I'll rebase and merge these changes after bootcheck finishes,
unless anyone has any other comments.

Mark
-------------- next part --------------
commit 0f1c2982d3b4aef5da3b2ee1f4833fc4663fc892
Author: Mark Brown <mark at mercurylang.org>
Date:   Tue Aug 27 13:51:44 2019 +1000

    s/gen_uint/generate_uint/g, per review comments

diff --git a/extras/random/binfile.m b/extras/random/binfile.m
index 36be4f9..14ee87c 100644
--- a/extras/random/binfile.m
+++ b/extras/random/binfile.m
@@ -43,10 +43,10 @@
     %
     % Throws an exception if the end-of-file is reached.
     %
-:- pred gen_uint8(binfile::in, uint8::out, io::di, io::uo) is det.
-:- pred gen_uint16(binfile::in, uint16::out, io::di, io::uo) is det.
-:- pred gen_uint32(binfile::in, uint32::out, io::di, io::uo) is det.
-:- pred gen_uint64(binfile::in, uint64::out, io::di, io::uo) is det.
+:- pred generate_uint8(binfile::in, uint8::out, io::di, io::uo) is det.
+:- pred generate_uint16(binfile::in, uint16::out, io::di, io::uo) is det.
+:- pred generate_uint32(binfile::in, uint32::out, io::di, io::uo) is det.
+:- pred generate_uint64(binfile::in, uint64::out, io::di, io::uo) is det.
 
 %---------------------------------------------------------------------------%
 
@@ -61,10 +61,10 @@
     --->    binfile(binary_input_stream).
 
 :- instance urandom(binfile, io) where [
-    pred(gen_uint8/4) is binfile.gen_uint8,
-    pred(gen_uint16/4) is binfile.gen_uint16,
-    pred(gen_uint32/4) is binfile.gen_uint32,
-    pred(gen_uint64/4) is binfile.gen_uint64
+    pred(generate_uint8/4) is binfile.generate_uint8,
+    pred(generate_uint16/4) is binfile.generate_uint16,
+    pred(generate_uint32/4) is binfile.generate_uint32,
+    pred(generate_uint64/4) is binfile.generate_uint64
 ].
 
 %---------------------------------------------------------------------------%
@@ -84,7 +84,7 @@ close(binfile(Stream), !IO) :-
 
 %---------------------------------------------------------------------------%
 
-gen_uint8(binfile(Stream), N, !IO) :-
+generate_uint8(binfile(Stream), N, !IO) :-
     io.read_binary_uint8(Stream, Res, !IO),
     (
         Res = ok(N)
@@ -96,15 +96,15 @@ gen_uint8(binfile(Stream), N, !IO) :-
         unexpected($pred, io.error_message(E))
     ).
 
-gen_uint16(binfile(Stream), N, !IO) :-
+generate_uint16(binfile(Stream), N, !IO) :-
     io.read_binary_uint16_be(Stream, Res, !IO),
     handle_res(Res, N).
 
-gen_uint32(binfile(Stream), N, !IO) :-
+generate_uint32(binfile(Stream), N, !IO) :-
     io.read_binary_uint32_be(Stream, Res, !IO),
     handle_res(Res, N).
 
-gen_uint64(binfile(Stream), N, !IO) :-
+generate_uint64(binfile(Stream), N, !IO) :-
     io.read_binary_uint64_be(Stream, Res, !IO),
     handle_res(Res, N).
 
diff --git a/extras/random/marsaglia.m b/extras/random/marsaglia.m
index 14699f0..1f3e086 100644
--- a/extras/random/marsaglia.m
+++ b/extras/random/marsaglia.m
@@ -39,10 +39,10 @@
     % Generate a uniformly distributed pseudo-random unsigned integer
     % of 8, 16, 32 or 64 bytes, respectively.
     %
-:- pred gen_uint8(uint8::out, random::in, random::out) is det.
-:- pred gen_uint16(uint16::out, random::in, random::out) is det.
-:- pred gen_uint32(uint32::out, random::in, random::out) is det.
-:- pred gen_uint64(uint64::out, random::in, random::out) is det.
+:- pred generate_uint8(uint8::out, random::in, random::out) is det.
+:- pred generate_uint16(uint16::out, random::in, random::out) is det.
+:- pred generate_uint32(uint32::out, random::in, random::out) is det.
+:- pred generate_uint64(uint64::out, random::in, random::out) is det.
 
 %---------------------------------------------------------------------------%
 
@@ -59,10 +59,10 @@
     --->    random(uint64).
 
 :- instance random(random) where [
-    pred(gen_uint8/3) is marsaglia.gen_uint8,
-    pred(gen_uint16/3) is marsaglia.gen_uint16,
-    pred(gen_uint32/3) is marsaglia.gen_uint32,
-    pred(gen_uint64/3) is marsaglia.gen_uint64
+    pred(generate_uint8/3) is marsaglia.generate_uint8,
+    pred(generate_uint16/3) is marsaglia.generate_uint16,
+    pred(generate_uint32/3) is marsaglia.generate_uint32,
+    pred(generate_uint64/3) is marsaglia.generate_uint64
 ].
 
 init = seed(0u32, 0u32).
@@ -74,26 +74,26 @@ seed(SX0, SY0) = R :-
 
 %---------------------------------------------------------------------------%
 
-gen_uint8(N, !R) :-
-    marsaglia.gen_uint32(N0, !R),
+generate_uint8(N, !R) :-
+    marsaglia.generate_uint32(N0, !R),
     N1 = uint32.cast_to_int(N0 >> 24),
     N = uint8.cast_from_int(N1).
 
-gen_uint16(N, !R) :-
-    marsaglia.gen_uint32(N0, !R),
+generate_uint16(N, !R) :-
+    marsaglia.generate_uint32(N0, !R),
     N1 = uint32.cast_to_int(N0 >> 16),
     N = uint16.cast_from_int(N1).
 
-gen_uint64(N, !R) :-
-    marsaglia.gen_uint32(A0, !R),
-    marsaglia.gen_uint32(B0, !R),
+generate_uint64(N, !R) :-
+    marsaglia.generate_uint32(A0, !R),
+    marsaglia.generate_uint32(B0, !R),
     A = uint32.cast_to_uint64(A0),
     B = uint32.cast_to_uint64(B0),
     N = A + (B << 32).
 
 %---------------------------------------------------------------------------%
 
-gen_uint32(N, R0, R) :-
+generate_uint32(N, R0, R) :-
     R0 = random(S0),
     unpack_uint64(S0, SX0, SY0),
     A = 18000u32,
diff --git a/extras/random/tausworthe.m b/extras/random/tausworthe.m
index 05c88f1..e0f4024 100644
--- a/extras/random/tausworthe.m
+++ b/extras/random/tausworthe.m
@@ -67,10 +67,10 @@
     % Throws an exception if the params and ustate are not the same size
     % (i.e., both 3-combo or both 4-combo).
     %
-:- pred gen_uint8(params::in, uint8::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint16(params::in, uint16::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint32(params::in, uint32::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint64(params::in, uint64::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint8(params::in, uint8::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint16(params::in, uint16::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint32(params::in, uint32::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint64(params::in, uint64::out, ustate::di, ustate::uo) is det.
 
     % Duplicate a tausworthe RNG state.
     %
@@ -105,10 +105,10 @@
             ).
 
 :- instance urandom(params, ustate) where [
-    pred(gen_uint8/4) is tausworthe.gen_uint8,
-    pred(gen_uint16/4) is tausworthe.gen_uint16,
-    pred(gen_uint32/4) is tausworthe.gen_uint32,
-    pred(gen_uint64/4) is tausworthe.gen_uint64
+    pred(generate_uint8/4) is tausworthe.generate_uint8,
+    pred(generate_uint16/4) is tausworthe.generate_uint16,
+    pred(generate_uint32/4) is tausworthe.generate_uint32,
+    pred(generate_uint64/4) is tausworthe.generate_uint64
 ].
 
 :- instance urandom_dup(ustate) where [
@@ -123,26 +123,26 @@ urandom_dup(S, S1, S2) :-
 
 %---------------------------------------------------------------------------%
 
-gen_uint8(RP, N, !RS) :-
-    tausworthe.gen_uint32(RP, N0, !RS),
+generate_uint8(RP, N, !RS) :-
+    tausworthe.generate_uint32(RP, N0, !RS),
     N1 = uint32.cast_to_int(N0 >> 24),
     N = uint8.cast_from_int(N1).
 
-gen_uint16(RP, N, !RS) :-
-    tausworthe.gen_uint32(RP, N0, !RS),
+generate_uint16(RP, N, !RS) :-
+    tausworthe.generate_uint32(RP, N0, !RS),
     N1 = uint32.cast_to_int(N0 >> 16),
     N = uint16.cast_from_int(N1).
 
-gen_uint64(RP, N, !RS) :-
-    tausworthe.gen_uint32(RP, A0, !RS),
-    tausworthe.gen_uint32(RP, B0, !RS),
+generate_uint64(RP, N, !RS) :-
+    tausworthe.generate_uint32(RP, A0, !RS),
+    tausworthe.generate_uint32(RP, B0, !RS),
     A = uint32.cast_to_uint64(A0),
     B = uint32.cast_to_uint64(B0),
     N = A + (B << 32).
 
 %---------------------------------------------------------------------------%
 
-gen_uint32(RP, N, RS0, RS) :-
+generate_uint32(RP, N, RS0, RS) :-
     RS0 = ustate(Seed0),
     Size = array.size(Seed0),
     rand(RP, 0, Size, 0u32, N, Seed0, Seed),
@@ -182,7 +182,7 @@ seed(Qs, Ps, Seed0, RP, RS) :-
     seed_2(0, Size, Ks, Ps, Ds, Shft0, Shft, Mask0, Mask, Seed0, Seed),
     RP = params(Qs, Ps, Shft, Mask),
     RS0 = unsafe_promise_unique(ustate(Seed)),
-    tausworthe.gen_uint32(RP, _, RS0, RS).
+    tausworthe.generate_uint32(RP, _, RS0, RS).
 
 :- pred seed_2(int::in, int::in, array(int)::in, array(int)::in,
     array(uint32)::in, array(int)::array_di, array(int)::array_uo,
diff --git a/library/random.m b/library/random.m
index 8c1b546..3b9873f 100644
--- a/library/random.m
+++ b/library/random.m
@@ -107,10 +107,10 @@
         % Generate a uniformly distributed pseudo-random unsigned integer
         % of 8, 16, 32 or 64 bits, respectively.
         %
-    pred gen_uint8(uint8::out, R::in, R::out) is det,
-    pred gen_uint16(uint16::out, R::in, R::out) is det,
-    pred gen_uint32(uint32::out, R::in, R::out) is det,
-    pred gen_uint64(uint64::out, R::in, R::out) is det
+    pred generate_uint8(uint8::out, R::in, R::out) is det,
+    pred generate_uint16(uint16::out, R::in, R::out) is det,
+    pred generate_uint32(uint32::out, R::in, R::out) is det,
+    pred generate_uint64(uint64::out, R::in, R::out) is det
 
 ].
 
@@ -192,10 +192,10 @@
         % Generate a uniformly distributed pseudo-random unsigned integer
         % of 8, 16, 32 or 64 bits, respectively.
         %
-    pred gen_uint8(P::in, uint8::out, S::di, S::uo) is det,
-    pred gen_uint16(P::in, uint16::out, S::di, S::uo) is det,
-    pred gen_uint32(P::in, uint32::out, S::di, S::uo) is det,
-    pred gen_uint64(P::in, uint64::out, S::di, S::uo) is det
+    pred generate_uint8(P::in, uint8::out, S::di, S::uo) is det,
+    pred generate_uint16(P::in, uint16::out, S::di, S::uo) is det,
+    pred generate_uint32(P::in, uint32::out, S::di, S::uo) is det,
+    pred generate_uint64(P::in, uint64::out, S::di, S::uo) is det
 
 ].
 
@@ -460,7 +460,7 @@
 uniform_int_in_range(Start, Range0, N, !R) :-
     Range = uint32.det_from_int(Range0),
     Max = uint32.max_uint32,
-    gen_uint32(N0, !R),
+    generate_uint32(N0, !R),
     N1 = N0 // (Max // Range),
     ( if N1 < Range then
         N = Start + uint32.cast_to_int(N1)
@@ -471,7 +471,7 @@ uniform_int_in_range(Start, Range0, N, !R) :-
 uniform_uint_in_range(Start, Range0, N, !R) :-
     Range = uint32.cast_from_uint(Range0),
     Max = uint32.max_uint32,
-    gen_uint32(N0, !R),
+    generate_uint32(N0, !R),
     N1 = N0 // (Max // Range),
     ( if N1 < Range then
         N = Start + uint32.cast_to_uint(N1)
@@ -492,7 +492,7 @@ uniform_float_around_mid(Mid, Delta, N, !R) :-
     ).
 
 uniform_float_in_01(N, !R) :-
-    gen_uint64(N0, !R),
+    generate_uint64(N0, !R),
     D = 18_446_744_073_709_551_616.0,       % 2^64
     N = float.cast_from_uint64(N0) / D.
 
@@ -516,7 +516,7 @@ normal_floats(U, V, !R) :-
 uniform_int_in_range(P, Start, Range0, N, !S) :-
     Range = uint32.det_from_int(Range0),
     Max = uint32.max_uint32,
-    gen_uint32(P, N0, !S),
+    generate_uint32(P, N0, !S),
     N1 = N0 // (Max // Range),
     ( if N1 < Range then
         N = Start + uint32.cast_to_int(N1)
@@ -527,7 +527,7 @@ uniform_int_in_range(P, Start, Range0, N, !S) :-
 uniform_uint_in_range(P, Start, Range0, N, !S) :-
     Range = uint32.cast_from_uint(Range0),
     Max = uint32.max_uint32,
-    gen_uint32(P, N0, !S),
+    generate_uint32(P, N0, !S),
     N1 = N0 // (Max // Range),
     ( if N1 < Range then
         N = Start + uint32.cast_to_uint(N1)
@@ -548,7 +548,7 @@ uniform_float_around_mid(P, Mid, Delta, N, !S) :-
     ).
 
 uniform_float_in_01(P, N, !S) :-
-    gen_uint64(P, N0, !S),
+    generate_uint64(P, N0, !S),
     D = 18_446_744_073_709_551_616.0,       % 2^64
     N = float.cast_from_uint64(N0) / D.
 
@@ -590,24 +590,24 @@ uniform_to_normal(X, Y, U, V) :-
     --->    urandom_state(R).
 
 :- instance urandom(urandom_params(R), urandom_state(R)) <= random(R) where [
-    ( gen_uint8(_, N, S0, S) :-
+    ( generate_uint8(_, N, S0, S) :-
         S0 = urandom_state(R0),
-        gen_uint8(N, R0, R),
+        generate_uint8(N, R0, R),
         S = unsafe_promise_unique(urandom_state(R))
     ),
-    ( gen_uint16(_, N, S0, S) :-
+    ( generate_uint16(_, N, S0, S) :-
         S0 = urandom_state(R0),
-        gen_uint16(N, R0, R),
+        generate_uint16(N, R0, R),
         S = unsafe_promise_unique(urandom_state(R))
     ),
-    ( gen_uint32(_, N, S0, S) :-
+    ( generate_uint32(_, N, S0, S) :-
         S0 = urandom_state(R0),
-        gen_uint32(N, R0, R),
+        generate_uint32(N, R0, R),
         S = unsafe_promise_unique(urandom_state(R))
     ),
-    ( gen_uint64(_, N, S0, S) :-
+    ( generate_uint64(_, N, S0, S) :-
         S0 = urandom_state(R0),
-        gen_uint64(N, R0, R),
+        generate_uint64(N, R0, R),
         S = unsafe_promise_unique(urandom_state(R))
     )
 ].
@@ -633,32 +633,32 @@ make_urandom(R, P, S) :-
 
 :- instance random(shared_random(P, S)) <= (urandom(P, S), urandom_dup(S))
         where [
-    ( gen_uint8(N, R0, R) :-
+    ( generate_uint8(N, R0, R) :-
         R0 = shared_random(P, S0),
         S1 = unsafe_promise_unique(S0),
         urandom_dup(S1, _, S2),
-        gen_uint8(P, N, S2, S),
+        generate_uint8(P, N, S2, S),
         R = shared_random(P, S)
     ),
-    ( gen_uint16(N, R0, R) :-
+    ( generate_uint16(N, R0, R) :-
         R0 = shared_random(P, S0),
         S1 = unsafe_promise_unique(S0),
         urandom_dup(S1, _, S2),
-        gen_uint16(P, N, S2, S),
+        generate_uint16(P, N, S2, S),
         R = shared_random(P, S)
     ),
-    ( gen_uint32(N, R0, R) :-
+    ( generate_uint32(N, R0, R) :-
         R0 = shared_random(P, S0),
         S1 = unsafe_promise_unique(S0),
         urandom_dup(S1, _, S2),
-        gen_uint32(P, N, S2, S),
+        generate_uint32(P, N, S2, S),
         R = shared_random(P, S)
     ),
-    ( gen_uint64(N, R0, R) :-
+    ( generate_uint64(N, R0, R) :-
         R0 = shared_random(P, S0),
         S1 = unsafe_promise_unique(S0),
         urandom_dup(S1, _, S2),
-        gen_uint64(P, N, S2, S),
+        generate_uint64(P, N, S2, S),
         R = shared_random(P, S)
     )
 ].
@@ -671,10 +671,10 @@ make_shared_random(P, S) = shared_random(P, S).
     --->    io_random(mutvar(R)).
 
 :- instance urandom(io_random(R), io) <= random(R) where [
-    pred(gen_uint8/4) is io_random_gen_uint8,
-    pred(gen_uint16/4) is io_random_gen_uint16,
-    pred(gen_uint32/4) is io_random_gen_uint32,
-    pred(gen_uint64/4) is io_random_gen_uint64
+    pred(generate_uint8/4) is io_random_gen_uint8,
+    pred(generate_uint16/4) is io_random_gen_uint16,
+    pred(generate_uint32/4) is io_random_gen_uint32,
+    pred(generate_uint64/4) is io_random_gen_uint64
 ].
 
 :- pred io_random_gen_uint8(io_random(R)::in, uint8::out, io::di, io::uo)
@@ -683,7 +683,7 @@ make_shared_random(P, S) = shared_random(P, S).
 
 io_random_gen_uint8(io_random(V), N, !IO) :-
     impure get_mutvar(V, R0),
-    gen_uint8(N, R0, R),
+    generate_uint8(N, R0, R),
     impure set_mutvar(V, R).
 
 :- pred io_random_gen_uint16(io_random(R)::in, uint16::out, io::di, io::uo)
@@ -692,7 +692,7 @@ io_random_gen_uint8(io_random(V), N, !IO) :-
 
 io_random_gen_uint16(io_random(V), N, !IO) :-
     impure get_mutvar(V, R0),
-    gen_uint16(N, R0, R),
+    generate_uint16(N, R0, R),
     impure set_mutvar(V, R).
 
 :- pred io_random_gen_uint32(io_random(R)::in, uint32::out, io::di, io::uo)
@@ -701,7 +701,7 @@ io_random_gen_uint16(io_random(V), N, !IO) :-
 
 io_random_gen_uint32(io_random(V), N, !IO) :-
     impure get_mutvar(V, R0),
-    gen_uint32(N, R0, R),
+    generate_uint32(N, R0, R),
     impure set_mutvar(V, R).
 
 :- pred io_random_gen_uint64(io_random(R)::in, uint64::out, io::di, io::uo)
@@ -710,7 +710,7 @@ io_random_gen_uint32(io_random(V), N, !IO) :-
 
 io_random_gen_uint64(io_random(V), N, !IO) :-
     impure get_mutvar(V, R0),
-    gen_uint64(N, R0, R),
+    generate_uint64(N, R0, R),
     impure set_mutvar(V, R).
 
 :- pragma promise_pure(make_io_random/4).
@@ -725,10 +725,10 @@ make_io_random(R, Pio, !IO) :-
     --->    io_urandom(P, mutvar(S)).
 
 :- instance urandom(io_urandom(P, S), io) <= urandom(P, S) where [
-    pred(gen_uint8/4) is io_urandom_gen_uint8,
-    pred(gen_uint16/4) is io_urandom_gen_uint16,
-    pred(gen_uint32/4) is io_urandom_gen_uint32,
-    pred(gen_uint64/4) is io_urandom_gen_uint64
+    pred(generate_uint8/4) is io_urandom_gen_uint8,
+    pred(generate_uint16/4) is io_urandom_gen_uint16,
+    pred(generate_uint32/4) is io_urandom_gen_uint32,
+    pred(generate_uint64/4) is io_urandom_gen_uint64
 ].
 
 :- pred io_urandom_gen_uint8(io_urandom(P, S)::in, uint8::out, io::di, io::uo)
@@ -738,7 +738,7 @@ make_io_random(R, Pio, !IO) :-
 io_urandom_gen_uint8(io_urandom(P, V), N, !IO) :-
     impure get_mutvar(V, S0),
     S1 = unsafe_promise_unique(S0),
-    gen_uint8(P, N, S1, S),
+    generate_uint8(P, N, S1, S),
     impure set_mutvar(V, S).
 
 :- pred io_urandom_gen_uint16(io_urandom(P, S)::in, uint16::out, io::di, io::uo)
@@ -748,7 +748,7 @@ io_urandom_gen_uint8(io_urandom(P, V), N, !IO) :-
 io_urandom_gen_uint16(io_urandom(P, V), N, !IO) :-
     impure get_mutvar(V, S0),
     S1 = unsafe_promise_unique(S0),
-    gen_uint16(P, N, S1, S),
+    generate_uint16(P, N, S1, S),
     impure set_mutvar(V, S).
 
 :- pred io_urandom_gen_uint32(io_urandom(P, S)::in, uint32::out, io::di, io::uo)
@@ -758,7 +758,7 @@ io_urandom_gen_uint16(io_urandom(P, V), N, !IO) :-
 io_urandom_gen_uint32(io_urandom(P, V), N, !IO) :-
     impure get_mutvar(V, S0),
     S1 = unsafe_promise_unique(S0),
-    gen_uint32(P, N, S1, S),
+    generate_uint32(P, N, S1, S),
     impure set_mutvar(V, S).
 
 :- pred io_urandom_gen_uint64(io_urandom(P, S)::in, uint64::out, io::di, io::uo)
@@ -768,7 +768,7 @@ io_urandom_gen_uint32(io_urandom(P, V), N, !IO) :-
 io_urandom_gen_uint64(io_urandom(P, V), N, !IO) :-
     impure get_mutvar(V, S0),
     S1 = unsafe_promise_unique(S0),
-    gen_uint64(P, N, S1, S),
+    generate_uint64(P, N, S1, S),
     impure set_mutvar(V, S).
 
 :- pragma promise_pure(make_io_urandom/5).
diff --git a/library/random.sfc16.m b/library/random.sfc16.m
index 9c6068c..85c39d3 100644
--- a/library/random.sfc16.m
+++ b/library/random.sfc16.m
@@ -42,10 +42,10 @@
     % Generate a uniformly distributed pseudo-random unsigned integer
     % of 8, 16, 32 or 64 bits, respectively.
     %
-:- pred gen_uint8(uint8::out, random::in, random::out) is det.
-:- pred gen_uint16(uint16::out, random::in, random::out) is det.
-:- pred gen_uint32(uint32::out, random::in, random::out) is det.
-:- pred gen_uint64(uint64::out, random::in, random::out) is det.
+:- pred generate_uint8(uint8::out, random::in, random::out) is det.
+:- pred generate_uint16(uint16::out, random::in, random::out) is det.
+:- pred generate_uint32(uint32::out, random::in, random::out) is det.
+:- pred generate_uint64(uint64::out, random::in, random::out) is det.
 
 %---------------------------------------------------------------------------%
 %---------------------------------------------------------------------------%
@@ -65,10 +65,10 @@
     --->    random(uint64).
 
 :- instance random(random) where [
-    pred(gen_uint8/3) is sfc16.gen_uint8,
-    pred(gen_uint16/3) is sfc16.gen_uint16,
-    pred(gen_uint32/3) is sfc16.gen_uint32,
-    pred(gen_uint64/3) is sfc16.gen_uint64
+    pred(generate_uint8/3) is sfc16.generate_uint8,
+    pred(generate_uint16/3) is sfc16.generate_uint16,
+    pred(generate_uint32/3) is sfc16.generate_uint32,
+    pred(generate_uint64/3) is sfc16.generate_uint64
 ].
 
 init = seed(0x6048_5623_5e79_371e_u64).
@@ -80,7 +80,7 @@ seed(Seed) = R :-
 
 skip(N, !R) :-
     ( if N > 0 then
-        sfc16.gen_uint16(_, !R),
+        sfc16.generate_uint16(_, !R),
         skip(N - 1, !R)
     else
         true
@@ -88,28 +88,28 @@ skip(N, !R) :-
 
 %---------------------------------------------------------------------------%
 
-gen_uint8(N, !R) :-
-    sfc16.gen_uint16(N0, !R),
+generate_uint8(N, !R) :-
+    sfc16.generate_uint16(N0, !R),
     N1 = uint16.to_int(N0 >> 8),
     N = uint8.cast_from_int(N1).
 
-gen_uint32(N, !R) :-
-    sfc16.gen_uint16(A0, !R),
-    sfc16.gen_uint16(B0, !R),
+generate_uint32(N, !R) :-
+    sfc16.generate_uint16(A0, !R),
+    sfc16.generate_uint16(B0, !R),
     A = uint16.cast_to_uint(A0),
     B = uint16.cast_to_uint(B0),
     N = uint32.cast_from_uint(A + (B << 16)).
 
-gen_uint64(N, !R) :-
-    sfc16.gen_uint16(A, !R),
-    sfc16.gen_uint16(B, !R),
-    sfc16.gen_uint16(C, !R),
-    sfc16.gen_uint16(D, !R),
+generate_uint64(N, !R) :-
+    sfc16.generate_uint16(A, !R),
+    sfc16.generate_uint16(B, !R),
+    sfc16.generate_uint16(C, !R),
+    sfc16.generate_uint16(D, !R),
     N = pack_uint64(A, B, C, D).
 
 %---------------------------------------------------------------------------%
 
-gen_uint16(N, random(S0), random(S)) :-
+generate_uint16(N, random(S0), random(S)) :-
     unpack_uint64(S0, A0, B0, C0, Counter0),
     N = A0 + B0 + Counter0,
     A = B0 `xor` (B0 >> 5),
diff --git a/library/random.sfc32.m b/library/random.sfc32.m
index 87c2a7f..903b1e7 100644
--- a/library/random.sfc32.m
+++ b/library/random.sfc32.m
@@ -48,10 +48,10 @@
     % Generate a uniformly distributed pseudo-random unsigned integer
     % of 8, 16, 32 or 64 bits, respectively.
     %
-:- pred gen_uint8(params::in, uint8::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint16(params::in, uint16::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint32(params::in, uint32::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint64(params::in, uint64::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint8(params::in, uint8::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint16(params::in, uint16::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint32(params::in, uint32::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint64(params::in, uint64::out, ustate::di, ustate::uo) is det.
 
     % Duplicate a 32-bit SFC state.
     %
@@ -65,10 +65,10 @@
     % As above, but does not require the params argument (which is a dummy
     % type only needed to satisfy the typeclass interface).
     %
-:- pred gen_uint8(uint8::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint16(uint16::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint32(uint32::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint64(uint64::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint8(uint8::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint16(uint16::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint32(uint32::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint64(uint64::out, ustate::di, ustate::uo) is det.
 
 %---------------------------------------------------------------------------%
 %---------------------------------------------------------------------------%
@@ -92,10 +92,10 @@
     --->    ustate(array(uint32)).
 
 :- instance urandom(params, ustate) where [
-    pred(gen_uint8/4) is sfc32.gen_uint8,
-    pred(gen_uint16/4) is sfc32.gen_uint16,
-    pred(gen_uint32/4) is sfc32.gen_uint32,
-    pred(gen_uint64/4) is sfc32.gen_uint64
+    pred(generate_uint8/4) is sfc32.generate_uint8,
+    pred(generate_uint16/4) is sfc32.generate_uint16,
+    pred(generate_uint32/4) is sfc32.generate_uint32,
+    pred(generate_uint64/4) is sfc32.generate_uint64
 ].
 
 :- instance urandom_dup(ustate) where [
@@ -123,7 +123,7 @@ seed(A, B, C, params, S) :-
 
 skip(N, !S) :-
     ( if N > 0 then
-        sfc32.gen_uint32(_, !S),
+        sfc32.generate_uint32(_, !S),
         skip(N - 1, !S)
     else
         true
@@ -131,40 +131,40 @@ skip(N, !S) :-
 
 %---------------------------------------------------------------------------%
 
-gen_uint8(_, N, !S) :-
-    sfc32.gen_uint8(N, !S).
+generate_uint8(_, N, !S) :-
+    sfc32.generate_uint8(N, !S).
 
-gen_uint16(_, N, !S) :-
-    sfc32.gen_uint16(N, !S).
+generate_uint16(_, N, !S) :-
+    sfc32.generate_uint16(N, !S).
 
-gen_uint32(_, N, !S) :-
-    sfc32.gen_uint32(N, !S).
+generate_uint32(_, N, !S) :-
+    sfc32.generate_uint32(N, !S).
 
-gen_uint64(_, N, !S) :-
-    sfc32.gen_uint64(N, !S).
+generate_uint64(_, N, !S) :-
+    sfc32.generate_uint64(N, !S).
 
 %---------------------------------------------------------------------------%
 
-gen_uint8(N, !S) :-
-    sfc32.gen_uint32(N0, !S),
+generate_uint8(N, !S) :-
+    sfc32.generate_uint32(N0, !S),
     N1 = uint32.cast_to_int(N0 >> 24),
     N = uint8.cast_from_int(N1).
 
-gen_uint16(N, !S) :-
-    sfc32.gen_uint32(N0, !S),
+generate_uint16(N, !S) :-
+    sfc32.generate_uint32(N0, !S),
     N1 = uint32.cast_to_int(N0 >> 16),
     N = uint16.cast_from_int(N1).
 
-gen_uint64(N, !S) :-
-    sfc32.gen_uint32(A0, !S),
-    sfc32.gen_uint32(B0, !S),
+generate_uint64(N, !S) :-
+    sfc32.generate_uint32(A0, !S),
+    sfc32.generate_uint32(B0, !S),
     A = uint32.cast_to_uint64(A0),
     B = uint32.cast_to_uint64(B0),
     N = A + (B << 32).
 
 %---------------------------------------------------------------------------%
 
-gen_uint32(N, RS0, RS) :-
+generate_uint32(N, RS0, RS) :-
     RS0 = ustate(S0),
     array.unsafe_lookup(S0, 0, A0),
     array.unsafe_lookup(S0, 1, B0),
diff --git a/library/random.sfc64.m b/library/random.sfc64.m
index 9b2d47b..f3a1501 100644
--- a/library/random.sfc64.m
+++ b/library/random.sfc64.m
@@ -45,10 +45,10 @@
     % Generate a uniformly distributed pseudo-random unsigned integer
     % of 8, 16, 32 or 64 bits, respectively.
     %
-:- pred gen_uint8(params::in, uint8::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint16(params::in, uint16::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint32(params::in, uint32::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint64(params::in, uint64::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint8(params::in, uint8::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint16(params::in, uint16::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint32(params::in, uint32::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint64(params::in, uint64::out, ustate::di, ustate::uo) is det.
 
     % Duplicate a 64-bit SFC state.
     %
@@ -62,10 +62,10 @@
     % As above, but does not require the params argument (which is a dummy
     % type only needed to satisfy the typeclass interface).
     %
-:- pred gen_uint8(uint8::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint16(uint16::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint32(uint32::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint64(uint64::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint8(uint8::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint16(uint16::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint32(uint32::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint64(uint64::out, ustate::di, ustate::uo) is det.
 
 %---------------------------------------------------------------------------%
 %---------------------------------------------------------------------------%
@@ -89,10 +89,10 @@
     --->    ustate(array(uint64)).
 
 :- instance urandom(params, ustate) where [
-    pred(gen_uint8/4) is sfc64.gen_uint8,
-    pred(gen_uint16/4) is sfc64.gen_uint16,
-    pred(gen_uint32/4) is sfc64.gen_uint32,
-    pred(gen_uint64/4) is sfc64.gen_uint64
+    pred(generate_uint8/4) is sfc64.generate_uint8,
+    pred(generate_uint16/4) is sfc64.generate_uint16,
+    pred(generate_uint32/4) is sfc64.generate_uint32,
+    pred(generate_uint64/4) is sfc64.generate_uint64
 ].
 
 :- instance urandom_dup(ustate) where [
@@ -124,7 +124,7 @@ seed(A, B, C, params, S) :-
 
 skip(N, !S) :-
     ( if N > 0 then
-        sfc64.gen_uint64(_, !S),
+        sfc64.generate_uint64(_, !S),
         skip(N - 1, !S)
     else
         true
@@ -132,37 +132,37 @@ skip(N, !S) :-
 
 %---------------------------------------------------------------------------%
 
-gen_uint8(_, N, !S) :-
-    sfc64.gen_uint8(N, !S).
+generate_uint8(_, N, !S) :-
+    sfc64.generate_uint8(N, !S).
 
-gen_uint16(_, N, !S) :-
-    sfc64.gen_uint16(N, !S).
+generate_uint16(_, N, !S) :-
+    sfc64.generate_uint16(N, !S).
 
-gen_uint32(_, N, !S) :-
-    sfc64.gen_uint32(N, !S).
+generate_uint32(_, N, !S) :-
+    sfc64.generate_uint32(N, !S).
 
-gen_uint64(_, N, !S) :-
-    sfc64.gen_uint64(N, !S).
+generate_uint64(_, N, !S) :-
+    sfc64.generate_uint64(N, !S).
 
 %---------------------------------------------------------------------------%
 
-gen_uint8(N, !S) :-
-    sfc64.gen_uint64(N0, !S),
+generate_uint8(N, !S) :-
+    sfc64.generate_uint64(N0, !S),
     N1 = uint64.cast_to_int(N0 >> 56),
     N = uint8.cast_from_int(N1).
 
-gen_uint16(N, !S) :-
-    sfc64.gen_uint64(N0, !S),
+generate_uint16(N, !S) :-
+    sfc64.generate_uint64(N0, !S),
     N1 = uint64.cast_to_int(N0 >> 48),
     N = uint16.cast_from_int(N1).
 
-gen_uint32(N, !S) :-
-    sfc64.gen_uint64(N0, !S),
+generate_uint32(N, !S) :-
+    sfc64.generate_uint64(N0, !S),
     N = uint32.cast_from_uint64(N0 >> 32).
 
 %---------------------------------------------------------------------------%
 
-gen_uint64(N, RS0, RS) :-
+generate_uint64(N, RS0, RS) :-
     RS0 = ustate(S0),
     array.unsafe_lookup(S0, 0, A0),
     array.unsafe_lookup(S0, 1, B0),
diff --git a/tests/hard_coded/random1.m b/tests/hard_coded/random1.m
index b0f7827..6e77644 100644
--- a/tests/hard_coded/random1.m
+++ b/tests/hard_coded/random1.m
@@ -37,7 +37,7 @@ main(!IO) :-
 
 test(Count, RP, !RS, !IO) :-
     ( if Count > 0 then
-        random.gen_uint64(RP, N, !RS),
+        random.generate_uint64(RP, N, !RS),
         A = cast_to_int(N >> 32),
         B = cast_to_int(N /\ 0xffffffffu64),
         io.format("%08x%08x\n", [i(A), i(B)], !IO),
diff --git a/tests/hard_coded/random2.m b/tests/hard_coded/random2.m
index 5f53391..06709f0 100644
--- a/tests/hard_coded/random2.m
+++ b/tests/hard_coded/random2.m
@@ -38,7 +38,7 @@ main(!IO) :-
 
 test(Count, !R, !IO) :-
     ( if Count > 0 then
-        random.gen_uint64(N, !R),
+        random.generate_uint64(N, !R),
         A = cast_to_int(N >> 32),
         B = cast_to_int(N /\ 0xffffffffu64),
         io.format("%08x%08x\n", [i(A), i(B)], !IO),
diff --git a/tests/hard_coded/random3.m b/tests/hard_coded/random3.m
index fcadb6c..ad0b411 100644
--- a/tests/hard_coded/random3.m
+++ b/tests/hard_coded/random3.m
@@ -38,7 +38,7 @@ main(!IO) :-
 
 test(Count, M, !IO) :-
     ( if Count > 0 then
-        random.gen_uint64(M, N, !IO),
+        random.generate_uint64(M, N, !IO),
         A = cast_to_int(N >> 32),
         B = cast_to_int(N /\ 0xffffffffu64),
         io.format("%08x%08x\n", [i(A), i(B)], !IO),


More information about the reviews mailing list