Calculer l'intervalle de score de Wilson

15

L' intervalle de score de Wilson est un intervalle de confiance de la probabilité de succès, basé sur la proportion de succès dans un ensemble d'essais de Bernoulli (un essai de Bernoulli est un essai dans lequel exactement deux résultats sont possibles: succès ou échec ). L'intervalle est donné par la formule suivante:

Intervalle de Wilson

Les deux valeurs données par la formule sont les limites supérieure et inférieure de l'intervalle. n S et n F sont le nombre de succès et d'échecs, respectivement, et n est le nombre total d'essais (équivalent à n S + n F ). z est un paramètre dépendant du niveau de confiance souhaité. Aux fins de ce défi, z = 1,96 sera utilisé (correspondant à un intervalle de confiance à 95%) 1 .

Étant donné les entiers non négatifs n S et n F , affichez les limites de l'intervalle de score de Wilson.

Règles

  • Les sorties doivent être aussi précises que possible par rapport aux vraies valeurs, dans les limites de l'implémentation en virgule flottante de votre langue, en ignorant les problèmes potentiels dus aux inexactitudes arithmétiques en virgule flottante. Si votre langage est capable d'arithmétique à précision arbitraire, il doit être au moins aussi précis que l'arithmétique à double précision IEEE 754.
  • Les entrées seront dans la plage représentable pour le type entier natif de votre langue, et les sorties seront dans la plage représentable pour le type natif à virgule flottante de votre langue.
  • n sera toujours positif.
  • L'ordre des sorties n'a pas d'importance.

Cas de test

Format: n_s, n_f => lower, upper

0, 1 => 0.0, 0.7934567085261071
1, 0 => 0.20654329147389294, 1.0
1, 1 => 0.09452865480086611, 0.905471345199134
1, 10 => 0.016231752262825982, 0.3773646254862038
10, 1 => 0.6226353745137962, 0.9837682477371741
10, 90 => 0.05522854161313612, 0.1743673043676654
90, 10 => 0.8256326956323345, 0.9447714583868639
25, 75 => 0.17545094003724265, 0.3430464637007583
75, 25 => 0.6569535362992417, 0.8245490599627573
50, 50 => 0.40382982859014716, 0.5961701714098528
0, 100 => 0.0, 0.03699480747600191
100, 0 => 0.9630051925239981, 1.0

  1. La zvaleur est le 1-α/2e quantile de la distribution normale standard, où αest le niveau de signification. Si vous voulez un intervalle de confiance à 95%, votre niveau de signification est α=0.05et la zvaleur est 1.96.
Mego
la source
Connexes: le pistolet le plus rapide de l'Ouest . J'allais en faire un défi, mais je suppose que tu m'as battu. : /
mbomb007

Réponses:

6

Mathematica, 48 octets (encodage UTF-8)

