Subtractive generator: Difference between revisions

{{trans|Python: With explanation}}

 

V seed = 292929

 

 

L 5

 

{{out}}

 

subtractive_generator.ads:

type State is private;

procedure Initialize (Generator : in out State; Seed : Natural);

Last : Natural;

end record;

 

subtractive_generator.adb:

 

procedure Initialize (Generator : in out State; Seed : Natural) is

end Next;

 

 

Example main.adb:

with Subtractive_Generator;

 

Ada.Text_IO.Put_Line (Integer'Image (I) & ":" & Integer'Image (N));

end loop;

 

{{out}}

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

 

Loop, 10

, r[i] := Mod(r[i] - r[Mod(A_Index + 30, 55)], r["m"])

return, r

{{out}}

<pre>220: 467478574

229: 380969305</pre>

 

{{works with|BBC BASIC for Windows}}

FOR i% = 1 TO 10

PRINT FNsubrand(0)

IF FNsubrand(0)

NEXT

{{out}}

<pre>

506003769

380969305

</pre>

 

This is a translation of the C example.

 

tbl$(state,55);

0:?si:?sj;

));

 

 

{{out}}

=={{header|C}}==

This is basically the same as the reference C code, only differs in that it's C89.

 

#define MOD 1000000000

 

return 0;

 

=={{header|C sharp|C#}}==

public class SubtractiveGenerator {

public static int MAX = 1000000000;

}

}

 

{{out}}

=={{header|C++}}==

{{libheader|Boost}}

// written for clarity not efficiency.

 

return 0;

}

 

{{out}}

 

=={{header|Clojure}}==

"produces an xpat2 function initialized from seed"

[seed]

 

(println (xpat2) (xpat2) (xpat2)) ; prints: 467478574 512932792 539453717

 

=={{header|Common Lisp}}==

