Random number generator (device): Difference between revisions

 

 

=={{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|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]].

 

 

{

 

 

[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::random_device rd;

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

 

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

using System.Security.Cryptography;

 

 

return result;

 

=={{header|Forth}}==

 

: randoms ( n -- )

rnd @ .

loop

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

 

<pre>380425053

-1003791794

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

{{out}}

<pre>723217350</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

*/

<pre>

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

$

</pre>

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

This works with FreePascal on "unixoids":

var

byteFile: file of byte;

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

end.

<pre>

>: ./RandomNumberDevice

 

=={{header|Perl}}==

my $device = '/dev/urandom';

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

}

 

 

 

=={{header|PicoLisp}}==

 

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

 

=={{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)))

 

 

 

4294967296

</pre>

 

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

 

# Allow override of device name

close $f

return $x

Usage:

 

=={{header|XPL0}}==

limited to 31 bits.

 

int R;

 

 

{{omit from|GUISS}}