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

{{task|Probability and statistics}}

 

=={{header|Ada}}==

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

$ ./Test_Chi_Square 522573 244456 139979 71531 21461

Degrees of Freedom: 4, Distance: 790063.28; (deviates significantly from uniform)</pre>

 

=={{header|C}}==

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

 

return sqs / avg;

}

 

return gammaIncompleteCompl(dof / 2, distance / 2);

}

 

bool x2IsUniform(T)(in T[] data, in real significance=0.05L)

return x2Prob(data.length - 1.0L, x2Dist(data)) > significance;

}

writefln(" %4s %12s %12s %8s %s",

"dof", "distance", "probability", "Uniform?", "dataset");

immutable dof = ds.length - 1;

immutable prob = x2Prob(dof, dist);

writefln("%4d %12.3f %12.8f %5s %6s",

}

{{out}}

<pre> dof distance probability Uniform? dataset

4 4.146 0.38657083 YES [199809, 200665, 199607, 200270, 199649]

4 790063.276 0.00000000 NO [522573, 244456, 139979, 71531, 21461]</pre>

 

=={{header|Fortran}}==

{{libheader|GNU Scientific Library}}

 

 

 

 

Now we're ready to complete the task.

 

 

 

 

 

 

contains

 

 

 

 

 

 

 

 

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

uniform? false

</pre>

 

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

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>

 

=={{header|OCaml}}==

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

 

 

$z**$s / $s * exp(-$z) * $M;

}

}

}

my $expected = $N / $n;

}

{{out}}

 

=={{header|Python}}==

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]

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

dof: 4 distance: 790063.275940 probability: 0.0000 uniform? No</pre>

 

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

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

distribution "4 21461 0 522573 1 244456 2 139979 3 71531" assessed as unfair</pre>

 

{{omit from|GUISS}}