(let ((x (last state)) (y (last state 25)))

;; I take "circular buffer" very seriously (until some guru

;; test it (output same as everyone else's)

(let ((f (bentley-clever 292929)))

 

=={{header|D}}==

{{trans|C}}

 

 

struct Subtractive {

foreach (i; 0 .. 10)

writeln(gen.subrand());

{{out}}

<pre>467478574

 

=={{header|dc}}==

* (seed) lsx --

* Seeds the subtractive generator.

lrx psz

lrx psz

 

This program prints 467478574, 512932792, 539453717.

 

This implementation never uses multiplication, but it does use modulus (remainder from division) to put each random number in range from 0 to 10^9 - 1.

 

=={{header|Elixir}}==

{{trans|Ruby}}

def new(seed) when seed in 0..999_999_999 do

s = Enum.reduce(1..53, [1, seed], fn _,[a,b|_]=acc -> [b-a | acc] end)

 

Subtractive.new(292929)

 

{{out}}

=={{header|F_Sharp|F#}}==

<p>Similar to Haskell, using lazy evaluation.</p>

let main argv =

let m = 1000000000

r |> Seq.skip 220 |> Seq.take 3

|> Seq.iter (printfn "%d")

{{out}}

<pre>467478574

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

 

end do

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

}

}

{{out}}

<pre>

 

=={{header|Haskell}}==

subtractgen seed = drop 220 out

where

where

r = take 55 $ shuffle $ cycle $ take 55 s

s = mmod $ seed : 1 : zipWith (-) s (tail s)

 

main :: IO ()

{{out}}

<pre>

 

=={{header|Icon}} and {{header|Unicon}}==

every 1 to 10 do

write(rand_sub(292929))

put(ring,get(ring))

return ring[-1]

 

{{out}}

Yes! '''f^:(-1)''' IS the inverse of '''f''' . When known.

 

cocurrent'sg' NB. install the state of rng sg into locale sg

 

cocurrent came_from_locale NB. return to previous locale

sg=: sg_sg_ NB. make a local name for sg in locale sg

 

Use:

load'sg.ijs'

sg 2

539453717 20349702 615542081 378707948

 

=={{header|Java}}==

Translation of [[Subtractive_generator#C|C]] via [[Subtractive_generator#D|D]]

{{works with|Java|8}}

import static java.util.stream.IntStream.generate;

 

.forEach(System.out::println);

}

 

<pre>467478574

506003769

380969305</pre>

 

=={{header|Julia}}==

{{works with|Julia|1.0}}

 

s = Array{Int32}(undef,i); r = similar(s)

s[1:2] = [seed,1] # table initialization

x = readline(stdin) # wait until the ENTER key is pressed

length(x) > 0 && break # any other key before ENTER => exit

{{out}}

<pre>(220, 467478574)

=={{header|Kotlin}}==

{{trans|C}}

 

const val MOD = 1_000_000_000

subrandSeed(292_929)

for (i in 0..9) println("r[${i + 220}] = ${subrand()}")

 

{{out}}

 

=={{header|Lua}}==

local n, r, s = 54, {}, { [0]=seed, 1 }

for n = 2,54 do s[n] = (s[n-2] - s[n-1]) % 1e9 end

end

subgen = SubGen(292929)

{{out}}

<pre>220 467478574

229 380969305</pre>

 

Module[{buffer},

buffer =

nextValue[buffer_] :=

 

<pre>buffer = initialize[292929];

 

</pre>

=={{header|Nim}}==

 

template shfl(idx): untyped = (K*(idx+1)) mod I

let rand = subGen(292929)

for _ in 1..3:

{{out}}

<pre>467478574

{{trans|C}}

 

let state = Array.create 55 0

let si = ref 0

let () =

subrand_seed 292929;

 

{{out}}

=={{header|ooREXX}}==

{{trans|REXX}}

/* array index must be positive! */

s=.array~new

mod: Procedure

Parse Arg a,b

{{out|output|text=&nbsp; when using the default input:}}

<pre>same as with REXX</pre>

 

=={{header|PARI/GP}}==

 

=={{header|Perl}}==

use strict;

 

 

bentley_clever(292929);

{{out}}

<pre>467478574

=={{header|Phix}}==

{{trans|C#}}

{{out}}

<pre>

=={{header|PicoLisp}}==

Using a circular list (as a true "ring" buffer).

*Bentley (apply circ (need 55))

*Bentley2 (nth *Bentley 32) )

(when (lt0 (dec *Bentley (pop '*Bentley2)))

(inc *Bentley 1000000000) )

Test:

{{out}}

<pre>467478574

 

=={{header|PL/I}}==

subtractive_generator: procedure options (main);

 

 

end subtractive_generator;

<pre>

Required 3 results:

The first 55 generated values are placed directly into their reordered slots in the ring.

An array object is used along with a rotating index object to simulate a ring.

function Get-SubtractiveRandom ( [int]$Seed )

{

Get-SubtractiveRandom

Get-SubtractiveRandom

{{out}}

<pre>

Uses collections.deque as a ring buffer

 

import collections

s= collections.deque(maxlen=55)

for i in xrange(5):

print "result = ", getnextr()

 

===Python: As a class within a module===

Python 2 and 3 compatable.

 

_ten2nine = 10**9

if __name__ == '__main__':

srand = Subtractive_generator()

 

{{out}}

<pre>[467478574, 512932792, 539453717, 20349702, 615542081]</pre>

 

=={{header|Racket}}==

(define (make-initial-state a-list max-i)

(for/fold ((state a-list))

;that returns a new random number each time it's called

(define rand (create-substractive-generator 292929))

 

=={{header|Raku}}==

{{works with|Rakudo|2018.03}}

 

constant $mod = 1_000_000_000;

my @seeds = ($seed % $mod, 1, (* - *) % $mod ... *)[^55];

 

my @sr = bentley-clever(292929);

Here we just make the seeder return the random sequence as a lazy list.

 

 

Some optimization was done so that the first two &nbsp; '''do''' &nbsp; loops executed faster.

Cp= 34

m= 219; Cj= 24

t= 235

exit 0 /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

563900213

</pre>

 

=={{header|Ruby}}==

This implementation aims for simplicity, not speed. <code>SubRandom#rand</code> pushes to and shifts from an array; this might be slower than a ring buffer. The seeding method must call <code>rand</code> 55 extra times (220 times instead of 165 times). The code also calls [[Arithmetic/Integer#Ruby|Ruby's modulus operator]], which always returns a non-negative integer if the modulus is positive.

 

# the same sequences as Bentley's generator, as used in xpat2.

class SubRandom

 

rng = SubRandom.new(292929)

 

<pre>[467478574, 512932792, 539453717]</pre>

 

=={{header|Seed7}}==

 

const integer: MOD is 1000000000;

writeln(subrand(gen));

end for;

 

{{out}}

 

=={{header|Sidef}}==

 

const mod = 1_000_000_000;

 

var r = SubRandom(292929);

{{out}}

<pre>

=={{header|Tcl}}==

{{trans|C}}

namespace eval subrand {

variable mod 1000000000 state [lrepeat 55 0] si 0 sj 0

for {set i 0} {$i < 10} {incr i} {

puts [subrand::gen]

 

=={{header|Wren}}==

{{trans|C}}

var state = List.filled(55, 0)

var si = 0

 

subrandSeed.call(292929)

 

{{out}}

{{trans|Python}}

{{trans|C}}

var ring=L(),m=(1e9).toInt();

mod:='wrap(n){ if(n<0) n+m else n };

ring.append((ring.pop(0)-ring[-24]):mod(_));

return(ring[-1]);

{{out}}

<pre>