Verify distribution uniformity/Naive: Difference between revisions

 

 

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

 

* 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:

* Some indication of the distribution achieved.

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

 

Show the distribution checker working when the produced distribution is flat enough and when it is not. (Use a generator from [[Seven-sided dice from five-sided dice]]).

 

See also:

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

<br><br>

 

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

=={{header|Elixir}}==

{{trans|Erlang}}

def naive( generator, times, delta_percent ) do

dict = Enum.reduce( List.duplicate(generator, times), Map.new, &update_counter/2 )

fun = fn -> Dice.dice7 end

IO.inspect VerifyDistribution.naive( fun, 100000, 3 )

 

{{out}}

 

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

math math.functions math.statistics math.vectors math.ranges ;

IN: rosetta-code.dice7

{ 1 10 100 1000 10000 100000 1000000 }

[| times | 0.02 7 [ dice7 ] times verify ] each

 

Output:

=={{header|Forth}}==

requires Forth200x locals

: init-bins ( n -- addr )

cells dup allocate throw tuck swap erase ;

and

loop

{{output}}

<pre>cr ' d7 1000000 7 1 check-distribution .

7 : 1416 ok

0</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|Java}}==

{{trans|D}}

{{works with|Java|8}}

import java.util.*;

import java.util.function.IntSupplier;

distCheck(() -> (int) (Math.random() * 5) + 1, 1_000_000, 1);

}

<pre>1 200439

2 201016

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

 

=={{header|Kotlin}}==

 

import java.util.Random

println()

checkDist(::dice5, 100_000)

 

Sample output:

=={{header|Liberty BASIC}}==

LB cannot pass user-defined function by name, so we use predefined function name - GENERATOR

n=1000

print "Testing ";n;" times"

GENERATOR = 1+int(rnd(0)*5) '1..5: dice5

end function

{{Out}}

<pre>

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

parse arg func times delta seed . /*obtain arguments (options) from C.L. */

if func=='' | func=="," then func= 'RANDOM' /*function not specified? Use default.*/

if times=='' | times=="," then times= 1000000 /*times " " " " */

if datatype(seed, 'W') then call random ,,seed /*use some RAND seed for repeatability.*/

do times /* [↓] perform a bunch of trials. */

/* [↓] compute the digit's skewness. */

/** [↑] show header and the separator.*/

say pad center(" (with " commas(times) ' trials)' , y) /*# trials. */

say pad center(" (skewed when exceeds " delta'%)' , y) /*skewed note.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

digit hits skew skew % result

 

=={{header|Ring}}==

# Project : Verify distribution uniformity/Naive

 

maxrnd = 7

func dice5

return random(5)

Output:

<pre>

Over 10000 runs dice5 passed distribution check

Over 100000 runs dice5 passed distribution check

</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.