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

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

{{trans|Liberty BASIC}}

Randomize Timer

Function dice5() As Integer

Print

Sleep

{{out}}

<pre>

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

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

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

Example usage:

=={{header|Nim}}==

proc rand5(): int = rand(1..5)

checkDist(rand5, 1_000_000, 0.5)

{{out}}

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">check</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">fid</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">range</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">iterations</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">atom</span> <span style="color: #000000;">delta</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d iterations: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">flats</span><span style="color: #0000FF;">[</span><span style="color: #000000;">flat</span><span style="color: #0000FF;">+</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

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

The word <code>distribution</code> tests a specified word (Quackery function) which should return numbers in the range 1 to 7 inclusive. The word <code>dice7</code>, which satisfies this requirement, is defined at [[Seven-sided dice from five-sided dice#Quackery]].

[ 7 times

say "s is sketchy."

cr ] ]

{{out}}

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

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

commas: parse arg _; do jc=length(_)-3 to 1 by -3; _=insert(',', _, jc); end; return _

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

<pre>

=={{header|Ring}}==

# Project : Verify distribution uniformity/Naive

func dice5

return random(5)

Output:

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

=={{header|Vlang}}==

{{trans|go}}

import rand.seed

import math

max, flat_enough = dist_check(dice7, 7, calls, 500)

println("Max delta: $max Flat enough: $flat_enough")

{{out}}

<pre>

{{libheader|Wren-fmt}}

{{libheader|Wren-sort}}

import "/fmt" for Fmt

import "/sort" for Sort

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.