Pseudo-random numbers/Combined recursive generator MRG32k3a: Difference between revisions

{{trans|Python}}

 

V m1 = Int64(2) ^ 32 - 209

V a2 = [Int64(527612), 0, -1370589]

L 100'000

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

 

{{out}}

 

=={{header|Ada}}==

type I64 is range -2**63..2**63 - 1;

m1 : constant I64 := 2**32 - 209;

function Next_Float return Long_Float;

end MRG32KA;

 

package body MRG32KA is

 

end MRG32KA;

 

with mrg32ka; use mrg32ka;

 

end Main;

{{output}}

<pre>

 

=={{header|C}}==

#include <stdio.h>

#include <stdint.h>

 

return 0;

{{out}}

<pre>1459213977

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

{{trans|C}}

#include <iostream>

 

 

return 0;

{{out}}

<pre>1459213977

=={{header|D}}==

{{trans|C++}}

import std.stdio;

 

writeln(i, ": ", v);

}

{{out}}

<pre>1459213977

 

=={{header|Factor}}==

math.vectors prettyprint sequences ;

 

 

987654321 seed 100,000 [ next-float 5 * >integer ] replicate

{{out}}

<pre>

{{trans|uBasic/4tH}}

{{works with|4tH v3.64}}

6 array (gens) \ holds the generators

\ set up constants

;

 

{{out}}

<pre>1459213977

=={{header|Go}}==

{{trans|Python}}

 

import (

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

}

 

{{out}}

=={{header|Haskell}}==

 

 

randoms :: Int -> [Int]

where

let x1i = sum (zipWith (*) x1 a1) `mod` m1

a1 = [0, 1403580, -810728]

m2 = 2^32 - 22853

 

 

<pre>*Main> take 5 $ randoms 1234567

*Main> hist . take 100000 $ (floor . (*5)) <$> randomsFloat 987654321

[20002,20060,19948,20059,19931]</pre>

 

=={{header|Java}}==

{{trans|C++}}

private static long mod(long x, long y) {

long m = x % y;

}

}

{{out}}

<pre>1459213977

3: 20059

4: 19931</pre>

 

=={{header|Julia}}==

const m1 = 2^32 - 209

const a2 = [527612, 0, -1370589]

end

foreach(p -> print(p[1], ": ", p[2], " "), enumerate(hist))

<pre>

1459213977

=={{header|Kotlin}}==

{{trans|C++}}

 

fun mod(x: Long, y: Long): Long {

println("${iv.index}: ${iv.value}")

}

{{out}}

<pre>1459213977

 

=={{header|Nim}}==

 

const

for _ in 1..100_000:

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

 

{{out}}

=={{header|Pari/GP}}==

Pretty straightforward translation from the directions. Used column/vector multiplication (essentially he dot product) instead of the more tedious form given in the definition of x1i and x2i; rationals (t_FRAC) used in place of floating-point since GP lacks floating-point.

m1 = 2^32-209;

a2 = [527612, 0, -1370589];

vector(5,i,next_int())

seed(987654321);

{{out}}

<pre>%1 = [1459213977, 2827710106, 4245671317, 3877608661, 2595287583]

 

=={{header|Perl}}==

use warnings;

use feature 'say';

$rng = MRG32k3a->new( seed => 987654321 );

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

{{out}}

<pre>Seed: 1234567, first 5 values:

 

=={{header|Phix}}==

{{out}}

<pre>

2595287583

{20002,20060,19948,20059,19931}

 

=={{header|Python}}==

a1 = [0, 1403580, -810728]

m1 = 2**32 - 209

for i in range(100_000):

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

 

{{out}}

All constants are encapsulated within the class.

 

has @!x1;

has @!x2;

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

$rng = MRG32k3a.new;

{{out}}

<pre>Seed: 1234567; first five Int values:

=={{header|Ruby}}==

{{trans|C}}

m = x % y

if m < 0 then

counts.each_with_index { |v,i|

print i, ": ", v, "\n"

{{out}}

<pre>1459213977

4: 19931</pre>

===Mimicking the Pseudo-code===

# First generator

A1 = [0, 1403580, -810728]

random_gen.seed(987654321)

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

 

=={{header|Sidef}}==

{{trans|Perl}}

 

define(

var rng = MRG32k3a(seed: 987654321)

var freq = 100_000.of { rng.next_float * 5 -> int }.freq

{{out}}

<pre>

{{trans|C}}

Since uBasic/4tH has no floating point support, only the integer part of the task can be implemented.

@(1) = 1403580

@(2) = -810728

@(9) = b@

 

{{out}}

<pre>1459213977

=={{header|Wren}}==

{{trans|Python}}

var A1 = [0, 1403580, -810728]

var M1 = 2.pow(32) - 209

}

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

 

{{out}}