Permutation test: Difference between revisions

{{trans|Kotlin}}

 

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

 

 

print(‘<= : #.6% #.’.format(100 * le / total, le))

 

{{out}}

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

 

=={{header|AWK}}==

# syntax: GAWK -f PERMUTATION_TEST.AWK

# converted from C

return pick(at-1,remain-1,accu+data[at-1],treat) + ( (at > remain) ? pick(at-1,remain,accu,treat) : 0 )

}

{{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|C sharp|C#}}==

{{trans|Java}}

using System.Collections.Generic;

 

}

}

{{out}}

<pre>&lt;= 87.1971681569205% 80551

=={{header|C++}}==

This is a translaion of C

#include<vector>

#include<numeric>

std::cout << "<= : " << 100.0 * lesser / total << "% " << lesser << std::endl

<< " > : " << 100.0 * greater / total << "% " << greater << std::endl;

 

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

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

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

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

{{works with|Rakudo|2018.09}}

 

([+] @test / +@test) - ([+] flat @all, (@test X* -1)) / @all - @test

}

say 'Equal to : %', 100 * @trials[1] / [+] @trials;

say 'Greater than : %', 100 * @trials[2] / [+] @trials;

 

{{out}}

=={{header|REXX}}==

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

/* ↑ ↑ */

/* │ │ */

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

 

=={{header|Rust}}==

fn main() {

let treatment = vec![85, 88, 75, 66, 25, 29, 83, 39, 97];

combinations(total - data[0], number - 1, &tail) + combinations(total, number, &tail)

}

{{out}}

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

{{trans|C}}

{{libheader|Wren-fmt}}

 

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

var le = (total - gt).truncate

Fmt.print("<= : $f\% $d", 100 * le / total, le)

 

{{out}}

<= : 87.197168% 80551

> : 12.802832% 11827

</pre>

 

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>