Verify distribution uniformity/Naive: Difference between revisions

{{trans|Python}}

 

R random:(1..5)

 

print(bin)

 

 

{{out}}

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

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

 

=={{header|Julia}}==

 

function distcheck(f::Function, rep::Int=10000, Δ::Int=3)

distcheck(x -> rand(1:5, x))

# Dice7 check

 

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

Testing two 'types' of 7-sided dice. Both appear to be fair.

{{trans|Raku}}

sub roll5 { 1+int rand(5) }

sub roll7_5 {

}

return $result . "\n";

{{out}}

<pre> 143 expected

 

=={{header|Phix}}==

{{out}}

<pre>

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

(formerly Perl 6)

Since the tested function is rolls of a 7 sided die, the test numbers are magnitudes of 10^x bumped up to the closest multiple of 7. This reduces spurious error from there not being an integer expected value.

sub roll7 { $d7.roll };

 

}

say '';

Sample output:

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

if func=='RANDOM' then ?= random(highDig) /*use RANDOM function.*/

else interpret '?=' func "(0,"highDig')' /* " specified " */

!.?= !.? + 1 /*bump the invocation counter.*/

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

g= times / (1 + highDig) /*calculate number of each digit throw.*/

pad= left('', 9) /*this is used for output indentation. */

say pad 'digit' center(" hits", w) ' skew ' "skew %" 'result' /*header. */

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

y= 5+1+w+1+6+1+6+1+6 /*width + seps*/

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

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

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

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

# Project : Verify distribution uniformity/Naive

 

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 ######################

=={{header|Scala}}==

===Imperative, ugly, mutable data===

 

private def distCheck(f: () => Int, nRepeats: Int, delta: Double): Unit = {

distCheck(() => 1 + util.Random.nextInt(5), 1_000_000, 1)

 

 

===Functional Style===

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/oYJWUvX/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/O513W3VoQ7ulspUMnGvTiQ Scastie (remote JVM)].

private def distCheck(f: () => Int, nRepeats: Int, delta: Double): Unit = {

val counts: Map[Int, Int] =

distCheck(() => 1 + util.Random.nextInt(5), 1_000_000, 1)

 

 

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

{{libheader|Wren-fmt}}

{{libheader|Wren-sort}}

 

var r = Random.new()

checkDist.call(dice5, 1e6, 0.5)

System.print()

 

{{out}}

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