File 2871-Clean-up-code.patch of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 2871-Clean-up-code.patch of Package erlang

From 5f6aa65d086a86b88953d57f04b18dee0155c253 Mon Sep 17 00:00:00 2001
From: Raimo Niskanen <raimo@erlang.org>
Date: Tue, 8 Dec 2020 16:31:21 +0100
Subject: [PATCH 1/6] Clean up code

Use Alg and AlgHandler in the right places.
---
 lib/stdlib/src/rand.erl | 165 +++++++++++++++++++++-------------------
 1 file changed, 85 insertions(+), 80 deletions(-)

diff --git a/lib/stdlib/src/rand.erl b/lib/stdlib/src/rand.erl
index 3a9a1e007b..b743bd5798 100644
--- a/lib/stdlib/src/rand.erl
+++ b/lib/stdlib/src/rand.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2015-2018. All Rights Reserved.
+%% Copyright Ericsson AB 2015-2020. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -147,32 +147,32 @@
 %% =====================================================================
 
 -define(
-   uniform_range(Range, Alg, R, V, MaxMinusRange, I),
+   uniform_range(Range, AlgHandler, R, V, MaxMinusRange, I),
    if
        0 =< (MaxMinusRange) ->
            if
                %% Really work saving in odd cases;
                %% large ranges in particular
                (V) < (Range) ->
-                   {(V) + 1, {(Alg), (R)}};
+                   {(V) + 1, {(AlgHandler), (R)}};
                true ->
                    (I) = (V) rem (Range),
                    if
                        (V) - (I) =< (MaxMinusRange) ->
-                           {(I) + 1, {(Alg), (R)}};
+                           {(I) + 1, {(AlgHandler), (R)}};
                        true ->
                            %% V in the truncated top range
                            %% - try again
-                           ?FUNCTION_NAME((Range), {(Alg), (R)})
+                           ?FUNCTION_NAME((Range), {(AlgHandler), (R)})
                    end
            end;
        true ->
-           uniform_range((Range), (Alg), (R), (V))
+           uniform_range((Range), (AlgHandler), (R), (V))
    end).
 
 %% For ranges larger than the algorithm bit size
