Random number generator (device): Difference between revisions

 

show how to obtain a random 32-bit number from that mechanism.

<br><br>

 

=={{header|Ada}}==

random.adb:

with Ada.Text_IO;

procedure Random is

Ada.Streams.Stream_IO.Close (Random_File);

Ada.Text_IO.Put_Line ("Number:" & Integer'Image (Number));

=={{header|Batch File}}==

The dynamic environmental variable <code>%random%</code> contains a number between 0 and 32767.

@echo %random%

 

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

{{works with|BBC BASIC for Windows}}

Requires Windows XP or later.

 

=={{header|C}}==

It works on systems having /dev/urandom, like [[GNU]]/[[Linux]].

 

#include <stdlib.h>

 

printf("%lu\n", v);

return 0;

 

[http://www.openbsd.org/cgi-bin/man.cgi?query=arc4random&apropos=0&sektion=3&manpath=OpenBSD+Current&arch=i386&format=html arc4random()] appeared in [[OpenBSD]] 2.1 and has spread to many [[BSD]] systems. This function runs an ARC4 random number generator that takes entropy from a kernel device. (This kernel device is sysctl kern.arandom in OpenBSD, or /dev/urandom in some other systems.)

 

#include <stdlib.h> /* arc4random */

#include <stdio.h> /* printf */

printf("%" PRIu32 "\n", arc4random());

return 0;

 

OpenSSL can generate random numbers. The default generator uses SHA1. For [[Unix]] systems, OpenSSL will gather entropy by reading a kernel device like /dev/urandom, or by using [http://egd.sourceforge.net/ EGD, the Entropy Gathering Daemon]. For other systems, OpenSSL might use a different source of entropy.

 

#include <stdio.h>

 

printf("%" PRIu32 "\n", v);

return 0;

 

=== Windows ===

{{works with|MinGW}}

 

#include <windows.h>

#include <wincrypt.h> /* CryptAcquireContext, CryptGenRandom */

CryptReleaseContext(p, 0);

return 0;

 

<code>std::random_device</code> is a uniformly-distributed integer random number generator that produces non-deterministic random numbers.

 

See the C++ section on [[Random_number_generator_(included)#C.2B.2B|Random number generator (included)]] for the list of pseudo-random number engines available.

{{works with|C++11}}

#include <random>

std::cout << "Random Number: " << dist(rd) << std::endl;

 

=={{header|C sharp}}==

using System.Security.Cryptography;

 

 

return result;

 

Park-Miller random number generator

const long m = 2147483647L;

const long a = 48271L;

arr[i] = gen();

}

 

 

=={{header|Common Lisp}}==

(with-open-file (s "/dev/random" :element-type '(unsigned-byte 32))

 

=={{header|D}}==

Example of MersenneTwisterEngine for generating uniformly-distributed 32-bit numbers with a period of 2 to the power of 19937.

import std.stdio;

import std.random;

writeln(n);

}

 

{{out}}

run 4: ...

</pre>

 

=={{header|EchoLisp}}==

No random device provided by the host (browser). But we can use the system timer to get a physical input.

(random-seed "simon")

(random (expt 2 32)) → 2275215386

(random-seed (current-time-milliseconds ))

(random (expt 2 32)) → 1322611152

 

=={{header|Factor}}==

Factor has good support for switching between different random number generators. <code>with-system-random</code> is a combinator that encapsulates the task of using a system RNG (/dev/random in the case of GNU/Linux).

 

=={{header|Forth}}==

 

: randoms ( n -- )

rnd @ .

loop

 

=={{header|Fortran}}==

Using system /dev/urandom in [[GNU]]/[[Linux]].

 

!-----------------------------------------------------------------------

! Test Linux urandom in Fortran

 

end program urandom_test

 

Here's an example of the use of the latter:

=={{header|FreeBASIC}}==

FreeBASIC can in theory use any C library to produce pseudo-random numbers including those which are partly device based.

 

However, in practice, there is little need for this as specifying a second parameter of 5 to FB's Randomize statement produces cryptographically strong pseudo-random numbers using either the Win32 Crypto API or the /dev/urandom device under Linux.

 

Randomize , 5

Next

 

 

=={{header|GlovePIE}}==

 

=={{header|Go}}==

In the Go library is crypto/rand, a source specified to use dev/urandom on Unix-like systems and the CryptGenRandom API on Windows. Also implemented here is a source using dev/random, if you really want it. On my system it would print a few numbers then hang until I moved the mouse or pressed some keys on the keyboard.

 

import (

}

fmt.Println()

 

=={{header|Groovy}}==

Based, necessarily, on Java solution:

 

Test:

 

{{out}}

1152610574

714616658</pre>

 

=={{header|Icon}} and {{header|Unicon}}==

The following is Unicon-specific but trivially converted into Icon.

 

n := integer(A[1])|5

every !n do write(rand(4))

close(f)

return x

 

Sample runs:

 

Untested:

 

Fallback:

 

Note: this assumes that J is running on linux.

 

=={{header|Java}}==

 

public class RandomExample {

System.out.println(rng.nextInt());

}

 

=={{header|jq}}==

 

Assuming the jq program shown below is in a file named uniform.jq, the command-line invocation would be:

<pre>od -t x -An /dev/urandom | tr -d " " | fold -w 8 | jq -R -f uniform.jq</pre>

 

def hex2integer:

explode

| .[1];

 

 

Notice that the program automatically adjusts the precision based on the length of the hexadecimal numbers presented. Since jq uses IEEE 754 64-bit arithmetic, specifying a larger value to `fold`, such as 10, will produce more precise results.

=={{header|Julia}}==

{{works with|Linux}}

const rdev = "/dev/random"

rstream = try

println("The hardware random number stream, ", rdev, ", was unavailable.")

end

 

{{out}}

A hardware random number is: 986109744

</pre>

 

=={{header|Kotlin}}==

 

import java.security.SecureRandom

rng.setSeed(newSeed) // reseed using the previous 2 random numbers

println(rng.nextInt()) // get random 32-bit number and print it

 

=={{header|Lasso}}==

{{out}}

<pre>723217350</pre>

 

=={{header|M2000 Interpreter}}==

Module checkit {

Declare random1 lib "advapi32.SystemFunction036" {long lpbuffer, long length}

}

checkit

 

 

Function Random2 {

Declare CryptAcquireContext Lib "advapi32.CryptAcquireContextW" {long ByRefhProv, pszContainer$,pszProvider$, long dwProvType, long dwFlags}

}

Print Random2()

 

Example: create array of 10 rand32 numbers

{{out}}

<pre>{355587317, -869860319, -91421859, 1605907693, 101463390, 891823090,

-531713717, -1038608428, 1717313407, 674189312}</pre>

 

=={{header|NetRexx}}==

{{Works with|Mac OS X}} and probably other UNIX systems that provide <tt>/dev/random</tt> or <tt>/dev/urandom</tt> random data source devices.<br />

options replace format comments java crossref savelog symbols binary

 

for ((i=0; i<10; ++i)); do java <program_name>; done # Shell loop to run the command 10 times

*/

{{out}}

<pre>

 

=={{header|Nim}}==

var r: int32

discard f.readBuffer(addr r, 4)

close(f)

 

=={{header|OCaml}}==

OCaml's default integers are 31 bits on 32 bits architectures:

 

let i1 = int_of_char (input_char ic)

and i2 = int_of_char (input_char ic)

close_in ic;

Printf.printf "%d\n" ri31;

 

but if we really want 32 bits integers there is a module for this:

 

let i1 = Int32.of_int (int_of_char (input_char ic))

and i2 = Int32.of_int (int_of_char (input_char ic))

close_in ic;

Printf.printf "%ld\n" ri32;

 

=={{header|PARI/GP}}==

It works on systems having /dev/urandom and Linux.

 

 

The code above creates a new function rnd() which returns cryptographically strong integers with max. 10 random digits from /dev/urandom. rnd(n) returns integer with max. n random digits. No leading zeros.

=={{header|Pascal}}==

This works with FreePascal on "unixoids":

var

byteFile: file of byte;

writeln('The random byte is: ', randomByte);

end.

{{out}}

<pre>

=={{header|Perl}}==

Typically one would use a module as they will work on UNIX, Win32, and other O/S's. Crypt::Random::Seed, for instance, will use Win32 sources, EGD/PRNGD, /dev/u?random, or if none of those exist for some reason, a userspace entropy method.

my $source = Crypt::Random::Seed->new( NonBlocking => 1 ); # Allow non-blocking sources like /dev/urandom

or (similar but many more dependencies):

 

Or we can read values from /dev/urandom ourselves:

my $device = '/dev/urandom';

open my $in, "<:raw", $device # :raw because it's not unicode string

}

 

Whether /dev/urandom is good enough for cryptographic work is debated, though on most UNIX systems it is at least as good as the Win32 Crypto API.

 

=={{header|Phix}}==

My machine does not support the rdrand instruction.<br>

Tested as best I can by commenting out the jnc instructions and replacing rdrand with rdtsc.<br>

For completeness, I have shown how to convert the signed result to an unsigned one.

 

 

A linux-only solution:

 

=={{header|PicoLisp}}==

 

=={{header|PowerShell}}==

function Get-RandomInteger

{

}

}

4,8,16,32,64,128 | Get-RandomInteger | Format-Wide {$_} -Column 6 -Force

{{Out}}

<pre>

</pre>

As hexadecimal:

4,8,16,32,64,128 | Get-RandomInteger | Format-Wide {"0x{0:X}" -f $_} -Column 6 -Force

{{Out}}

<pre>

=={{header|ProDOS}}==

Uses math module:

=={{header|PureBasic}}==

PureBasic has the source for the random data is the "/dev/urandom" device on Linux or Mac OSX and the "Microsoft Cryptography API" on Windows.

MyRandom = CryptRandom(#MAXLONG)

CloseCryptRandom()

 

=={{header|Python}}==

rand = random.SystemRandom()

 

=={{header|Racket}}==

#lang racket

;; Assuming a device to provide random bits:

(call-with-input-file* "/dev/random"

(λ(i) (integer-bytes->integer (read-bytes 4 i) #f)))

 

=={{header|REXX}}==

Note: &nbsp; the REXX &nbsp; '''random''' &nbsp; BIF has a maximum range

of &nbsp; 100,000.

numeric digits 10 /*ensure REXX has enough decimal digits*/

_=2**16 /*a handy─dandy constant to have around*/

r#= random(0, _-1) * _ + random(0, _-1) /*generate an unsigned 32-bit random #.*/

{{out}}

<pre>

===version 2===

This program generates a random 4 byte character string in the range '00000000'x to 'ffffffff'x

rite=0

lo=hex(left)hex(rite)

Say 'high ' c2x(hi)

Exit

{{out}}

<pre>low 00000000

 

=={{header|Ring}}==

nr = 10

for i = 1 to nr

see random(i) + nl

next

 

=={{header|Ruby}}==

Ruby 1.8.7 introduces the 'securerandom' library. For [[MRI]] users, this library tries to get random numbers by loading OpenSSL, or opening /dev/urandom, or calling CryptGenRandom.

 

 

=={{header|Rust}}==

<code>rand</code> used to be part of Rust standard library but it was extracted as a 'crate' (https://crates.io/crates/rand). <code>OsRng</code> uses the appropriate device for many platforms including Unix, Windows, BSD, and iOS (listed [https://docs.rs/rand/0.4/rand/os/struct.OsRng.html here]). Other methods like <code>RDRAND</code> can be found in other crates (https://crates.io/crates/rdrand).

 

 

use rand::{OsRng, Rng};

let rand_num: u32 = rng.gen();

println!("{}", rand_num);

 

=={{header|Scala}}==

 

object RandomExample extends App {

println(this.nextInt()) // get random 32-bit number and print it

}

=={{header|Sidef}}==

 

device.open('<:raw', \var fh, \var err) ->

 

}

 

 

=={{header|Tcl}}==

 

# Allow override of device name

close $f

return $x

Usage:

 

=={{header|UNIX Shell}}==

 

=={{header|Wee Basic}}==

Due to how the code works, any key has to be entered to generate the random number.

let number=1

print 1 "Press any key to generate a random number from 1 to 10.

wend

print 1 number

 

=={{header|X86 Assembly}}==

Processors supporting the new RDRAND feature can generate a random 32-bit integer in two instructions:

RDRAND reads the CPU's cryptographically-secure hardware random number generator. The loop is needed because RDRAND can occasionally fail to retrieve a value — it sets the carry flag to indicate whether it succeeded.

 

limited to 31 bits.

 

int R;

 

=={{header|zkl}}==

{{trans|C}}

Linux:

fin,buf:=File(RANDOM_PATH,"r"), fin.read(4);

fin.close(); // GC would also close the file

{{out}}

<pre>