Permutation test: Difference between revisions

was measured and reported in this table.

 

|+ Table of experimental results

|- style="background-color: rgb(255, 204, 255);"

* Report the percentage of alternative groupings for which the difference in means is less or equal to the actual experimentally observed difference in means, and the percentage for which it is greater.

* Note that they should sum to 100%.

 

Extremely dissimilar values are evidence of an effect not entirely due

that's easier than loading them at run time. Test your solution on the

data given above.

 

=={{header|Ada}}==

 

 

procedure Permutation_Test is

New_Line;

end;

 

This solution uses an auxiliary package Iterate_Subsets. Here is the Spec:

Subset_Size, More_Elements: Positive;

package Iterate_Subsets is

 

end Iterate_Subsets;

 

And here is the implementation:

 

 

function First return Subset is

end Last;

 

 

{{out}}

</pre>

 

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

nplacebo% = 10

DIM results%(ntreated% + nplacebo% - 1)

N% = (N% + (N% >>> 4)) AND &0F0F0F0F

N% += N% >>> 8 : N% += N% >>> 16

{{out}}

<pre>

 

=={{header|C}}==

 

int data[] = { 85, 88, 75, 66, 25, 29, 83, 39, 97,

100 * le / total, le, 100 * gt / total, gt);

return 0;

 

=={{header|Common Lisp}}==