-uniform_range(Range, #{next:=Next, bits:=Bits} = Alg, R, V) ->
-    WeakLowBits = maps:get(weak_low_bits, Alg, 0),
+uniform_range(Range, #{next:=Next, bits:=Bits} = AlgHandler, R, V) ->
+    WeakLowBits = maps:get(weak_low_bits, AlgHandler, 0),
     %% Maybe waste the lowest bit(s) when shifting in new bits
     Shift = Bits - WeakLowBits,
     ShiftMask = bnot ?MASK(WeakLowBits),
@@ -183,7 +183,7 @@ uniform_range(Range, #{next:=Next, bits:=Bits} = Alg, R, V) ->
             {V1, R1, _} =
                 uniform_range(
                   Range bsr Bits, Next, R, V, ShiftMask, Shift, Bits),
-            {(V1 band RangeMinus1) + 1, {Alg, R1}};
+            {(V1 band RangeMinus1) + 1, {AlgHandler, R1}};
         true ->
             %% Generate a value with at least two bits more than the range
             %% and try that for a fit, otherwise recurse
@@ -203,12 +203,12 @@ uniform_range(Range, #{next:=Next, bits:=Bits} = Alg, R, V) ->
             I = V1 rem Range,
             if
                 (V1 - I) =< (1 bsl B) - Range ->
-                    {I + 1, {Alg, R1}};
+                    {I + 1, {AlgHandler, R1}};
                 true ->
                     %% V1 drawn from the truncated top range
                     %% - try again
                     {V2, R2} = Next(R1),
-                    uniform_range(Range, Alg, R2, V2)
+                    uniform_range(Range, AlgHandler, R2, V2)
             end
     end.
 %%
@@ -230,10 +230,10 @@ uniform_range(Range, Next, R, V, ShiftMask, Shift, B) ->
 %% =====================================================================
 
 %% Return algorithm and seed so that RNG state can be recreated with seed/1
--spec export_seed() -> undefined | export_state().
+-spec export_seed() -> 'undefined' | export_state().
 export_seed() ->
     case get(?SEED_DICT) of
-	{#{type:=Alg}, Seed} -> {Alg, Seed};
+	{#{type:=Alg}, AlgState} -> {Alg, AlgState};
 	_ -> undefined
     end.
 
@@ -307,14 +307,14 @@ uniform(N) ->
 -spec uniform_s(State :: state()) -> {X :: float(), NewState :: state()}.
 uniform_s(State = {#{uniform:=Uniform}, _}) ->
     Uniform(State);
-uniform_s({#{bits:=Bits, next:=Next} = Alg, R0}) ->
+uniform_s({#{bits:=Bits, next:=Next} = AlgHandler, R0}) ->
     {V, R1} = Next(R0),
     %% Produce floats on the form N * 2^(-53)
-    {(V bsr (Bits - 53)) * ?TWO_POW_MINUS53, {Alg, R1}};
-uniform_s({#{max:=Max, next:=Next} = Alg, R0}) ->
+    {(V bsr (Bits - 53)) * ?TWO_POW_MINUS53, {AlgHandler, R1}};
+uniform_s({#{max:=Max, next:=Next} = AlgHandler, R0}) ->
     {V, R1} = Next(R0),
     %% Old algorithm with non-uniform density
-    {V / (Max + 1), {Alg, R1}}.
+    {V / (Max + 1), {AlgHandler, R1}}.
 
 
 %% uniform_s/2: given an integer N >= 1 and a state, uniform_s/2
@@ -326,22 +326,22 @@ uniform_s({#{max:=Max, next:=Next} = Alg, R0}) ->
 uniform_s(N, State = {#{uniform_n:=UniformN}, _})
   when is_integer(N), 1 =< N ->
     UniformN(N, State);
-uniform_s(N, {#{bits:=Bits, next:=Next} = Alg, R0})
+uniform_s(N, {#{bits:=Bits, next:=Next} = AlgHandler, R0})
   when is_integer(N), 1 =< N ->
     {V, R1} = Next(R0),
     MaxMinusN = ?BIT(Bits) - N,
-    ?uniform_range(N, Alg, R1, V, MaxMinusN, I);
-uniform_s(N, {#{max:=Max, next:=Next} = Alg, R0})
+    ?uniform_range(N, AlgHandler, R1, V, MaxMinusN, I);
+uniform_s(N, {#{max:=Max, next:=Next} = AlgHandler, R0})
   when is_integer(N), 1 =< N ->
     %% Old algorithm with skewed probability
     %% and gap in ranges > Max
     {V, R1} = Next(R0),  
     if
         N =< Max ->
-            {(V rem N) + 1, {Alg, R1}};
+            {(V rem N) + 1, {AlgHandler, R1}};
         true ->
             F = V / (Max + 1),
-            {trunc(F * N) + 1, {Alg, R1}}
+            {trunc(F * N) + 1, {AlgHandler, R1}}
     end.
 
 %% uniform_real/0: returns a random float X where 0.0 < X =< 1.0,
@@ -388,7 +388,7 @@ uniform_real() ->
 %%-define(TWO_POW_MINUS110, 7.7037197775489436e-34).
 %%
 -spec uniform_real_s(State :: state()) -> {X :: float(), NewState :: state()}.
-uniform_real_s({#{bits:=Bits, next:=Next} = Alg, R0}) ->
+uniform_real_s({#{bits:=Bits, next:=Next} = AlgHandler, R0}) ->
     %% Generate a 56 bit number without using the weak low bits.
     %%
     %% Be sure to use only 53 bits when multiplying with
@@ -400,22 +400,22 @@ uniform_real_s({#{bits:=Bits, next:=Next} = Alg, R0}) ->
     if
         ?BIT(55) =< M1 ->
             %% We have 56 bits - waste 3
-            {(M1 bsr 3) * math:pow(2.0, -53), {Alg, R1}};
+            {(M1 bsr 3) * math:pow(2.0, -53), {AlgHandler, R1}};
         ?BIT(54) =< M1 ->
             %% We have 55 bits - waste 2
-            {(M1 bsr 2) * math:pow(2.0, -54), {Alg, R1}};
+            {(M1 bsr 2) * math:pow(2.0, -54), {AlgHandler, R1}};
         ?BIT(53) =< M1 ->
             %% We have 54 bits - waste 1
-            {(M1 bsr 1) * math:pow(2.0, -55), {Alg, R1}};
+            {(M1 bsr 1) * math:pow(2.0, -55), {AlgHandler, R1}};
         ?BIT(52) =< M1 ->
             %% We have 53 bits - use all
-            {M1 * math:pow(2.0, -56), {Alg, R1}};
+            {M1 * math:pow(2.0, -56), {AlgHandler, R1}};
         true ->
             %% Need more bits
             {V2, R2} = Next(R1),
-            uniform_real_s(Alg, Next, M1, -56, R2, V2, Bits)
+            uniform_real_s(AlgHandler, Next, M1, -56, R2, V2, Bits)
     end;
-uniform_real_s({#{max:=_, next:=Next} = Alg, R0}) ->
+uniform_real_s({#{max:=_, next:=Next} = AlgHandler, R0}) ->
     %% Generate a 56 bit number.
     %% Ignore the weak low bits for these old algorithms,
     %% just produce something reasonable.
@@ -429,23 +429,23 @@ uniform_real_s({#{max:=_, next:=Next} = Alg, R0}) ->
     if
         ?BIT(55) =< M1 ->
             %% We have 56 bits - waste 3
-            {(M1 bsr 3) * math:pow(2.0, -53), {Alg, R1}};
+            {(M1 bsr 3) * math:pow(2.0, -53), {AlgHandler, R1}};
         ?BIT(54) =< M1 ->
             %% We have 55 bits - waste 2
-            {(M1 bsr 2) * math:pow(2.0, -54), {Alg, R1}};
+            {(M1 bsr 2) * math:pow(2.0, -54), {AlgHandler, R1}};
         ?BIT(53) =< M1 ->
             %% We have 54 bits - waste 1
-            {(M1 bsr 1) * math:pow(2.0, -55), {Alg, R1}};
+            {(M1 bsr 1) * math:pow(2.0, -55), {AlgHandler, R1}};
         ?BIT(52) =< M1 ->
             %% We have 53 bits - use all
-            {M1 * math:pow(2.0, -56), {Alg, R1}};
+            {M1 * math:pow(2.0, -56), {AlgHandler, R1}};
         true ->
             %% Need more bits
             {V2, R2} = Next(R1),
-            uniform_real_s(Alg, Next, M1, -56, R2, V2, 56)
+            uniform_real_s(AlgHandler, Next, M1, -56, R2, V2, 56)
     end.
 
-uniform_real_s(Alg, _Next, M0, -1064, R1, V1, Bits) -> % 19*56
+uniform_real_s(AlgHandler, _Next, M0, -1064, R1, V1, Bits) -> % 19*56
     %% This is a very theoretical bottom case.
     %% The odds of getting here is about 2^-1008,
     %% through a white box test case, or thanks to
@@ -454,8 +454,8 @@ uniform_real_s(Alg, _Next, M0, -1064, R1, V1, Bits) -> % 19*56
     %% Fill up to 53 bits, we have at most 52
     B0 = (53 - ?BC(M0, 52)), % Missing bits
     {(((M0 bsl B0) bor (V1 bsr (Bits - B0))) * math:pow(2.0, -1064 - B0)),
-     {Alg, R1}};
-uniform_real_s(Alg, Next, M0, BitNo, R1, V1, Bits) ->
+     {AlgHandler, R1}};
+uniform_real_s(AlgHandler, Next, M0, BitNo, R1, V1, Bits) ->
     if
         %% Optimize the most probable.
         %% Fill up to 53 bits.
@@ -463,32 +463,36 @@ uniform_real_s(Alg, Next, M0, BitNo, R1, V1, Bits) ->
             %% We have 52 bits in M0 - need 1
             {(((M0 bsl 1) bor (V1 bsr (Bits - 1)))
               * math:pow(2.0, BitNo - 1)),
-             {Alg, R1}};
+             {AlgHandler, R1}};
         ?BIT(50) =< M0 ->
             %% We have 51 bits in M0 - need 2
             {(((M0 bsl 2) bor (V1 bsr (Bits - 2)))
               * math:pow(2.0, BitNo - 2)),
-             {Alg, R1}};
+             {AlgHandler, R1}};
         ?BIT(49) =< M0 ->
             %% We have 50 bits in M0 - need 3
             {(((M0 bsl 3) bor (V1 bsr (Bits - 3)))
               * math:pow(2.0, BitNo - 3)),
-             {Alg, R1}};
+             {AlgHandler, R1}};
         M0 == 0 ->
             M1 = V1 bsr (Bits - 56),
             if
                 ?BIT(55) =< M1 ->
                     %% We have 56 bits - waste 3
-                    {(M1 bsr 3) * math:pow(2.0, BitNo - 53), {Alg, R1}};
+                    {(M1 bsr 3) * math:pow(2.0, BitNo - 53),
+                     {AlgHandler, R1}};
                 ?BIT(54) =< M1 ->
                     %% We have 55 bits - waste 2
-                    {(M1 bsr 2) * math:pow(2.0, BitNo - 54), {Alg, R1}};
+                    {(M1 bsr 2) * math:pow(2.0, BitNo - 54),
+                     {AlgHandler, R1}};
                 ?BIT(53) =< M1 ->
                     %% We have 54 bits - waste 1
-                    {(M1 bsr 1) * math:pow(2.0, BitNo - 55), {Alg, R1}};
+                    {(M1 bsr 1) * math:pow(2.0, BitNo - 55),
+                     {AlgHandler, R1}};
                 ?BIT(52) =< M1 ->
                     %% We have 53 bits - use all
-                    {M1 * math:pow(2.0, BitNo - 56), {Alg, R1}};
+                    {M1 * math:pow(2.0, BitNo - 56),
+                     {AlgHandler, R1}};
                 BitNo =:= -1008 ->
                     %% Endgame
                     %% For the last round we cannot have 14 zeros or more
@@ -497,7 +501,8 @@ uniform_real_s(Alg, Next, M0, BitNo, R1, V1, Bits) ->
                     if
                         ?BIT(42) =< M1 ->
                             %% We have 43 bits - get the last bits
-                            uniform_real_s(Alg, Next, M1, BitNo - 56, R1);
+                            uniform_real_s(
+                              AlgHandler, Next, M1, BitNo - 56, R1);
                         true ->
                             %% Would underflow 2^-1022 - start all over
                             %%
@@ -506,26 +511,26 @@ uniform_real_s(Alg, Next, M0, BitNo, R1, V1, Bits) ->
                             %% for a good PRNG generating this many zeros
                             %% in a row.  Maybe we should write an error
                             %% report or call this a system limit...?
-                            uniform_real_s({Alg, R1})
+                            uniform_real_s({AlgHandler, R1})
                     end;
                 true ->
                     %% Need more bits
-                    uniform_real_s(Alg, Next, M1, BitNo - 56, R1)
+                    uniform_real_s(AlgHandler, Next, M1, BitNo - 56, R1)
             end;
         true ->
             %% Fill up to 53 bits
             B0 = 53 - ?BC(M0, 49), % Number of bits we need to append
             {(((M0 bsl B0) bor (V1 bsr (Bits - B0)))
               * math:pow(2.0, BitNo - B0)),
-             {Alg, R1}}
+             {AlgHandler, R1}}
     end.
 %%
-uniform_real_s(#{bits:=Bits} = Alg, Next, M0, BitNo, R0) ->
+uniform_real_s(#{bits:=Bits} = AlgHandler, Next, M0, BitNo, R0) ->
     {V1, R1} = Next(R0),
-    uniform_real_s(Alg, Next, M0, BitNo, R1, V1, Bits);
-uniform_real_s(#{max:=_} = Alg, Next, M0, BitNo, R0) ->
+    uniform_real_s(AlgHandler, Next, M0, BitNo, R1, V1, Bits);
+uniform_real_s(#{max:=_} = AlgHandler, Next, M0, BitNo, R0) ->
     {V1, R1} = Next(R0),
-    uniform_real_s(Alg, Next, M0, BitNo, R1, ?MASK(56, V1), 56).
+    uniform_real_s(AlgHandler, Next, M0, BitNo, R1, ?MASK(56, V1), 56).
 
 %% jump/1: given a state, jump/1
 %% returns a new state which is equivalent to that
@@ -789,25 +794,25 @@ exsss_next([S1|S0]) ->
     {?scramble_starstar(S0, V_0, V_1), [S0|NewS1]}.
 %%    {?MASK(58, S0 + NewS1), [S0|NewS1]}.
 
-exsp_uniform({Alg, R0}) ->
+exsp_uniform({AlgHandler, R0}) ->
     {I, R1} = exsplus_next(R0),
     %% Waste the lowest bit since it is of lower
     %% randomness quality than the others
-    {(I bsr (58-53)) * ?TWO_POW_MINUS53, {Alg, R1}}.
+    {(I bsr (58-53)) * ?TWO_POW_MINUS53, {AlgHandler, R1}}.
 
-exsss_uniform({Alg, R0}) ->
+exsss_uniform({AlgHandler, R0}) ->
     {I, R1} = exsss_next(R0),
-    {(I bsr (58-53)) * ?TWO_POW_MINUS53, {Alg, R1}}.
+    {(I bsr (58-53)) * ?TWO_POW_MINUS53, {AlgHandler, R1}}.
 
-exsp_uniform(Range, {Alg, R}) ->
+exsp_uniform(Range, {AlgHandler, R}) ->
     {V, R1} = exsplus_next(R),
     MaxMinusRange = ?BIT(58) - Range,
-    ?uniform_range(Range, Alg, R1, V, MaxMinusRange, I).
+    ?uniform_range(Range, AlgHandler, R1, V, MaxMinusRange, I).
 
-exsss_uniform(Range, {Alg, R}) ->
+exsss_uniform(Range, {AlgHandler, R}) ->
     {V, R1} = exsss_next(R),
     MaxMinusRange = ?BIT(58) - Range,
-    ?uniform_range(Range, Alg, R1, V, MaxMinusRange, I).
+    ?uniform_range(Range, AlgHandler, R1, V, MaxMinusRange, I).
 
 
 %% This is the jump function for the exs* generators,
@@ -848,10 +853,10 @@ exsss_uniform(Range, {Alg, R}) ->
 -dialyzer({no_improper_lists, exsplus_jump/1}).
 -spec exsplus_jump({alg_handler(), exsplus_state()}) ->
                           {alg_handler(), exsplus_state()}.
-exsplus_jump({Alg, S}) ->
+exsplus_jump({AlgHandler, S}) ->
     {S1, AS1} = exsplus_jump(S, [0|0], ?JUMPCONST1, ?JUMPELEMLEN),
     {_,  AS2} = exsplus_jump(S1, AS1,  ?JUMPCONST2, ?JUMPELEMLEN),
-    {Alg, AS2}.
+    {AlgHandler, AS2}.
 
 -dialyzer({no_improper_lists, exsplus_jump/4}).
 exsplus_jump(S, AS, _, 0) ->
@@ -953,13 +958,13 @@ exs1024_next({[H], RL}) ->
 
 -spec exs1024_jump({alg_handler(), exs1024_state()}) ->
                           {alg_handler(), exs1024_state()}.
-exs1024_jump({Alg, {L, RL}}) ->
+exs1024_jump({AlgHandler, {L, RL}}) ->
     P = length(RL),
     AS = exs1024_jump({L, RL},
          [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
          ?JUMPCONSTTAIL, ?JUMPCONSTHEAD, ?JUMPELEMLEN, ?JUMPTOTALLEN),
     {ASL, ASR} = lists:split(?RINGLEN - P, AS),
-    {Alg, {ASL, lists:reverse(ASR)}}.
+    {AlgHandler, {ASL, lists:reverse(ASR)}}.
 
 exs1024_jump(_, AS, _, _, _, 0) ->
     AS;
@@ -1122,20 +1127,20 @@ exro928_next_state(Ss, Rs, S15, S0) ->
     {[NewS0|Ss], [NewS15|Rs]}.
 
 
-exro928ss_uniform({Alg, SR}) ->
+exro928ss_uniform({AlgHandler, SR}) ->
     {V, NewSR} = exro928ss_next(SR),
-    {(V bsr (58-53)) * ?TWO_POW_MINUS53, {Alg, NewSR}}.
+    {(V bsr (58-53)) * ?TWO_POW_MINUS53, {AlgHandler, NewSR}}.
 
-exro928ss_uniform(Range, {Alg, SR}) ->
+exro928ss_uniform(Range, {AlgHandler, SR}) ->
     {V, NewSR} = exro928ss_next(SR),
     MaxMinusRange = ?BIT(58) - Range,
-    ?uniform_range(Range, Alg, NewSR, V, MaxMinusRange, I).
+    ?uniform_range(Range, AlgHandler, NewSR, V, MaxMinusRange, I).
 
 
 -spec exro928_jump({alg_handler(), exro928_state()}) ->
                           {alg_handler(), exro928_state()}.
-exro928_jump({Alg, SR}) ->
-    {Alg,exro928_jump_2pow512(SR)}.
+exro928_jump({AlgHandler, SR}) ->
+    {AlgHandler,exro928_jump_2pow512(SR)}.
 
 -spec exro928_jump_2pow512(exro928_state()) -> exro928_state().
 exro928_jump_2pow512(SR) ->
@@ -1268,16 +1273,16 @@ exrop_next_s(S0, S1) ->
 exrop_next([S0|S1]) ->
     {?MASK(58, S0 + S1), ?exrop_next_s(S0, S1, S1_a)}.
 
-exrop_uniform({Alg, R}) ->
+exrop_uniform({AlgHandler, R}) ->
     {V, R1} = exrop_next(R),
     %% Waste the lowest bit since it is of lower
     %% randomness quality than the others
-    {(V bsr (58-53)) * ?TWO_POW_MINUS53, {Alg, R1}}.
+    {(V bsr (58-53)) * ?TWO_POW_MINUS53, {AlgHandler, R1}}.
 
-exrop_uniform(Range, {Alg, R}) ->
+exrop_uniform(Range, {AlgHandler, R}) ->
     {V, R1} = exrop_next(R),
     MaxMinusRange = ?BIT(58) - Range,
-    ?uniform_range(Range, Alg, R1, V, MaxMinusRange, I).
+    ?uniform_range(Range, AlgHandler, R1, V, MaxMinusRange, I).
 
 %% Split a 116 bit constant into two 58 bit words,
 %% a top '1' marks the end of the low word.
@@ -1285,9 +1290,9 @@ exrop_uniform(Range, {Alg, R}) ->
    JUMP_116(Jump),
    [?BIT(58) bor ?MASK(58, (Jump)),(Jump) bsr 58]).
 %%
-exrop_jump({Alg,S}) ->
+exrop_jump({AlgHandler,S}) ->
     [J|Js] = ?JUMP_116(16#9863200f83fcd4a11293241fcb12a),
-    {Alg, exrop_jump(S, 0, 0, J, Js)}.
+    {AlgHandler, exrop_jump(S, 0, 0, J, Js)}.
 %%
 -dialyzer({no_improper_lists, exrop_jump/5}).
 exrop_jump(_S, S0, S1, 0, []) -> % End of jump constant
@@ -1447,13 +1452,13 @@ format_jumpconst58_value(J) ->
 -define(NOR_INV_R, 1/?NOR_R).
 
 %% return a {sign, Random51bits, State}
-get_52({Alg=#{bits:=Bits, next:=Next}, S0}) ->
+get_52({#{bits:=Bits, next:=Next} = AlgHandler, S0}) ->
     %% Use the high bits
     {Int,S1} = Next(S0),
-    {?BIT(Bits - 51 - 1) band Int, Int bsr (Bits - 51), {Alg, S1}};
-get_52({Alg=#{next:=Next}, S0}) ->
+    {?BIT(Bits - 51 - 1) band Int, Int bsr (Bits - 51), {AlgHandler, S1}};
+get_52({#{next:=Next} = AlgHandler, S0}) ->
     {Int,S1} = Next(S0),
-    {?BIT(51) band Int, ?MASK(51, Int), {Alg, S1}}.
+    {?BIT(51) band Int, ?MASK(51, Int), {AlgHandler, S1}}.
 
 %% Slow path
 normal_s(0, Sign, X0, State0) ->
-- 
2.26.2

Places

File 2871-Clean-up-code.patch of Package erlang

Places