Verify distribution uniformity/Naive: Difference between revisions

{{task|Probability and statistics}}

 

Create a function to check that the random integers returned from a small-integer generator function have uniform distribution.

 

The function should take as arguments:

* The number of times to call the integer generator.

* A 'delta' value of some sort that indicates how close to a flat distribution is close enough.

 

The function should produce:

* An 'error' if the distribution is not flat enough.

 

 

See also:

*[[Verify distribution uniformity/Chi-squared test]]

 

=={{header|Ada}}==

 

 

procedure Naive_Random is

 

Ada.Text_IO.Put_Line("Test Passed? (" & Boolean'Image(OK) & ")");

 

Sample run 1 (all buckets good):<pre>7

 

=={{header|AutoHotkey}}==

 

DistCheck(function, repetitions, delta)

}

Return, text

<pre>Distribution check:

 

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

{{works with|BBC BASIC for Windows}}

FOR r% = 2 TO 5

check% = FNdistcheck(FNdice5, 10^r%, 0.05)

= s%

Output:

<pre>

 

=={{header|C}}==

#include <stdio.h>

#include <math.h>

 

return 0;

Count = 10: bin 1 out of range: 1 (-30% vs 3%), NOT flat

Count = 100: bin 1 out of range: 11 (-23% vs 3%), NOT flat

Count = 1000000: flat

</pre>

 

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

#include <iostream>

#include <cmath>

 

return good;

 

=={{header|Clojure}}==

The code could be shortened if the verify function did the output itself, but the "Clojure way" is to have functions, whenever possible, avoid side effects (like printing) and just return a result. Then the "application-level" code uses doseq and println to display the output to the user. The built-in (rand-int) function is used for all three runs of the verify function, but first with small N to simulate experimental error in a small sample size, then with larger N to show it working properly on large N.

