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;

 

{{trans|Java}}

using System.Collections.Generic;

 

}

}

{{out}}

<pre>&lt;= 87.1971681569205% 80551

&gt; 12.8028318430795% 11827</pre>

 

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

{{trans|Kotlin}}

private static final int[] data = new int[]{

85, 88, 75, 66, 25, 29, 83, 39, 97,

System.out.printf(" > : %f%% %d\n", 100.0 * gt / total, gt);

}

{{out}}

<pre><= : 87.197168% 80551

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

 

'''Functions'''

 

meandiff(a::Vector{T}, b::Vector{T}) where T <: Real = mean(a) - mean(b)

end

return better, worse

 

'''Main'''

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

 

println("\nThere are $tot different permuted groups of these data.")

@printf("%8d, %5.2f%% showed better than actual results.\n", better, 100 * better / tot)

 

{{out}}

=={{header|Kotlin}}==

{{trans|C}}

 

val data = intArrayOf(

System.out.printf("<= : %f%% %d\n", 100.0 * le / total, le)

System.out.printf(" > : %f%% %d\n", 100.0 * gt / total, gt)

 

{{out}}

> : 12.802832% 11827

</pre>

=={{header|M2000 Interpreter}}==

{{trans|C}}

Module Checkit {

Global data(), treat=0

}

Checkit

{{out}}

<pre><= : 87.2% 80551

Slower version, using a lambda function with a series of inner lambda functions to return each combination at a time.

 

Module CheckThis {

Function CombinationsStep (a, nn) {

}

CheckThis

 

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%

=={{header|Nim}}==

{{trans|C}}

 

const data = [85, 88, 75, 66, 25,

le = int(total - float(gt))

echo fmt"<= : {100.0 * float(le) / total:.6f}% {le}"

{{out}}

<pre>

 

=={{header|Perl}}==

use warnings;

use strict;

92

28

{{out}}

equal 313 0.339%

less 80238 86.858%

greater 11827 12.803%

 

=={{header|Phix}}==

{{Trans|C}}

{{out}}

<pre>

 

=={{header|PicoLisp}}==

 

(scl 2)

 

(let N (permutationTest *TreatmentGroup *ControlGroup)

{{out}}

<pre>under = 87.85%, over = 12.15%</pre>

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

This REXX program is modeled after the &nbsp; '''C''' &nbsp; version, with some generalizations and optimization added.

/* ↑ ↑ */

/* │ │ */

data= 85 88 75 66 25 29 83 39 97 68 41 10 49 16 65 32 92 28 98

w= words(data); m= w - n /*w: volunteers + control population*/

say '# of volunteers & control population: ' w

say 'volunteer population given treatment: ' right(n, L)

else q= 0

itP= it - 1 /*set temporary var.*/

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

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

<pre>

under=87.20%, over=12.80%

</pre>

 

===Imperative version (Ugly, side effects)===

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

private val data =

Array(85, 88, 75, 66, 25, 29, 83, 39, 97, 68, 41, 10, 49, 16, 65, 32, 92, 28, 98)

println(f" > : ${100.0 * gt / total}%f%% ${gt}%d")

 

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

<= : 87.197168% 80551

=={{header|Sidef}}==

{{trans|Ruby}}

var(sumab, suma) = (ab.sum, a.sum)

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

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

var under = permutationTest(treatmentGroup, controlGroup)

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