(let ((more 0) (leq 0)

(all-data (append s1 s2))

(format t "<=: ~a ~6f%~% >: ~a ~6f%~%"

x (* 100e0 (/ x s))

 

=={{header|D}}==

 

auto permutationTest(T)(in T[] a, in T[] b) pure nothrow @safe {

immutable under = permutationTest(treatmentGroup, controlGroup);

writefln("Under =%6.2f%%\nOver =%6.2f%%", under, 100.0 - under);

{{out}}

<pre>Under = 87.20%

Alternative version:

{{trans|C}}

import std.stdio, std.algorithm, std.range;

 

writefln(" > : %2.2f%% %d", 100.0 * gt / t, gt);

writefln("<= : %2.2f%% %d", 100.0 * le / t, le);

{{out}}

<pre> > : 12.80% 11827

<= : 87.20% 80551</pre>

 

=={{header|Elixir}}==

{{trans|Ruby}}

def statistic(ab, a) do

sumab = Enum.sum(ab)

controlGroup = [68, 41, 10, 49, 16, 65, 32, 92, 28, 98]

under = Permutation.test(treatmentGroup, controlGroup)

 

{{out}}

 

=={{header|GAP}}==

b := [68, 41, 10, 49, 16, 65, 32, 92, 28, 98];

 

# in order, % less or greater than original diff

PermTest(a, b);

 

=={{header|Go}}==

A version doing all math in integers until computing final percentages.

 

import "fmt"

}

rc(0, 0)

{{out}}

<pre>

 

=={{header|Haskell}}==

where f = scanl (*) 1 [1..]

 

[68, 41, 10, 49, 16, 65, 32, 92, 28, 98]

in do putStr "> : "; print r

{{out}}

<pre>

 

Somewhat faster, this goes from top down:

where f = scanl (*) 1 [1..]

 

(a, b) = perms [85, 88, 75, 66, 25, 29, 83, 39, 97]

[68, 41, 10, 49, 16, 65, 32, 92, 28, 98]

 

In cases where the sample data are a large number of relatively small positive integers, counting number of partial sums is a lot faster:

f a n = merge a (map (addNum n) $ filter (\(l,_,_) -> l < len) a)

addNum n (a,s,c)

-- how many combinations are less than current sum

main = print$ permtest [85, 88, 75, 66, 25, 29, 83, 39, 97]

 

=={{header|J}}==

trmt=: 0.85 0.88 0.75 0.66 0.25 0.29 0.83 0.39 0.97

ctrl=: 0.68 0.41 0.1 0.49 0.16 0.65 0.32 0.92 0.28 0.98

all=: trmt(#@[ ({. difm }.) |:@([ (comb ~.@,"1 i.@])&# ,) { ,) ctrl

smoutput 'under: ','%',~":100*mean all <: result

 

Result:

=={{header|jq}}==

{{works with|jq|1.4}}

'''Part 1: Combinations'''

def combination(r):

if r > length or r < 0 then empty

( .[1:]|combination(r))

end;

'''Part 2: Permutation Test'''

def permutationTest(a; b):

 

| .[1] += 1 )

| .[0] * 100.0 / .[1] # under/count

'''Example:'''

def controlGroup: [68, 41, 10, 49, 16, 65, 32, 92, 28, 98];

 

permutationTest(treatmentGroup; controlGroup) as $under

{{out}}

$ jq -n -r -f permutation_test.jq

 

=={{header|Julia}}==

 

'''Functions'''

 

asel[sel] = false

end

 

better += 1

else

end

end

 

'''Main'''

 

 

tot = better + worse

 

println("Permutation test using the following data:")

println("Control: ", control)

 

{{out}}

 

There are 92378 different permuted groups of these data.

11827, 12.80% showed better than actual results.

</pre>

 

ToString[#2 - #1] <> " " <> ToString[100. (1 - #1/#2)] <> "%" &[

Count[Total /@ Subsets[Join[#1, #2], {Length@#1}],

n_ /; n <= Total@#1],

Binomial[Length@#1 + Length@#2, Length@#1]] &[{85, 88, 75, 66, 25,

{{out}}

<pre><=: 80551 87.1972%

>: 11827 12.8028%</pre>

 

 

 

 

 

 

{{out}}

 

=={{header|Perl}}==

use warnings;

use strict;

92

28

{{out}}

equal 313 0.339%

greater 11827 12.803%

 

 

 

 

 

 

 

{{out}}

 

=={{header|PureBasic}}==

the treatment group or the control group

 

 

Define.f meanTreated,meanControl,diffInMeans

Debug StrF(100*diffLessOrEqual/TotalComBinations,2)+" "+Str(diffLessOrEqual)

Debug StrF(100*diffGreater /TotalComBinations,2)+" "+Str(diffGreater)

 

{{out}}

12.80 11827

</pre>

 

=={{header|Python}}==

{{trans|Tcl}}

 

def statistic(ab, a):

controlGroup = [68, 41, 10, 49, 16, 65, 32, 92, 28, 98]

under = permutationTest(treatmentGroup, controlGroup)

{{out}}

<pre>under=89.11%, over=10.89%</pre>

 

The above solution does a different thing than the other solutions. I'm not really sure why. If you want to do the same thing as the other solutions, then this is the solution:

 

def permutationTest(a, b):

controlGroup = [68, 41, 10, 49, 16, 65, 32, 92, 28, 98]

under = permutationTest(treatmentGroup, controlGroup)

{{out}}

<pre>under=87.20%, over=12.80%</pre>

 

=={{header|R}}==

 

perms <- combinations(length(treatment)+length(control),

length(treatment),

p <- mean(rowMeans(perms) <= mean(treatment))

c(under=p, over=(1-p))

 

+ c(68, 41, 10, 49, 16, 65, 32, 92, 28, 98))

under over

 

=={{header|Racket}}==

{{trans|Common Lisp}}

 

 

(define-syntax-rule (inc! x)

more (real->decimal-string (* 100. (/ more sum)) 2)

leq (real->decimal-string (* 100. (/ leq sum)) 2))))

 

{{out}}

<=: 80551 87.20%

>: 11827 12.80%

</pre>

 

=={{header|Ruby}}==

{{trans|Python}}

sumab, suma = ab.inject(:+).to_f, a.inject(:+).to_f

suma / a.size - (sumab - suma) / (ab.size - a.size)

controlGroup = [68, 41, 10, 49, 16, 65, 32, 92, 28, 98]

under = permutationTest(treatmentGroup, controlGroup)

 

{{out}}

under=87.20%, over=12.80%

</pre>

 

=={{header|Seed7}}==

include "float.s7i";

 

writeln("<= : " <& 100.0 * flt(le) / flt(total) digits 6 <& "% " <& le);

writeln(" > : " <& 100.0 * flt(gt) / flt(total) digits 6 <& "% " <& gt);

{{out}}

 

=={{header|Sidef}}==

{{trans|Ruby}}

suma/a.size - ((sumab-suma) / (ab.size-a.size))

}

 

func permutationTest(a, b) {

}

 

{{out}}

<pre>

 

=={{header|Tcl}}==

 

# Difference of means; note that the first list must be the concatenation of

set count [tcl::mathfunc::double $count]

list [expr {$overcount / $count}] [expr {$undercount / $count}]

Demonstration code:

set controlGroup {0.68 0.41 0.10 0.49 0.16 0.65 0.32 0.92 0.28 0.98}

lassign [permutationTest $treatmentGroup $controlGroup] over under

{{out}}

<pre>under=86.90%, over=13.10%</pre>

 

=={{header|Ursala}}==

#import nat

#import flo

#show+

 

{{out}}

<pre>

12.80%

87.20%</pre>

 

=={{header|zkl}}==

A solution that is not going to scale gracefully at all.

{{trans|D}}

ab := a.extend(b);

tObs := a.sum(0);

controlGroup := T(68, 41, 10, 49, 16, 65, 32, 92, 28, 98);

under := permutationTest(treatmentGroup, controlGroup);

{{out}}

<pre>