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

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

FOR i% = 1 TO 10

PRINT FNsubrand(0)

IF FNsubrand(0)

NEXT

{{out}}

<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.

=={{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

 

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

except insofar as a subfunction may call its parent (or grandparent, etc),

we have defined `subrand` as an accessible subfunction of `subrandSeed`.

# which sets .x as the PRN and which expects the the input to

# be the PRNG state, which is updated.

| foreach range(0; 10) as $i (.;

subrand;

{{out}}

<pre>

{{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

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Module[{buffer},

buffer =

nextValue[buffer_] :=

 

<pre>buffer = initialize[292929];

 

=={{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#}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">state</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">55</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d: %d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">next</span><span style="color: #0000FF;">()})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{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}}

 

=={{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.

s.0= 292929; s.1= 1; billion= 1e9

numeric digits 20

mod: procedure; parse arg a,b; return ( (a // b) + b) // b

r: parse arg #; return r.#

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

<pre>

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>

This implementation uses a ring buffer in the form of a <code>Vec<i32></code>. It is fully configurable, although the seeding algorithm is only implemented for a generator with i = 55, j = 24, and m = 10⁹.

Like C, Rust's <code>%</code> will give negative results for some negative parameters. This algorithm uses [https://doc.rust-lang.org/std/primitive.i32.html#method.rem_euclid the <code>i32::rem_euclid()</code> method] instead.

/// m in the formula

modulo: i32,

println!("{}", n);

}

<pre>467478574

512932792

 

=={{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|uBasic/4tH}}==

 

For i = 1 To 10

Next

 

{{out}}

<pre>467478574

=={{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>