({-1,1}√((s=1.4^4)##/+##+s^2/4)+#+s/2)/(s+##)&

Fonction sans nom prenant deux arguments dans l'ordre n_s, n_fet renvoyant une paire ordonnée de nombres réels. Le symbole à trois octets , représentant la fonction racine carrée, est U-221A.

Utilise le fait que précéder ##d'un nombre donne le produit des deux arguments, tandis que +##leur somme. Utilise également le fait que les produits et les sommes passent automatiquement sur les listes, ce qui {-1,1}√(...)implémente le ± dans la formule. La définition de la constante s = z^2au lieu de zlui - même a également permis d'économiser quelques octets. (Surtout, je suis juste fier d'économiser un octet en remarquant que 1.4^4c'est exactement 1.96^2!)

Greg Martin
la source
Mathematica peut-il utiliser des encodages arbitraires? Le symbole de racine carrée est de 1 octet dans de nombreux codages à un octet.
Mego
Il peut en effet utiliser de nombreux encodages, par exemple, Mac OS Roman, qui a la propriété que vous mentionnez. Ma compréhension, cependant, est que j'aurais besoin d'inclure les octets nécessaires pour passer à un codage non par défaut, qui dans ce cas est plus que les 2 octets "gaspillés".
Greg Martin
Oh, cela nécessite un commutateur de ligne de commande (ou un appel de fonction)? Brut.
Mego
4
Mathematica est une merveilleuse juxtaposition de génial et brut: D
Greg Martin
3

Perl 6 , 66 octets

->\s,\f,\z=1.96 {(s+(-z|z)*sqrt(s*f/(s+f)+z*z/4)+z*z/2)/(s+f+z*z)}

Cette fonction renvoie en fait une jonction or des bornes inférieure et supérieure; par exemple, s'il est appelé avec les arguments 100 et 0, il renvoie:

any(0.963005192523998, 1)

C'est un format de sortie non traditionnel pour le moins, mais aucun format particulier n'a été spécifié, et les deux valeurs requises sont présentes.

Sean
la source
Cela me semble bien. L'absence d'un format de sortie spécifique était intentionnelle - exiger un format spécifique pour la sortie donne des avantages à certaines langues et complique inutilement le défi. Tant que les deux valeurs de sortie sont présentes sous une forme utilisable, c'est acceptable.
Mego
3

05AB1E , 34 octets

"1.96"Dn©4/¹P¹O/+t*D()®;+¹0è+®¹O+/

L'entrée est de la forme La [n_s, n_f]
sortie est de la forme[upper, lower]

Essayez-le en ligne!

Explication

"1.96"                             # push 1.96
      Dn©                          # duplicate, square, store a copy in register
         4/                        # divide by 4
           ¹P¹O/                   # product of input divided by sum of input
                +                  # add this to (z^2)/4
                 t*                # sqrt and multiply with z
                   D()             # wrap in list together with a negated copy
                      ®;+          # add (z^2)/2
                         ¹0è+      # add n_s
                             ®¹O+/ # divide by z^2+n
Emigna
la source
3

Enchantements runiques , 105 octets

#StillBetterThanJava

/:2,:2,i:3s:3s:i:3s*3s+::6s4s,+'qA{*:Z4s3TRr4s{++}\
\p2:,C1Ä'<> yyyyyyyyyyyyyyyyyyy'Ä1C,2p:2,//@S ',+ /

Essayez-le en ligne!

L'entrée est de la forme La n_s n_f
sortie est de la forme lower upperet a un espace de fin

AH DIEU celui-ci est un gâchis. Voici la version non emballée:

>'Ä1C,:2p:2,:2,i:3s:3s:i:3s*3s+::6s4s,+'qA{*:Z4s3TRr4s{++}+,' S@
                  > yyyyyyyyyyyyyyyyyyy'Ä1C,2p:2,//

Tous ces ys doivent ralentir la deuxième IP afin qu'elle arrive au Tpoint de transfert au bon moment (c'est-à-dire la seconde). Cela pousse les 3 premiers éléments d'un pointeur sur l'autre (la configuration de cette action est illustrée ci-dessous). 'Ä1C,génère zen divisant le caractère 196 par 100 (dup, carré, dup, div 2, dup, div 2 ...). Tout le reste n'est qu'un tas de mathématiques et de manipulation de pile pour pousser les valeurs futures dans la pile jusqu'à ce qu'elles soient nécessaires. Pour la plupart, ils se retrouvent dans le bon ordre et c'est seulement jusqu'à ce r4s{++}que nous devions inverser la pile et faire pivoter le tout pour obtenir les valeurs que nous voulons côte à côte.

Il y a probablement matière à amélioration, mais c'est suffisamment complexe pour que je ne puisse pas le voir. Heck, avait par inadvertance lu "z" au lieu de "n" dans la formule originale à un moment donné et la fixation qui était rude.

J'ai dû retirer des fiches et simuler les piles afin de m'assurer que c'était correct:

Stack Funtimes

Chacun a une valeur aux deux extrémités en raison du nombre de variables (par exemple, j'en aurais une avec S et une avec F, je les afficherais toutes les deux, en inverser une et ajouter le S + F qui était sur l'autre extrémité en haut de la pile). Vous pouvez voir que l'une des sqrt(...)cartes a un Ssur le bord inférieur.

Draco18s ne fait plus confiance à SE
la source
3

R , 58 53 51 49 41 octets

-15 octets grâce à J.Doe. -2 octets grâce à Giuseppe.

function(x,y)prop.test(t(c(x,y)),cor=F)$c
Robert S.
la source
1
J'aime quand R est compétitif avec les langues de golf ...
J.Doe
2

APL (Dyalog Unicode) , 50 octets

{(+/⍺⍵z)÷⍨(⍺+z÷2)(-,+).5*⍨z×(⍺×⍵÷⍺+⍵)+4÷⍨z3.8416}

Essayez-le en ligne!

nsnF

Merci à H.PWiz et dzaima pour leur aide.

Comment:

                                        z3.8416   Set z=1.96²
                                     4÷⍨           Divide it by 4
                                    +              plus
                           (⍺×⍵÷⍺+⍵)              (nf×nsn
                         z×                        ×z²
                     .5*⍨                          to the power .5 (square root)
                (-,+)                              ±
         (⍺+z÷2)                                   ns+(z²/2)
(+/⍺⍵z)÷⍨                                         all divided by nf+ns+z²
J. Sallé
la source
@ Adám Ce n'est ni une expression, ni un programme complet, mais vous pouvez en faire une expression en initialisant zà son utilisation la plus à droite: ...÷z+(z←1.908)++pour le même nombre d'octets. Aussi: ⊣×⊢÷+->×÷+
ngn
1
@ngn C'est vrai, mais en fait, cela est permis par un double méta consensus: (1) et (2) .
Adám
1

Python, 79 67 octets

lambda s,f,z=3.8416:2j**.5*(s-(-z*(f*s/(f+s)+z/4))**.5+z/2)/(f+s+z)

La sortie est un entier complexe avec l'intervalle stocké en tant que partie réelle / imaginaire.

orlp
la source
1

dc , 71 octets

16k?dsa2*?sb1.96 2^dso+dlalb4**lalb+/lo+vlov*dsd+lalblo++2*dsx/rld-lx/f

Prend les deux entrées sur deux lignes distinctes lors de l'invocation et les sorties sur deux lignes distinctes avec la limite supérieure en bas et la limite inférieure en haut .

Par exemple:

bash-4.4$ dc -e '16k?dsa2*?sb1.96 2^dso+dlalb4**lalb+/lo+vlov*dsd+lalblo++2*dsx/rld-lx/f'
10                # Input n_s
90                # Input n_f
.0552285416131361 # Output lower bound
.1743673043676654 # Output upper bound
R. Kap
la source
1

Raquette 134 octets

(let*((n(+ s f))(z 1.96)(h(* z z))(p(/ 1(+ n h)))(q(+ s(/ h 2)))(r(* z(sqrt(+(/(* s f) n)(/ h 4))))))(values(* p(- q r))(* p(+ q r))))

Non golfé:

(define (g s f)
  (let* ((n (+ s f))
         (z 1.96)
         (zq (* z z))
         (p (/ 1 (+ n zq)))
         (q (+ s (/ zq 2)))
         (r (* z (sqrt (+ (/(* s f) n) (/ zq 4))))))
    (values (* p (- q r)) (* p (+ q r)))))

Essai:

(g 1 10)

Production:

0.016231752262825982
0.3773646254862038
rnso
la source
1

Java 7, 130 octets

Golfé:

double[]w(int s,int f){double n=s+f,z=1.96,x=z*z,p=s+x/2,d=z*Math.sqrt(s*f/n+x/4),m=1/(n+x);return new double[]{m*(p-d),m*(p+d)};}

Non golfé:

double[] w(int s, int f)
{
    double n = s + f, z = 1.96, x = z * z, p = s + x / 2, d = z * Math.sqrt(s * f / n + x / 4), m = 1 / (n + x);
    return new double[]
    { m * (p - d), m * (p + d) };
}

Essayez-le en ligne

Retourne un tableau de type double de longueur 2, peut probablement être joué plus.

peech
la source
1

> <> avec -vindicateur, 100 octets

:{:@:}*@+:@,24a,a,-:@:*:&4,+:\$~*{&:&2,+}:{:@@-{&+:&,nao+&,n;
,}:{::*@@-:0$0(?$-1a,:*:*:*(?\}:{:@,+2

Attend que l'entrée soit présente sur la pile au début de l'exécution, dans l'ordre n_s, n_f. Essayez-le en ligne!

Quelle langue stupide pour tenter cela dans ...

Comme> <> n'a pas d'exposant ou d'opérateur racine, la racine carrée est calculée dans la deuxième ligne de code en utilisant la méthode babylonienne , avec une précision de 1e-8- pour chaque exemple que j'ai essayé, elle est précise à au moins 10 décimales. Si ce n'est pas assez précis, les limites peuvent être resserrées en ajoutant plus :*dans la deuxième ligne, en mélangeant les choses pour garder les miroirs en ligne.

La sortie se présente sous la forme suivante:

<lower bound>
<upper bound>
Sok
la source
1

Pyth, 38 octets

J*K1.96Kmc++dhQcJ2+sQJ_B*K@+cJ4c*FQsQ2

L' entrée est sous forme de liste de valeurs [n_s, n_f]. La sortie est [upper, lower]Essayez-le en ligne ici , ou vérifiez tous les cas de test à la fois ici .

J*K1.96Kmc++dhQcJ2+sQJ_B*K@+cJ4c*FQsQ2   Implicit: Q=eval(input())

  K1.96                                  Set variable K=1.96 (z)
J*K    K                                 Set variable J=K*K (z^2)
                                *FQ      Product of input pair
                               c   sQ    Divide the above by the sum of the input pair
                            cJ4          J / 4
                           +             Add the two previous results
                          @          2   Take the square root of the above
                        *K               Multiply by K
                      _B                 Pair the above with itself, negated
        m                                Map each in the above, as d, using:
             hQ                            First value of input (i.e. n_s)
               cJ2                         J / 2
          ++d                              Sum the above two with d
         c                                 Divided by...
                  +sQJ                     ... (J + sum of input)
Sok
la source
1

Gelée , 30 octets

×÷++1.96²©HH¤×®½×Ø-+®H¤+³÷++®ɗ

Essayez-le en ligne!

Explication

                   Inputs: s and f
×÷+                (s×f)÷(s+f)
    1.96²©HH¤      (© ← 1.96²)÷4      (call this W)

   +                         (s×f)÷(s+f)+W
             ×®             ((s×f)÷(s+f)+W)ש
               ½      sqrt[ ((s×f)÷(s+f)+W)ש ]   (call this R)

                ×Ø-            [   -R,      +R  ]
                   +®H¤        [©/2-R,   ©/2+R  ]
                       +³      [©/2-R+s, ©/2+R+s]

                         ÷           Divide both by:
                          ++®ɗ       (s+f)+©

Remarque

Certaines de ces fonctionnalités sont plus récentes que le défi. Je crois qu'à l'époque où ce défi a été publié, ++®¶×÷++1.96²©HH¤×®½×-,1+®H¤+³÷çétait une gelée valide (32 octets), manquante ɗet Ø-.

Lynn
la source
1

APL (NARS), 49 caractères, 98 octets

{k←1.9208⋄(2+n÷k)÷⍨(1+⍺÷k)+¯1 1×√1+2×⍺×⍵÷k×n←⍺+⍵}

tester

  f←{k←1.9208⋄(2+n÷k)÷⍨(1+⍺÷k)+¯1 1×√1+2×⍺×⍵÷k×n←⍺+⍵}
  25 f 75
0.17545094 0.3430464637 
  0 f 1
0 0.7934567085 
  1 f 0
0.2065432915 1 
RosLuP
la source