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

4 : 20005

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

{{out}}

<pre>2707161783

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)

{{out}}

<pre>

{20080,19802,19910,20039,20169}

</pre>

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

It was a challenge to understand how some Java constructs work and to end up with the identical output.

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

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

3215226955

{0=>20049, 1=>20022, 2=>20115, 3=>19809, 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|Wren}}==

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