Random numbers: Difference between revisions

{{task|Basic language learning}}

{{omit from|GUISS}}

{{omit from|UNIX Shell|From the shell, we simply invoke the awk solution}}

 

 

 

 

=={{header|Ada}}==

with Ada.Numerics.Float_Random; use Ada.Numerics.Float_Random;

with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;

Distribution (I) := Normal_Distribution (Seed);

end loop;

=={{header|ALGOL 68}}==

{{trans|C}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

(

sqrt(-2*log(random)) * cos(2*pi*random)

INT limit=10;

printf(($"("n(limit-1)(-d.6d",")-d.5d" ... )"$, rands[:limit]))

{{out}}

<pre>

( 0.693461, 0.948424, 0.482261, 1.045939, 0.890818, 1.467935, 0.604153, 0.804811, 0.690227, 0.83462 ... )

</pre>

 

=={{header|AutoHotkey}}==

contributed by Laszlo on the ahk

[http://www.autohotkey.com/forum/post-276261.html#276261 forum]

R .= RandN(1,0.5) "`n" ; mean = 1.0, standard deviation = 0.5

MsgBox %R%

}

Return Y

 

=={{header|AWK}}==

'''One-liner:'''

 

'''Readable version:'''

function r() {

return sqrt( -2*log( rand() ) ) * cos(6.2831853*rand() )

print s

}

{{out}} first few values only

<pre>

 

=={{header|BASIC}}==

 

FOR number% = 0 TO 999

array(number%) = 1.0 + 0.5 * SQR(-2*LN(RND(1))) * COS(2*PI*RND(1))

PRINT "Mean = " ; mean

{{out}}

<pre>Mean = 1.01848064

Standard deviation = 0.503551814</pre>

 

=={{header|C}}==

#include <math.h>

#ifndef M_PI

rands[i] = 1.0 + 0.5*random_normal();

return 0;

 

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

{{trans|JavaScript}}

private static double randomNormal()

{

return Math.Cos(2 * Math.PI * tRand.NextDouble()) * Math.Sqrt(-2 * Math.Log(tRand.NextDouble()));

}

 

Then the methods in [[Random numbers#Metafont]] are used to calculate the average and the Standard Deviation:

static Random tRand = new Random();

 

Console.ReadLine();

}

 

An example result:

The new C++ standard looks very similar to the Boost library example below.

 

#include <functional>

#include <vector>

generate(v.begin(), v.end(), rnd);

return 0;

 

{{works with|C++03}}

#include <cmath> // for atan, sqrt, log, cos

#include <algorithm> // for generate_n

std::generate_n(array, 1000, normal_distribution(1.0, 0.5));

return 0;

 

{{libheader|Boost}}

This example used Mersenne Twister generator. It can be changed by changing the typedef.

 

#include <vector>

#include "boost/random.hpp"

return 0;

}

 

=={{header|Clojure}}==

(def normals

(let [r (Random.)]

 

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

 

=={{header|D}}==

 

struct NormalRandom {

//x = nRnd;

x = nRnd();

 

===Alternative Version===

{{libheader|tango}}

 

 

void main() {

l = 1.0 + 0.5 * l;

}

 

=={{header|Delphi}}==

Delphi has RandG function which generates random numbers with normal distribution using Marsaglia-Bray algorithm:

 

 

{$APPTYPE CONSOLE}

Writeln('Std Deviation = ', StdDev(Values):6:4);

Readln;

{{out}}

<pre>Mean = 1.0098

 

=={{header|DWScript}}==

var i : Integer;

 

for i := values.Low to values.High do

 

=={{header|E}}==

 

=={{header|Eiffel}}==

class

APPLICATION

end

end

 

Example Result

Average: 1.0079398405028137

Standard Deviation: 0.49042787564453988

</pre>

 

=={{header|Elixir}}==

def normal(mean, sd) do

mean + sd * (:math.sqrt(-2 * :math.log(a)) * :math.cos(2 * :math.pi * b))

end

end

 

xs = for _ <- 1..1000, do: Random.normal(1.0, 0.5)

 

=={{header|Erlang}}==

{{works with|Erlang}}

 

mean(Values) ->

mean(tl(Values), hd(Values), 1).

io:format("mean = ~w\n", [mean(X)]),

io:format("stddev = ~w\n", [stddev(X)]).

{{out}}

<pre>

 

=={{header|ERRE}}==

PROGRAM DISTRIBUTION

 

 

END PROGRAM

 

=={{header|Euler Math Toolbox}}==

 

>v=normal(1,1000)*0.5+1;

>mean(v), dev(v)

1.00291801071

0.498226876528

 

=={{header|Euphoria}}==

{{trans|PureBasic}}

 

function RandomNormal()

for i = 1 to n do

s[i] = 1 + 0.5 * RandomNormal()

 

=={{header|Factor}}==

 

for i in [0:1000] : a+= norm_rand_num()

 

pi = 2*acos(0)

return 1 + (cos(2 * pi * random()) * pow(-2 * log(random()) ,1/2)) /2

 

=={{header|Fantom}}==

Two solutions. The first uses Fantom's random-number generator, which produces a uniform distribution. So, convert to a normal distribution using a formula:

 

class Main

{

}

}

 

The second calls out to Java's Gaussian random-number generator:

 

using [java] java.util::Random

 

}

}

 

=={{header|Forth}}==

{{works with|gforth|0.6.2}}

 

here to seed

 

0 do frnd-normal 0.5e f* 1e f+ f, loop ;

 

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

 

INTEGER, PARAMETER :: n = 1000

WRITE(*, "(A,F8.6)") "Standard Deviation = ", sd

 

 

{{out}}

Free Pascal provides the '''randg''' function in the RTL math unit that produces Gaussian-distributed random numbers with the Box-Müller algorithm.

 

function randg(mean,stddev: float): float;

 

 

=={{header|Go}}==

 

import (

"math/rand"

"time"

)

const mean = 1.0

const stdv = .5

 

func main() {

rand.Seed(time.Now().UnixNano())

for i := range list {

list[i] = mean + stdv*rand.NormFloat64()

}

 

=={{header|Groovy}}==

 

=={{header|Haskell}}==

 

 

pairs :: [a] -> [(a,a)]

 

result :: IO [Double]

 

=={{header|HicEst}}==

 

pi = 4 * ATAN(1)

 

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

 

Note that Unicon randomly seeds it's generator.

procedure main()

local L

every write(!L)

end

 

=={{header|IDL}}==

 

=={{header|J}}==

'''Solution:'''

zrand=: (2 o. 2p1 * urand) * [: %: _2 * [: ^. urand

 

 

'''Alternative Solution:'''<br>

Using the normal script from the [[j:Addons/stats/distribs|stats/distribs addon]].

1 0.5 rnorm 1000

 

=={{header|Java}}==

double mean = 1.0, std = 0.5;

Random rng = new Random();

for(int i = 0;i<list.length;i++) {

list[i] = mean + std * rng.nextGaussian();

 

=={{header|JavaScript}}==

return Math.cos(2 * Math.PI * Math.random()) * Math.sqrt(-2 * Math.log(Math.random()))

}

for (var i=0; i < 1000; i++){

a[i] = randomNormal() / 2 + 1

 

=={{header|jq}}==

 

''''A Pseudo-Random Number Generator''''

# The random numbers are in [0 -- 32767] inclusive.

# Input: an array of length at least 2 interpreted as [count, state, ...]

.[0] as $count | .[1] as $state

| ( (214013 * $state) + 2531011) % 2147483648 # mod 2^31

''''Box-Muller Method''''

# using the Box-Muller method: X = sqrt(-2 ln U) * cos(2 pi V) where U and V are uniform on [0,1].

# Input: [n, state]

next_rand_normal

| recurse( if .[0] < count then next_rand_normal else empty end)

'''Example'''

The task can be completed using: [0,1] | random_normal_variate(1; 0.5; 1000) | .[2]

 

We show just the sample average and standard deviation:

length as $l | add as $sum | ($sum/$l) as $a

| reduce .[] as $x (0; . + ( ($x - $a) | .*. ))

| [ $a, (./$l | sqrt)] ;

 

{{out}}

$ jq -n -c -f Random_numbers.jq

=={{header|Julia}}==

Julia's standard library provides a <code>randn</code> function to generate normally distributed random numbers (with mean 0 and standard deviation 0.5, which can be easily rescaled to any desired values):

 

=={{header|LabVIEW}}==

[[File:LV_array_of_randoms_with_given_mean_and_stdev.png]]

 

 

=={{header|Logo}}==

{{works with|UCB Logo}}

The earliest Logos only have a RANDOM function for picking a random non-negative integer. Many modern Logos have floating point random generators built-in.

localmake "max.int lshift -1 -1

output quotient random :max.int :max.int

end

 

 

for i = 1, 1000 do

list[i] = 1 + math.sqrt(-2 * math.log(math.random())) * math.cos(2 * math.pi * math.random()) / 2

 

Built-in function RandomReal with built-in distribution NormalDistribution as an argument:

 

=={{header|MATLAB}}==

 

Native support :

x = randn(1000,1) * sd + mu;

 

The statistics toolbox provides this function

 

This script uses the Box-Mueller Transform to transform a number from the uniform distribution to a normal distribution of mean = mu0 and standard deviation = chi2.

 

radiusSquared = +Inf;

randNum = (v .* scaleFactor .* chi2) + mu0;

 

 

Output:

 

ans =

 

 

=={{header|Maxima}}==

 

 

=={{header|MAXScript}}==

 

for i in 1 to 1000 do

(

c = 1.0 + 0.5 * sqrt (-2*log a) * cos (360*b) -- Maxscript cos takes degrees

append arr c

 

=={{header|Metafont}}==

Metafont has <code>normaldeviate</code> which produces pseudorandom normal distributed numbers with mean 0 and variance one. So the following complete the task:

 

 

m := 0; % m holds the mean, for testing purposes

 

show m, s; % and let's show that really they get what we wanted

 

A run gave

Assigning a value to the special variable '''randomseed''' will allow to have always

the same sequence of pseudorandom numbers

 

=={{header|Mirah}}==

 

list = double[999]

list[i] = mean + std * rng.nextGaussian

end

 

=={{header|МК-61/52}}==

ln ИП8 * 2 * КвКор ИП9 2 * пи

 

''Input'': РY - variance, РX - expectation.

Or:

 

 

to generate 1000 numbers with a mean of 1.0 and a standard deviation of 0.5.

{{trans|C}}

 

 

IMPORT Random;

rands[i] := 1.0D0 + 0.5D0 * RandNorm();

END;

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

 

return

{{out}}

<pre>

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

 

 

randomize()

 

{{out}}

 

=={{header|Objeck}}==

class RandomNumbers {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|OCaml}}==

let random_gaussian () =

1. +. sqrt (-2. *. log (Random.float 1.)) *. cos (2. *. pi *. Random.float 1.);;

 

=={{header|Octave}}==

disp(mean(p));

 

{{out}}

{{trans|REXX}}

===version 1===

pi=RxCalcPi() /* get value of pi */

Parse Arg n seed . /* allow specification of N & seed*/

Return RxCalcPower(_/n,.5)

 

{{out}}

<pre> old mean= 0.49830002

===version 2===

Using the nice function names in the algorithm.

pi=RxCalcPi() /* get value of pi */

Parse Arg n seed . /* allow specification of N & seed*/

sin: Return RxCalcSin(arg(1),,'R')

 

 

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

my(pr=32*ceil(default(realprecision)*log(10)/log(4294967296)),u1=random(2^pr)*1.>>pr,u2=random(2^pr)*1.>>pr);

\\ Could easily be extended with a second normal at very little cost.

};

 

=={{header|Pascal}}==

 

The following function calculates Gaussian-distributed random numbers with the Box-Müller algorithm:

function rnorm (mean, sd: real): real;

{Calculates Gaussian random numbers according to the Box-Müller approach}

u1 := random;

u2 := random;

end;

 

[[#Delphi | Delphi]] and [[#Free Pascal|Free Pascal]] support implement a '''randg''' function that delivers Gaussian-distributed random numbers.

 

=={{header|Perl}}==

 

my @nums = map {

1 + 0.5 * sqrt(-2 * log rand) * cos(2 * $PI * rand)

 

 

 

 

 

 

=={{header|PHP}}==

 

return mt_rand() / mt_getrandmax();

}

$a[$i] = 1.0 + ((sqrt(-2 * log(random())) * cos(2 * $pi * random())) * 0.5);

 

=={{header|PicoLisp}}==

{{trans|C}}

 

(de randomNormal () # Normal distribution, centered on 0, std dev 1

(link (+ 1.0 (/ (randomNormal) 2))) ) )

(for N (head 7 Result) # Print first 7 results

{{out}}

<pre>1.500334 1.212931 1.095283 0.433122 0.459116 1.302446 0.402477</pre>

 

=={{header|PL/I}}==

/* CONVERTED FROM WIKI FORTRAN */

Normal_Random: procedure options (main);

put skip edit ( "Standard Deviation = ", sd) (a, F(18,16));

END Normal_Random;

{{out}}

<pre>

 

=={{header|PL/SQL}}==

DECLARE

--The desired collection

END LOOP;

END;

 

=={{header|Pop11}}==

true -> popradians;

 

for i from 1 to 1000 do 1.0+0.5*random_normal() endfor;

;;; collect them into array

 

=={{header|PowerShell}}==

Equation adapted from Liberty BASIC

{

[CmdletBinding()]

$Measure = $RandomNormalNumbers | Measure-Object -Average

{{out}}

 

=={{header|Python}}==

;Using random.gauss:

>>> values = [random.gauss(1, .5) for i in range(1000)]

 

;Quick check of distribution:

count = len(numbers)

mean = sum(numbers) / count

>>> quick_check(values)

(1.0140373306786599, 0.49943411329234066)

 

Note that the ''random'' module in the Python standard library supports a number of statistical distribution methods.

 

;Alternatively using random.normalvariate:

>>> quick_check(values)

(0.990099111944864, 0.5029847005836282)

 

=={{header|R}}==

 

=={{header|Racket}}==

#lang racket

(for/list ([i 1000])

(add1 (* (sqrt (* -2 (log (random)))) (cos (* 2 pi (random))) 0.5)))

 

=={{header|Raven}}==

-1 acos

2 / 1 +

Quick Check (on linux with code in file rand.rv)

stdev = 0.497773

 

=={{header|REXX}}==

The REXX language doesn't have any "higher math" functions like SQRT/SIN/COS/LN/LOG/EXP/POW/etc.,

 

Programming note: &nbsp; note the range of the random numbers: &nbsp; (0,1]

<br>(that is, random numbers from &nbsp; zero──►unity, &nbsp; excluding zero, including unity).

say

end /*j*/

e: e =2.7182818284590452353602874713526624977572470936999595749669676277240766303535; return e /*digs overkill*/

pi: pi=3.1415926535897932384626433832795028841971693993751058209749445923078164062862; return pi /* " " */

sin: procedure; parse arg x;x=r2r(x);numeric fuzz min(5,digits()-3);if abs(x)=pi then return 0;return .sincos(x,x,1)

.sincos:parse arg z,_,i; x=x*x; p=z; do k=2 by 2; _=-_*x/(k*(k+i)); z=z+_; if z=p then leave; p=z; end; return z

xx=izz;ii=ii+is*2**k;end;x=x*e**-ii-1;z=0;_=-1;p=z;do k=1;_=-_*x;z=z+_/k;if z=p then leave;p=z;end; return z+ii

'''output''' &nbsp; when using the default inputs:

<pre>

 

=={{header|Ring}}==

for i = 1 to 10

see random(i) + nl

next i

 

 

=={{header|Rust}}==

'''Using a for-loop:'''

use rand::distributions::{Normal, IndependentSample};

 

*num = normal.ind_sample(&mut rng);

}

 

'''Using iterators:'''

use rand::distributions::{Normal, IndependentSample};

 

(0..1000).map(|_| normal.ind_sample(&mut rng)).collect()

};

 

=={{header|SAS}}==

/* Generate 1000 random numbers with mean 1 and standard deviation 0.5.

SAS version 9.2 was used to create this code.*/

end;

run;

Results:

<pre>

 

=={{header|Sather}}==

main is

a:ARRAY{FLTD} := #(1000);

#OUT + "dev " + dev + "\n";

end;

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

(define ((c-rand seed)) (set! seed (remainder (+ (* 1103515245 seed) 12345) 2147483648)) (quotient seed 65536))

 

 

(mean-sdev v)

 

=={{header|Seed7}}==

include "float.s7i";

include "math.s7i";

rands[i] := 1.0 + 0.5 * randomNormal;

end for;

 

=={{header|Sidef}}==

 

=={{header|Standard ML}}==

You can call the generator with <code>()</code> repeatedly to get a word in the range <code>[Rand.randMin, Rand.randMax]</code>.

You can use the <code>Rand.norm</code> function to transform the output into a <code>real</code> from 0 to 1, or use the <code>Rand.range (i,j)</code> function to transform the output into an <code>int</code> of the given range.

val gen = Rand.mkRandom seed;

fun random_gaussian () =

1.0 + Math.sqrt (~2.0 * Math.ln (Rand.norm (gen ()))) * Math.cos (2.0 * Math.pi * Rand.norm (gen ()));

 

2) Random (a subtract-with-borrow generator). You create the generator by calling <code>Random.rand</code> with a seed (of a pair of <code>int</code>s). You can use the <code>Random.randInt</code> function to generate a random int over its whole range; <code>Random.randNat</code> to generate a non-negative random int; <code>Random.randReal</code> to generate a <code>real</code> between 0 and 1; or <code>Random.randRange (i,j)</code> to generate an <code>int</code> in the given range.

val gen = Random.rand seed;

fun random_gaussian () =

1.0 + Math.sqrt (~2.0 * Math.ln (Random.randReal gen)) * Math.cos (2.0 * Math.pi * Random.randReal gen);

 

Other implementations of Standard ML have their own random number generators. For example, Moscow ML has a <code>Random</code> structure that is different from the one from SML/NJ.

 

=={{header|Tcl}}==

variable ::pi [expr acos(0)]

proc ::tcl::mathfunc::nrand {} {

for {set i 0} {$i < 1000} {incr i} {

lappend result [expr {$mean + $stddev*nrand()}]

 

=={{header|TorqueScript}}==

 

=={{header|Ursala}}==

a standard normal distribution. Mean and standard deviation

library functions are also used in this example.

#import flo

 

^(mean,stdev)* <

pop_stats(1.,0.5) 1000,

The output shows the mean and standard deviation for both sample vectors,

the latter being exact by construction.

 

=={{header|Visual FoxPro}}==

LOCAL i As Integer, m As Double, n As Integer, sd As Double

py = PI()

RETURN z

ENDFUNC

 

=={{header|Yorick}}==

Returns array of ''count'' random numbers with mean 0 and standard deviation 1.

return sqrt(-2*log(random(count))) * cos(2*pi*random(count));

 

Example of basic use:

 

=={{header|zkl}}==

pi:=(0.0).pi; // using the Box–Muller transform

rz1:=fcn{1.0-(0.0).random(1)} // from [0,1) to (0,1]

return('wrap(){((-2.0*rz1().log()).sqrt() * (2.0*pi*rz1()).cos())*sd + mean })

This creates a new random number generator, now to use it:

ns:=(0).pump(1000,List,g); // 1000 rands with mean==1 & sd==1/2

mean:=(ns.sum(0.0)/1000); //-->1.00379

// calc sd of list of numbers: