Pseudo-random numbers/PCG32: Difference between revisions

{{trans|Python}}

 

UInt64 state, inc

 

V shifted = UInt32(((old >> 18) (+) old) >> 27)

V rot = UInt32(old >> 59)

 

F seed(UInt64 seed_state, seed_sequence)

L 100'000

hist[Int(random_gen.next_float() * 5)]++

 

{{out}}

=={{header|Ada}}==

Ada solution using a package to encapsulate the PCG32 algorithm.

 

package random_pcg32 is

procedure Seed (seed_state : Unsigned_64; seed_sequence : Unsigned_64);

end random_pcg32;

 

 

State : Unsigned_64 := 0;

 

end random_pcg32;

 

with Interfaces; use Interfaces;

with random_pcg32; use random_pcg32;

end Main_P;

{{output}}

<pre>

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

# note that although LONG INT is 64 bits in Algol 68G, LONG BITS is longer than 64 bits #

LONG BITS state := LONG 16r853c49e6748fea9b;

print( ( newline ) )

END

{{out}}

<pre>

=={{header|C}}==

{{trans|Go}}

#include <stdint.h>

#include <stdio.h>

 

return 0;

{{out}}

<pre>2707161783

3 : 19809

4 : 20005</pre>

 

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

{{trans|C}}

#include <iostream>

 

class PCG32 {

 

return 0;

{{out}}

<pre>2707161783

=={{header|D}}==

{{trans|C++}}

import std.stdio;

 

writeln(" ", i, " : ", v);

}

{{out}}

<pre>2707161783

3 : 19809

4 : 20005</pre>

 

=={{header|Delphi}}==

{{libheader| System.Generics.Collections}}

{{Trans|Python}}

program PCG32_test;

 

Readln;

end.

{{out}}

<pre>

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

===The Functions===

// PCG32. Nigel Galloway: August 13th., 2020

let N=6364136223846793005UL

let pcg32=Seq.unfold(fun(n,g)->let rot,xs=uint32(g>>>59),uint32(((g>>>18)^^^g)>>>27) in Some(uint32((xs>>>(int rot))|||(xs<<<(-(int rot)&&&31))),(n,g*N+n)))

let pcgFloat n=pcg32 n|>Seq.map(fun n-> (float n)/4294967296.0)

===The Tasks===

pcg32(seed 42UL 54UL)|>Seq.take 5|>Seq.iter(printfn "%d")

{{out}}

<pre>

3215226955

</pre>

pcgFloat(seed 987654321UL 1UL)|>Seq.take 100000|>Seq.countBy(fun n->int(n*5.0))|>Seq.iter(printf "%A");printfn ""

<pre>

(2, 20115)(3, 19809)(0, 20049)(4, 20005)(1, 20022)

</pre>

=={{header|Factor}}==

{{trans|Python}}

{{works with|Factor|0.99 2020-08-14}}

prettyprint sequences ;

 

987654321 1 [ seed ] keepdd

100,000 [ dup next-float 5 * >integer ] replicate nip

{{out}}

<pre>

=={{header|Go}}==

{{trans|Python}}

 

import (

fmt.Printf(" %d : %d\n", i, counts[i])

}

 

{{out}}

Implement given algorithm as an instance of <code>RandomGen</code> class.

 

import Data.Word

import System.Random

randoms' g = unfoldr (pure . next) g

 

 

Direct usage of generator:

*Main> hist . take 100000 $ (floor . (*5)) <$> (randoms (mkPCGen 987654321 1) :: [Float])

[20009,20065,20023,19876,20027]</pre>

 

=={{header|Java}}==

{{trans|C++}}

private static final long N = 6364136223846793005L;

 

}

}

{{out}}

<pre>2707161783

=={{header|Julia}}==

{{trans|Python}}

 

mutable struct PCG32

 

testPCG32()

<pre>

2707161783

{{trans|C++}}

Requires the experimental unsigned feature for integer types

 

class PCG32 {

println(" %d : %d".format(iv.index, iv.value))

}

{{out}}

<pre>2707161783

=={{header|Lua}}==

{{trans|C}}

return n & 0xffffffff

end

for i=1,5 do

print(" " .. (i - 1) .. ": " .. counts[i])

{{out}}

<pre>2707161783

3: 19809

4: 20005</pre>

 

=={{header|Nim}}==

 