(let [rands (frequencies (repeatedly n rand))

avg (/ (reduce + (map val rands)) (count rands))

[num count okay?] (verify #(rand-int 7) n)]

(println "Saw" num count "times:"

 

<pre>Saw 1 13 times: that's acceptable

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

{{trans|OCaml}}

(let ((bins (make-hash-table)))

(loop repeat n do (incf (gethash (funcall function) bins 0)))

do (format t "~&Distribution potentially skewed for ~w:~

expected around ~w got ~w." key target value)

 

<pre>> (check-distribution 'd7 1000)

 

=={{header|D}}==

 

/**

distCheck(() => uniform(1, 6), 1_000_000, 1);

}

If compiled with -version=verify_distribution_uniformity_naive_main:

{{out}}

4 200016

5 200424</pre>

 

=={{header|Erlang}}==

-module( verify_distribution_uniformity ).

 

 

update_counter( Fun, Dict ) -> dict:update_counter( Fun(), 1, Dict ).

 

{{out}}

Following the task verbatim.

 

>function checkrandom (frand$, n:index, delta:positive real) ...

$ v=zeros(1,n);

>checkrandom("wrongdice",1000000,1)

0

 

Checking the dice7 from dice5 generator.

 

>function dice5 () := intrandom(1,1,5);

>function dice7 () ...

>checkrandom("dice7",1000000,1)

1

 

Faster implementation with the matrix language.

 

>function dice5(n) := intrandom(1,n,5)-1;

>function dice7(n) ...

>checkrandom(wrongdice(1000000))

0

 

=={{header|Factor}}==

 

: dice5 ( -- x )

;

 

: dice7 ( -- x )

0 [ dup 21 < ] [ drop dice5 5 * dice5 + 6 - ] do until

;

 

;

 

! there is the number of ones in the input array, in the second position

! of the result there is the number of twos in the input array, etc.

;

 

! Verify distribution uniformity/Naive. Delta is the acceptable deviation

! from the ideal number of items in each bucket, expressed as a fraction of

! produces a random number on stack in the range [1..sides], times is the

! number of times to call it.

dup .

times sides / :> ideal-count

ideal-count v-n vabs

times v/n

;

 

: verify-all ( -- )

{ 1 10 100 1000 10000 100000 1000000 }

 

Output:

"Not random enough"

"Not random enough"

"Not random enough"

"Random enough"

"Random enough"

"Random enough"</pre>

 

=={{header|Fortran}}==

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

 

interface

deallocate(buckets)

 

=={{header|Go}}==

 

import (

max, flatEnough = distCheck(dice7, 7, calls, 500)

fmt.Println("Max delta:", max, "Flat enough:", flatEnough)

Output:

<pre>

 

=={{header|Haskell}}==

import Data.List

import Control.Monad

ul = round $ (100 + fromIntegral d)/100 * avg

ll = round $ (100 - fromIntegral d)/100 * avg

Example:

(1,(16911,True))

(2,(16599,True))

(4,(16624,True))

(5,(16526,True))

 

=={{header|Hy}}==

 

(import [random [randint]])

 

(all (list-comp

(<= (- target delta) (/ n repeats) (+ target delta))

 

Examples of use:

 

(fn [] (randint 1 10))

(fn [] (if (randint 0 1) (randint 1 9) (randint 1 10)))]]

 

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

This example assumes the random number generator is passed to <code>verify_uniform</code> as a co-expression. The co-expression <code>rnd</code> is prompted for its next value using <code>@rnd</code>. The co-expression is created using <code>create (|?10)</code> where the vertical bar means generate an infinite sequence of what is to its right (in this case, <code>?10</code> generates a random integer in the range [1,10]).

# n : the number of numbers to test

# delta: tolerance in non-uniformity

then write ("uniform")

else write ("skewed")

Output:

<pre>

 

The ''delta'' is given as an optional left argument (<code>x</code>), defaulting to 5%. The right argument (<code>y</code>) is any valid argument to the distribution generating verb.

0.05 u checkUniform y

:

errmsg assert (delta * expected) > | expected - {:"1 freqtable

freqtable

It is possible to use tacit expressions within an explicit definition enabling a more functional and concise style:

0.05 u checkUniformT y

:

errmsg assert ((n % #) (x&*@[ > |@:-) {:"1) freqtable

freqtable

Show usage using <code>rollD7t</code> given in [[Seven-dice from Five-dice#J|Seven-dice from Five-dice]]:

1 14082

2 14337

0.05 rollD7t checkUniform 1e2

|Distribution is potentially skewed: assert

 

=={{header|JavaScript}}==

{{trans|Tcl}}

if (opts === undefined) opts = {}

opts['delta'] = opts['delta'] || 2;

} catch (e) {

print(e);

Output:

<pre>0 9945

distribution potentially skewed for 0: expected result around 50000, got 95040</pre>

 

CheckDistribution[function_,number_,delta_] :=(Print["Expected: ", N[number/7], ", Generated :",

Transpose[Tally[Table[function, {number}]]][[2]] // Sort]; If[(Max[#]-Min[#])&

 

Example usage:

->Expected: 14285.7, Generated :{14182,14186,14240,14242,14319,14407,14424}

->"Flat"</pre>

 

=={{header|OCaml}}==

let h = Hashtbl.create 5 in

for i = 1 to n do

key target value)

) h;

 

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

This tests the purportedly random 7-sided die with a slightly biased 1000-sided die.

dice7()={

 

test(dice7, 10^5)

Output:

<pre>Flat with significance 0.2931867820813680387842134664085280183

### user error: Not flat enough, significance only 5.391077606003910233 E-3500006</pre>

 

 

 

 

my @dist;

my $expect = $n / 7;

my $pct = ($v - $expect)/$expect*100;

}

 

 

 

 

</pre>

 

=={{header|PicoLisp}}==

(one-tenth of a percent), and a 'prg' code body (i.e. an arbitrary number of

executable expressions).

(let Res NIL

(do Cnt (accu 'Res (run Prg 1) 1))

Max (*/ N (+ 1000 Pm) 1000) )

(for R Res

Output:

<pre>: (checkDistribution 100000 5 (rand 1 7))

 

=={{header|PureBasic}}==

 

Procedure.s distcheck(*function.RandNum_prt, repetitions, delta.d)

EndProcedure

 

A small delta was chosen to increase the chance of a skewed result in the sample output:

<pre>Distribution check:

=={{header|Python}}==

{{works with|Python|3.1}}

from pprint import pprint as pp

 

for key, count in sorted(bin.items()) ]

)

Sample output:

<pre>>>> distcheck(dice5, 1000000, 1)

for key, count in sorted(bin.items()) ]

AssertionError: Bin distribution skewed from 200 +/- 2: [(1, 4), (2, -33), (3, 6), (4, 11), (5, 12)]</pre>

 

=={{header|R}}==

{

if(is.character(fn))

data.frame(value=names(counts), counts=as.vector(counts), status=status)

}

 

=={{header|Racket}}==

Returns a pair of a boolean stating uniformity and either the "uniform" distribution or a report of the first skew number found.

 

(define (pretty-fraction f)

(if (integer? f) f

(test-uniformity/naive straight-die 1000 5)

; Test whether a biased die fails:

 

{{out}}

'(#t (1 . 169) (2 . 185) (3 . 184) (4 . 163) (5 . 144) (6 . 155))

'(#f . "test-uniformity/naive distribution of #<procedure:crooked-die> potentially skewed for 6. expected 166 2/3 got 262")</pre>

 

=={{header|REXX}}==

 

<pre>

</pre>

 

=={{header|Ruby}}==

{{trans|Tcl}}

unless block_given?

raise ArgumentError, "pass a block to this method"

p e

end

 

{{out}}

 

=={{header|Run BASIC}}==

dim num(100)

for i = 1 to 1000

for i = 1 to 10

print using("###",i);" "; using("#####",num(i));" ";left$(s$,num(i) / 5)

1 90 ##################

2 110 ######################

9 82 ################

10 92 ##################*</pre>

 

=={{header|Tcl}}==

for {set i 0} {$i<$times} {incr i} {incr vals([uplevel 1 $random])}

set target [expr {$times / [array size vals]}]

foreach k [lsort -integer [array names vals]] {lappend result $k $vals($k)}

return $result

Demonstration:

puts [distcheck {expr {int(10*rand())}} 100000]

 

# Now, one that definitely isn't!

Which produces this output (error in red):

0 10003 1 9851 2 10058 3 10193 4 10126 5 10002 6 9852 7 9964 8 9957 9 9994

 

=={{header|VBScript}}==

 

sub verifydistribution(calledfunction, samples, delta)

& ", desired limit is " & FormatPercent(delta, 2) & "."

if maxdiff > delta then wscript.echo "Skewed!" else wscript.echo "Smooth!"

Demonstration with included [[Seven-sided dice from five-sided dice#VBScript]] code:

Which produces this output:

Running "dice7" 1000 times...

Maximum found variation is 0.94%, desired limit is 3.00%.

Smooth!

 

=={{header|zkl}}==

This tests the random spread over 0..9. It starts at 10 samples and doubles the sample size until the spread is within 0.1% of 10% for each bucket.

dist:=L(0,0,0,0,0,0,0,0,0,0);

do(N){n:=(0).random(10); dist[n]=dist[n]+1}

 

n:=10;

{{out}}

Reported numbers is the percent that bucket has of all samples.