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.

 

 

 

 

 

DistCheck(function, repetitions, delta)

}

Return, text

<pre>Distribution check:

 

Bucket 6 contains 1485 elements. Skewed.

Bucket 7 contains 1444 elements.</pre>

 

=={{header|C}}==

#include <math.h>

 

 

{

 

 

 

 

 

}

 

}

 

 

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

#include <iostream>

#include <cmath>

 

return good;

 

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

NIL

#<EQL Hash Table{7} 200CB5BB></pre>

 

=={{header|J}}==

 

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

:

n=. */y

delta=. x

expected=. n % # freqtable

errmsg=. 'Distribution is potentially skewed'

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

let h = Hashtbl.create 5 in

for i = 1 to n do

key target value)

) h;

 

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

{{trans|Tcl}}

unless block_given?

raise ArgumentError, "pass a block to this method"

end

end

 

p e

end

 

 

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

<span style="color:red">distribution potentially skewed for 0: expected around 50000, got 94873</span>