Verify distribution uniformity/Chi-squared test: Difference between revisions

{{trans|Python}}

 

V k1_factrl = 1.0

[Float] c

V prob = chi2Probability(dof, distance)

print(‘probability: #.4’.format(prob), end' ‘ ’)

 

{{out}}

=={{header|Ada}}==

First, we specify a simple package to compute the Chi-Square Distance from the uniform distribution:

type Flt is digits 18;

function Distance(Bins: Bins_Type) return Flt;

 

Next, we implement that package:

 

function Distance(Bins: Bins_Type) return Flt is

end Distance;

 

Finally, we actually implement the Chi-square test. We do not actually compute the Chi-square probability; rather we hardcode a table of values for 5% significance level, which has been picked from Wikipedia [http://en.wikipedia.org/wiki/Chi-squared_distribution]:

 

procedure Test_Chi_Square is

Put_Line("; (deviates significantly from uniform)");

end if;

 

{{out}}

This first sections contains the functions required to compute the Chi-Squared probability.

These are not needed if a library containing the necessary function is availabile (e.g. see [[Numerical Integration]], [[Gamma function]]).

#include <stdio.h>

#include <math.h>

 

return 1.0 - Simpson3_8( &f0, 0, y, (int)(y/h))/Gamma_Spouge(a);

This section contains the functions specific to the task.

{

double expected = 0.0;

double dist = chi2UniformDistance( dset, dslen);

return chi2Probability( dof, dist ) > significance;

Testing

{

double dset1[] = { 199809., 200665., 199607., 200270., 199649. };

}

return 0;

 

=={{header|D}}==

 

real x2Dist(T)(in T[] data) pure nothrow @safe @nogc {

dof, dist, prob, ds.x2IsUniform ? "YES" : "NO", ds);

}

{{out}}

<pre> dof distance probability Uniform? dataset

=={{header|Elixir}}==

{{trans|Ruby}}

defp gammaInc_Q(a, x) do

a1 = a-1

:io.fwrite " probability: ~.4f~n", [Verify.chi2Probability(dof, distance)]

:io.fwrite " uniform? ~s~n", [(if Verify.chi2IsUniform(ds), do: "Yes", else: "No")]

 

{{out}}

Instead of implementing the chi-squared distribution by ourselves, we bind to GNU Scientific Library; so we need a module to interface to the function we need (<tt>gsl_cdf_chisq_Q</tt>)

 

 

use iso_c_binding

end function p_value

 

 

Now we're ready to complete the task.

 

 

use gsl_mini_bind_m, only: p_value

end function chisq

 

 

Output:

dof: 4 chisq: 4.1463

probability: 0.3866

dof: 4 chisq: 790063.2500

probability: 0.0000

 

=={{header|Go}}==

{{trans|C}}

Go has a nice gamma function in the library. Otherwise, it's mostly a port from C. Note, this implementation of the incomplete gamma function works for these two test cases, but, I believe, has serious limitations. See talk page.

 

import (

fmt.Printf(" significant at %2.0f%% level? %t\n", sigLevel*100, sig)

fmt.Println(" uniform? ", !sig, "\n")

Output:

<pre>

 

=={{header|Hy}}==

[scipy.stats [chisquare]]

[collections [Counter]])

size 'alpha'."

(<= alpha (second (chisquare

 

Examples of use:

 

 

(for [f [

(fn [] (randint 1 10))

(fn [] (if (randint 0 1) (randint 1 9) (randint 1 10)))]]

 

=={{header|J}}==

'''Solution (Tacit):'''

 

countCats=: #@~. NB. counts the number of unique items

NB. y is: distribution to test

NB. x is: optionally specify number of categories possible

 

'''Solution (Explicit):'''

 

NB.*isUniformX v Tests (5%) whether y is uniformly distributed

degfreedom=. <: x NB. degrees of freedom

signif > degfreedom chisqcdf :: 1: X2

 

'''Example Usage:'''

UnfairDistrib=: (9.5e5 ?@$ 5) , (5e4 ?@$ 4)

isUniformX FairDistrib

1

4 isUniform 4 4 4 5 5 5 5 5 5 5 NB. not uniform if 4 categories possible

 

=={{header|Java}}==

{{trans|D}}

{{works with|Java|8}}

import java.util.Arrays;

import static java.util.Arrays.stream;

}

}

<pre> dof distance probability Uniform? dataset

4 4,146 0,38657083 YES [199809.0, 200665.0, 199607.0, 200270.0, 199649.0]

 

=={{header|Julia}}==

 

using Distributions

println("Data:\n$data")

println("Hypothesis test: the original population is ", (eqdist(data) ? "" : "not "), "uniform.\n")

 

{{out}}

=={{header|Kotlin}}==

This program reuses Kotlin code from the [[Gamma function]] and [[Numerical Integration]] tasks but otherwise is a translation of the C entry for this task.

 

typealias Func = (Double) -> Double

println(" Uniform? $uniform\n")

}

 

{{out}}

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

This code explicity assumes a discrete uniform distribution since the chi square test is a poor test choice for continuous distributions and requires Mathematica version 2 or later

If[$VersionNumber >= 8,

confLevel <= PearsonChiSquareTest[data, DiscreteUniformDistribution[{min, max}]],

GammaRegularized[k/2, 0, v/2] <= 1 - confLevel]]

 

code used to create test data requires Mathematica version 6 or later

{{out}}<pre>{True,False}</pre>

 

We use the gamma function from the “math” module. To simplify the code, we use also the “lenientops” module which provides mixed operations between floats ane integers.

 

 

func simpson38(f: (float) -> float; a, b: float; n: int): float =

for dset in [[199809, 200665, 199607, 200270, 199649],

[522573, 244456, 139979, 71531, 21461]]:

 

{{out}}

This code needs to be compiled with library [http://oandrieu.nerim.net/ocaml/gsl/ gsl.cma].

 

 

let chi2UniformDistance distrib =

[| 199809; 200665; 199607; 200270; 199649 |];

[| 522573; 244456; 139979; 71531; 21461 |]

 

Output

 

The sample data for the test was taken from [[#Go|Go]].

my(g=gamma(dof/2));

incgam(dof/2,chi2/2,g)/g

 

test([199809, 200665, 199607, 200270, 199649])

 

=={{header|Perl}}==

{{trans|Raku}}

use constant pi => 3.14159265;

 

for $dataset ([199809, 200665, 199607, 200270, 199649], [522573, 244456, 139979, 71531, 21461]) {

printf "C2 = %10.3f, p-value = %.3f, uniform = %s\n", chi_squared_test(@$dataset);

{{out}}

<pre>C2 = 4.146, p-value = 0.387, uniform = True

=={{header|Phix}}==

{{trans|Go}}

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

<span style="color: #008080;">function</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">aa1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">t</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">utest</span><span style="color: #0000FF;">({</span><span style="color: #000000;">199809</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">200665</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">199607</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">200270</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">199649</span><span style="color: #0000FF;">})</span>

<span style="color: #000000;">utest</span><span style="color: #0000FF;">({</span><span style="color: #000000;">522573</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">244456</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">139979</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">71531</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">21461</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

Implements the Chi Square Probability function with an integration. I'm

sure there are better ways to do this. Compare to OCaml implementation.

import random

 

prob = chi2Probability( dof, distance)

print "probability: %.4f"%prob,

Output:

<pre>Data set: [199809, 200665, 199607, 200270, 199649]

This uses the library routine [https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.chisquare.html scipy.stats.chisquare].

 

 

 

dist, pvalue = chisquare(ds)

uni = 'YES' if pvalue > 0.05 else 'NO'

 

{{out}}

=={{header|R}}==

R being a statistical computating language, the chi-squared test is built in with the function "chisq.test"

dset1=c(199809,200665,199607,200270,199649)

dset2=c(522573,244456,139979,71531,21461)

print(paste("uniform?",chi2IsUniform(ds)))

}

 

Output:

 

=={{header|Racket}}==

#lang racket

(require

; Test whether the constant generator fails:

(is-uniform? (λ(_) 5) 1000 0.05)

Output:

#t

#f

 

=={{header|Raku}}==

in closed form, as we only need its value at integers and half integers.

 

my \numers = $z X** 1..*;

my \denoms = [\*] $s X+ 1..*;

say 'data: ', $dataset;

say "χ² = {%t<chi-squared>}, p-value = {%t<p-value>.fmt('%.4f')}, uniform = {%t<uniform>}";

{{out}}

<pre>data: 199809 200665 199607 200270 199649

either an integer, &nbsp; or a number which is a multiple of &nbsp; <big>'''¹/₂'''</big>, &nbsp; both of these cases can be calculated with

<br>a straight─forward calculation.

numeric digits length( pi() ) - length(.) /*enough decimal digs for calculations.*/

@.=; @.1= 199809 200665 199607 200270 199649

say pad "significant at " sigPC'% level? ' word('no yes', sig + 1)

say pad " is the dataset uniform? " word('no yes', (\(sig))+ 1)

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

<pre>

=={{header|Ruby}}==

{{trans|Python}}

a1, a2 = a-1, a-2

f0 = lambda {|t| t**a1 * Math.exp(-t)}

puts " probability: %.4f" % chi2Probability(dof, distance)

puts " uniform? %s" % (chi2IsUniform(ds) ? "Yes" : "No")

 

{{out}}

 

=={{header|Rust}}==

use statrs::function::gamma::gamma_li;

 

}

 

{{out}}

<pre>

{{libheader|Scastie qualified}}

{{works with|Scala|2.13}}

 

object ChiSquare extends App {

dof, dist, χ2Prob(dof.toDouble, dist), if (χ2IsUniform(ds, 0.05)) "YES" else "NO", ds.mkString(", "))

}

 

=={{header|Sidef}}==

func F1(a, b, z, limit=100) {

sum(0..limit, {|k|

say "data: #{dataset}"

say "χ² = #{r[0]}, p-value = #{r[1].round(-4)}, uniform = #{r[2]}\n"

{{out}}

<pre>

{{works with|Tcl|8.5}}

{{tcllib|math::statistics}}

package require math::statistics

 

[expr {$degreesOfFreedom / 2.0}] [expr {$X2 / 2.0}]]

expr {$likelihoodOfRandom > $significance}

Testing:

for {set i 0} {$i<$count} {incr i} {incr distribution([uplevel 1 $operation])}

return [array get distribution]

puts "distribution \"$distFair\" assessed as [expr [isUniform $distFair]?{fair}:{unfair}]"

set distUnfair [makeDistribution {expr int(rand()*rand()*5)}]

Output:

<pre>distribution "0 199809 4 199649 1 200665 2 199607 3 200270" assessed as fair

=={{header|VBA}}==

The built in worksheetfunction ChiSq_Dist of Excel VBA is used. Output formatted like R.

'Returns true if the observed frequencies pass the Pearson Chi-squared test at the required significance level.

Dim Total As Long, Ei As Long, i As Integer

O = [{522573,244456,139979,71531,21461}]

Debug.Print "[1] ""Uniform? "; Test4DiscreteUniformDistribution(O, 0.05); """"

{{out}<pre>[1] "Data set:" 199809 200665 199607 200270 199649

Chi-squared test for given frequencies

=={{header|Vlang}}==

{{trans|Go}}

 

type Ifctn = fn(f64) f64

println(" significant at ${sig_level*100:2.0f}% level? $sig")

println(" uniform? ${!sig}\n")

{{out}}

<pre>

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

 

var uniform = chiIsUniform.call(ds, 0.05) ? "Yes" : "No"

System.print(" Uniform? %(uniform)\n")

 

{{out}}

{{trans|C}}

{{trans|D}}

fcn Simpson3_8(f,a,b,N){ // fcn,double,double,Int --> double

h,h1:=(b - a)/N, h/3.0;

if(y>x) y=x;

1.0 - Simpson3_8(f,0.0,y,(y/h).toInt())/Gamma_Spouge(a);

dslen :=ds.len();

expected:=dslen.reduce('wrap(sum,k){ sum + ds[k] },0.0)/dslen;

fcn chiIsUniform(dset,significance=0.05){

significance < chi2Probability(-1.0 + dset.len(),chi2UniformDistance(dset))

T(522573.0, 244456.0, 139979.0, 71531.0, 21461.0) );

println(" %4s %12s %12s %8s %s".fmt(

dof, dist, prob, chiIsUniform(ds) and "YES" or "NO",

ds.concat(",")));

{{out}}

<pre>