const N = 6364136223846793005u64

for _ in 1..100_000:

counts.inc int(gen.nextFloat() * 5)

 

{{out}}

 

0: 20049, 1: 20022, 2: 20115, 3: 19809, 4: 20005</pre>

 

=={{header|Perl}}==

use warnings;

use feature 'say';

$rng = PCG32->new(seed => 987654321, incr => 1);

$h{int 5 * $rng->next_float}++ for 1 .. 100_000;

{{out}}

<pre>Seed: 42, Increment: 54, first 5 values:

Phix atoms are limited to 53/64 bits of precision, however (given the above) this task would need 128 bits.<br>

First, for comparison only, this is the usual recommended native approach for this genre of task (different output)

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"NB: These are not expected to match the task spec!\n"</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">set_rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">42</span><span style="color: #0000FF;">)</span>

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

<span style="color: #0000FF;">?</span><span style="color: #000000;">s</span>

{{out}}

<pre>

</pre>

To meet the spec, similar to the Delphi and Wren entries, we resort to using mpfr/gmp, but it is a fair bit longer than the above, and almost certainly slower, not that there is anywhere near enough work being done here to make that measureable.

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

<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

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

<span style="color: #0000FF;">?</span><span style="color: #000000;">r</span>

{{out}}

<pre>

 

===Python: As class===

mask32 = (1 << 32) - 1

CONST = 6364136223846793005

for i in range(100_000):

hist[int(random_gen.next_float() *5)] += 1

 

{{out}}

===Python: As generator===

 

def next_int():

"return random 32 bit unsigned int"

for i in islice(pcg32(987654321, 1, as_int=False), 100_000):

hist[int(i * 5)] += 1

 

{{out}}

Raku does not have unsigned Integers at this time (Integers are arbitrary sized) so use explicit bit masks during bitwise operations.

 

has $!state;

has $!incr;

say "\nSeed: default, Increment: default; first five Int values:";

$rng = PCG32.new;

{{out}}

<pre>Seed: 42, Increment: 54; first five Int values:

DON'T use Rexx, however, for this type of problem unless you take the time spent

for some Java coffees!

N = 6364136223846793005

state = x2d('853c49e6748fea9b',16)

b=b||bits.c

End

{{out}}

<pre>

=={{header|Ruby}}==

{{trans|Python}}

MASK64 = (1 << 64) - 1

MASK32 = (1 << 32) - 1

random_gen.seed(987654321, 1)

p 100_000.times.each{(random_gen.next_float * 5).floor}.tally.sort.to_h

{{out}}

<pre>2707161783

</pre>

 

 

=={{header|Scheme}}==

{{trans|Ruby}}

 

 

(define PCG-DEFAULT-MULTIPLIER 6364136223846793005)

(newline)

(lp (+ i 1))))

{{out}}

<pre>

4 : 20005

</pre>

 

=={{header|Sidef}}==

{{trans|Perl}}

 

has state

var rng = PCG32(seed: 987654321, incr: 1)

var histogram = Bag(1e5.of { floor(5*rng.next_float) }...)

{{out}}

<pre>

 

=={{header|Standard ML}}==

 

local

Word.fromLarge (state >> 0w59)),

(state * m + inc, inc))

;Test code<nowiki>:</nowiki>

(print (Word32.fmt StringCvt.DEC rand ^ "\n"); state)

 

 

val _ = doTimes (test2 o pcg32Random, 100000, pcg32Init (987654321, 1))

{{out}}

<pre>2707161783

 

0: 20049, 1: 20022, 2: 20115, 3: 19809, 4: 20005</pre>

 

=={{header|uBasic/4tH}}==

{{trans|C}}

uBasic/4tH only supports signed integers - so floating point is out of the question. It also requires clipping some integers to 32 bits in order to make this work.

 

If Info("wordsize") < 64 Then Print "This program requires a 64-bit uBasic" : End

s = s + a@

Proc _PCG32Int

{{Out}}

<pre>2707161783

 

0 OK, 0:391</pre>

=={{header|Wren}}==

{{trans|Python}}

{{libheader|Wren-big}}

As Wren doesn't have a 64-bit integer type, we use BigInt instead.

 

var Const = BigInt.new("6364136223846793005")

}

System.print("\nThe counts for 100,000 repetitions are:")

 

{{out}}