Pseudo-random numbers/Xorshift star: Difference between revisions

{{trans|Python}}

UInt64 state

L 100'000

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

{{out}}

=={{header|Ada}}==

Raises Unseeded_Error exception if state is not initialized before generating a pseudo-random value.

with Ada.Text_IO; use Ada.Text_IO;

end Main;

{{output}}

<pre>

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

Will generate a runtime error if state is not initialised before use.

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

LONG BITS state;

print( ( newline ) )

END

{{out}}

<pre>

=={{header|C}}==

#include <stdint.h>

#include <stdio.h>

return 0;

{{out}}

<pre>3540625527

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

{{trans|C}}

#include <cstdint>

#include <iostream>

return 0;

{{out}}

<pre>3540625527

=={{header|D}}==

{{trans|C++}}

import std.stdio;

writeln(i, ": ", v);

}

{{out}}

<pre>3540625527

{{libheader| System.Math}}

{{Trans|Go}}

program Xorshift_star;

{$IFNDEF UNIX} Readln; {$ENDIF}

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

===The Functions===

// Xorshift star. Nigel Galloway: August 14th., 2020

let fN=(fun(n:uint64)->n^^^(n>>>12))>>(fun n->n^^^(n<<<25))>>(fun n->n^^^(n>>>27))

let Xstar32=Seq.unfold(fun n->let n=fN n in Some(uint32((n*0x2545F4914F6CDD1DUL)>>>32),n))

let XstarF n=Xstar32 n|>Seq.map(fun n->(float n)/4294967296.0)

===The Tasks===

Xstar32 1234567UL|>Seq.take 5|>Seq.iter(printfn "%d")

{{out}}

<pre>

3809424708

</pre>

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

{{out}}

<pre>

=={{header|Factor}}==

prettyprint sequences ;

987654321 >>state

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' = unfoldr (pure . next)

Direct usage of generator:

=={{header|Java}}==

{{trans|C++}}

private static final long MAGIC = Long.parseUnsignedLong("2545F4914F6CDD1D", 16);

private long state;

}

}

{{out}}

<pre>3540625527

=={{header|Julia}}==

{{trans|Python}}

const CONST = 0x2545F4914F6CDD1D

testXorShiftStar()

<pre>

3540625527

=={{header|Kotlin}}==

{{trans|Java}}

class XorShiftStar {

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

}

{{out}}

<pre>3540625527

=={{header|Lua}}==

{{trans|C}}

local g = {

magic = 0x2545F4914F6CDD1D,

for i,v in pairs(counts) do

print(i..': '..v)

{{out}}

<pre>3540625527

=={{header|Nim}}==

const C = 0x2545F4914F6CDD1Du64

for _ in 1..100_000:

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

{{out}}

=={{header|Perl}}==

use warnings;

no warnings 'portable';

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

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

{{out}}

<pre>Seed: 1234567, first 5 values:

As per [[Pseudo-random_numbers/PCG32#Phix]], resorting to mpfr/gmp

{{libheader|Phix/mpfr}}

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

=={{header|Python}}==

mask32 = (1 << 32) - 1

const = 0x2545F4914F6CDD1D

for i in range(100_000):

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

{{out}}

Raku does not have unsigned Integers at this time (Integers are arbitrary sized) so use explicit bit masks during bitwise operations. All constants are encapsulated inside the class.

has $!state;

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

$rng = Xorshift-star.new;

{{out}}

<pre>Seed: 1234567; first five Int values

=={{header|REXX}}==

numeric digits 200 /*ensure enough decimal digs for mult. */

parse arg n reps pick seed1 seed2 . /*obtain optional arguments from the CL*/

xor: parse arg a, b; $= /*perform a bit─wise XOR. */

do !=1 for length(a); $= $ || (substr(a,!,1) && substr(b,!,1) )

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

<pre>

=={{header|Ruby}}==

Using Ruby 3.0 end-les method def:

MASK64 = (1 << 64) - 1

MASK32 = (1 << 32) - 1

tally = Hash.new(0)

100_000.times{ tally[(random_gen.next_float*5).floor] += 1 }

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Perl}}

define (

var rng = Xorshift_star(987654321)

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

{{out}}

<pre>

=={{header|Swift}}==

struct XorshiftStar {

}

{{out}}

{{libheader|Wren-big}}

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

var Const = BigInt.fromBaseString("2545F4914F6CDD1D", 16)

}

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

{{out}}