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

 

/**

+/- delta % of repeats/bincount.

*/

if (isCallable!TF) {

int[int] counts;

counts[func()]++;

immutable int deltaCount = cast(int)(delta / 100.0 * target);

 

if (abs(target - count) >= deltaCount)

throw new Exception(format(

k, count));

 

writeln(k, " ", counts[k]);

}

 

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

}

If compiled with -version=verify_distribution_uniformity_naive_main:

{{out}}

4 200016

5 200424</pre>

 

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

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

my(t);

};

 

 

test(dice7, 10^5)

Output:

 

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

{{trans|Tcl}}

unless block_given?

raise ArgumentError, "pass a block to this method"

end

end

 

p e

end

 

 

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

 

{{omit from|GUISS}}