September Morn Update

Task/Subtractive-generator/Haskell/subtractive-generator.hs

@@ -1,8 +1,14 @@
-subtractgen seed = drop 220 out where
-	out = mmod $ r ++ zipWith (-) out (drop 31 out) where
-		r = take 55 $ shuffle $ cycle $ take 55 s
-		shuffle x = head xx:shuffle xx where xx = drop 34 x
-		s = mmod $ seed:1:zipWith (-) s (tail s)
-		mmod = map (`mod` 10^9)
+subtractgen :: Int -> [Int]
+subtractgen seed = drop 220 out
+  where
+    out = mmod $ r ++ zipWith (-) out (drop 31 out)
+      where
+        r = take 55 $ shuffle $ cycle $ take 55 s
+        shuffle x = head xx : shuffle xx
+          where
+            xx = drop 34 x
+        s = mmod $ seed : 1 : zipWith (-) s (tail s)
+        mmod = map (`mod` 10 ^ 9)
 
+main :: IO ()
 main = mapM_ print $ take 10 $ subtractgen 292929

Task/Subtractive-generator/Julia/subtractive-generator.julia

@@ -0,0 +1,16 @@
+i,j,m,d,seed = 55,24,10^9,34,292929     # parameters
+s = Array{Int32}(undef,i); r = similar(s)
+s[1:2] = [seed,1]                       # table initialization
+for n = 3:i; (s[n] = s[n-2]-s[n-1]) < 0 && (s[n] += m) end
+t = 1; for u=1:i; (global t+=d)>i && (t-=i); r[u]=s[t] end # permutation, r = s[(d*(1:i) .% i).+1]
+
+u,v,n = i,i-j,i-1
+while (n += 1) > 0
+    (global u += 1) > i && (u = 1)      # circular indexing: u,v = ((n,n-j) .% i).+1
+    (global v += 1) > i && (v = 1)
+    (r[u] -= r[v]) < 0 && (r[u] += m)   # table update
+    n < 220 && continue                 # 165 silent values
+    print((n,r[u]))                     # show (index,value) of next pseudorandom number
+    x = readline(stdin)                 # wait until the ENTER key is pressed
+    length(x) > 0 && break              # any other key before ENTER => exit
+end

Task/Subtractive-generator/Phix/subtractive-generator.phix

@@ -0,0 +1,36 @@
+sequence state = repeat(0,55)
+integer pos
+
+constant MAX = 1e9
+function cap(integer n)
+    if n<0 then n += MAX end if
+    return n
+end function
+
+function next()
+    pos = mod(pos,55)+1
+    integer temp = cap(state[pos]-state[mod(pos+30,55)+1])
+    state[pos] = temp
+    return temp
+end function
+
+procedure init(integer seed)
+    sequence temp = repeat(0,55)
+    temp[1] = cap(seed)
+    temp[2] = 1
+    for i=3 to 55 do
+        temp[i] = cap(temp[i-2]-temp[i-1])
+    end for
+    for i=1 to 55 do
+        state[i] = temp[mod(34*i,55)+1]
+    end for
+    pos = 55
+    for i=55 to 219 do
+        {} = next()
+    end for
+end procedure
+
+init(292929)
+for i=220 to 222 do
+    printf(1,"%d: %d\n",{i,next()})
+end for

Task/Subtractive-generator/REXX/subtractive-generator.rexx

@@ -1,24 +1,24 @@
 /*REXX program uses a  subtractive generator, and creates a sequence of random numbers. */
-s.0=292929;        s.1=1;                                 billion=1e9     /* ◄────────┐ */
-numeric digits 20;                                        billion=10**9   /*same as─►─┘ */
-cI=55;             do i=2  to cI-1
-                   s.i=mod(s(i-2) - s(i-1), billion)
+s.0= 292929;       s.1= 1;                                billion= 1e9    /* ◄────────┐ */
+numeric digits 20;                                        billion= 10**9  /*same as─►─┘ */
+cI= 55;            do i=2    to cI-1
+                   s.i= mod( s(i-2)   -   s(i-1), billion)
                    end   /*i*/
-Cp=34
+Cp= 34
                    do j=0    to cI-1
-                   r.j=s(mod(cP*(j+1), cI))
+                   r.j= s( mod( cP * (j+1), cI))
                    end   /*j*/
-m=219;  Cj=24
-                   do k=cI   to m;     _=k//cI
-                   r._=mod(r(mod(k-cI, cI)) - r(mod(k-cJ, cI)), billion)
-                   end   /*m*/
-t=235
-                   do n=m+1  to t;     _=n//cI
-                   r._=mod(r(mod(n-cI, cI)) - r(mod(n-cJ, cI)), billion)
+m= 219;   Cj= 24
+                   do k=cI   to m;     _= k // cI
+                   r._= mod( r( mod(k-cI, cI))   -   r( mod(k-cJ, cI)), billion)
+                   end   /*k*/
+t= 235
+                   do n=m+1  to t;     _= n // cI
+                   r._= mod( r( mod(n-cI, cI))   -   r( mod(n-cJ, cI)), billion)
                    say   right(r._, 40)
                    end   /*n*/
 exit                                             /*stick a fork in it,  we're all done. */
 /*──────────────────────────────────────────────────────────────────────────────────────*/
-mod: procedure;    parse arg a,b;     return  ((a // b)  +  b)   //   b
-r:                 parse arg #;       return  r.#
-s:                 parse arg #;       return  s.#
+mod: procedure;    parse arg a,b;      return  ( (a // b)  +  b)   //   b
+r:                 parse arg #;        return  r.#
+s:                 parse arg #;        return  s.#