Convertisseur d'intervalle de confiance en écarts-types

' Fonction VBA Excel pour l'Intervalle de Confiance en Écarts Types
Function ConfidenceToStdDev(CI As Double) As Double
    ConfidenceToStdDev = Application.NormSInv(1 - (1 - CI) / 2)
End Function
' Utilisation :
' =ConfidenceToStdDev(0.95)

confidence_to_std_dev <- function(confidence_interval) {
  qnorm((1 + confidence_interval) / 2)
}

# Exemple d'utilisation :
ci <- 0.95  # intervalle de confiance de 95%
z_score <- confidence_to_std_dev(ci)
cat(sprintf("%.2f%% d'intervalle de confiance correspond à %.4f écarts types\n", ci*100, z_score))

function z = confidenceToStdDev(confidenceInterval)
    z = norminv((1 + confidenceInterval) / 2);
end

% Exemple d'utilisation :
ci = 0.95;  % intervalle de confiance de 95%
zScore = confidenceToStdDev(ci);
fprintf('%.2f%% d\'intervalle de confiance correspond à %.4f écarts types\n', ci*100, zScore);

import scipy.stats as stats

def confidence_to_std_dev(confidence_interval):
    return stats.norm.ppf((1 + confidence_interval) / 2)

# Exemple d'utilisation :
ci = 0.95  # intervalle de confiance de 95%
z_score = confidence_to_std_dev(ci)
print(f"{ci*100}% d'intervalle de confiance correspond à {z_score:.4f} écarts types")

function confidenceToStdDev(confidenceInterval) {
  // Utilisation d'une approximation pour la fonction inverse d'erreur
  function erfInv(x) {
    const a = 0.147;
    const y = Math.log(1 - x*x);
    const z = 2/(Math.PI * a) + y/2;
    return Math.sign(x) * Math.sqrt(Math.sqrt(z*z - y/a) - z);
  }
  
  return Math.sqrt(2) * erfInv(confidenceInterval);
}

// Exemple d'utilisation :
const ci = 0.95;
const zScore = confidenceToStdDev(ci);
console.log(`${ci*100}% d'intervalle de confiance correspond à ${zScore.toFixed(4)} écarts types`);

public class ConfidenceIntervalConverter {
    public static double confidenceToStdDev(double confidenceInterval) {
        // Utilisation de l'algorithme de Moro pour l'approximation de la CDF normale inverse
        double p = (1 + confidenceInterval) / 2;
        double t = Math.sqrt(-2 * Math.log(1 - p));
        double c0 = 2.515517;
        double c1 = 0.802853;
        double c2 = 0.010328;
        double d1 = 1.432788;
        double d2 = 0.189269;
        double d3 = 0.001308;
        
        return t - ((c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t));
    }

    public static void main(String[] args) {
        double ci = 0.95;
        double zScore = confidenceToStdDev(ci);
        System.out.printf("%.2f%% d'intervalle de confiance correspond à %.4f écarts types%n", ci*100, zScore);
    }
}

#include <iostream>
#include <cmath>

double confidenceToStdDev(double confidenceInterval) {
    // Utilisation de l'algorithme de Moro pour l'approximation de la CDF normale inverse
    double p = (1 + confidenceInterval) / 2;
    double t = std::sqrt(-2 * std::log(1 - p));
    double c0 = 2.515517, c1 = 0.802853, c2 = 0.010328;
    double d1 = 1.432788, d2 = 0.189269, d3 = 0.001308;
    
    return t - ((c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t));
}

int main() {
    double ci = 0.95;
    double zScore = confidenceToStdDev(ci);
    printf("%.2f%% d'intervalle de confiance correspond à %.4f écarts types\n", ci*100, zScore);
    return 0;
}

def confidence_to_std_dev(confidence_interval)
  # Utilisation d'une approximation pour la fonction inverse d'erreur
  p = (1 + confidence_interval) / 2
  t = Math.sqrt(-2 * Math.log(1 - p))
  c0, c1, c2 = 2.515517, 0.802853, 0.010328
  d1, d2, d3 = 1.432788, 0.189269, 0.001308
  
  t - ((c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t))
end

# Exemple d'utilisation :
ci = 0.95
z_score = confidence_to_std_dev(ci)
puts "#{ci*100}% d'intervalle de confiance correspond à #{z_score.round(4)} écarts types"

<?php
function confidenceToStdDev($confidenceInterval) {
    // Utilisation d'une approximation pour la fonction inverse d'erreur
    $p = (1 + $confidenceInterval) / 2;
    $t = sqrt(-2 * log(1 - $p));
    $c0 = 2.515517; $c1 = 0.802853; $c2 = 0.010328;
    $d1 = 1.432788; $d2 = 0.189269; $d3 = 0.001308;
    
    return $t - (($c0 + $c1 * $t + $c2 * $t * $t) / (1 + $d1 * $t + $d2 * $t * $t + $d3 * $t * $t * $t));
}

// Exemple d'utilisation :
$ci = 0.95;
$zScore = confidenceToStdDev($ci);
printf("%.2f%% d'intervalle de confiance correspond à %.4f écarts types\n", $ci*100, $zScore);
?>

fn confidence_to_std_dev(confidence_interval: f64) -> f64 {
    // Utilisation d'une approximation pour la fonction inverse d'erreur
    let p = (1.0 + confidence_interval) / 2.0;
    let t = (-2.0 * (1.0 - p).ln()).sqrt();
    let c0 = 2.515517;
    let c1 = 0.802853;
    let c2 = 0.010328;
    let d1 = 1.432788;
    let d2 = 0.189269;
    let d3 = 0.001308;
    
    t - ((c0 + c1 * t + c2 * t * t) / (1.0 + d1 * t + d2 * t * t + d3 * t * t * t))
}

fn main() {
    let ci = 0.95;
    let z_score = confidence_to_std_dev(ci);
    println!("{:.2}% d'intervalle de confiance correspond à {:.4} écarts types", ci*100.0, z_score);
}

using System;

class ConfidenceIntervalConverter
{
    static double ConfidenceToStdDev(double confidenceInterval)
    {
        // Utilisation d'une approximation pour la fonction inverse d'erreur
        double p = (1 + confidenceInterval) / 2;
        double t = Math.Sqrt(-2 * Math.Log(1 - p));
        double c0 = 2.515517, c1 = 0.802853, c2 = 0.010328;
        double d1 = 1.432788, d2 = 0.189269, d3 = 0.001308;
        
        return t - ((c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t));
    }

    static void Main()
    {
        double ci = 0.95;
        double zScore = ConfidenceToStdDev(ci);
        Console.WriteLine($"{ci*100:F2}% d'intervalle de confiance correspond à {zScore:F4} écarts types");
    }
}

package main

import (
    "fmt"
    "math"
)

func confidenceToStdDev(confidenceInterval float64) float64 {
    // Utilisation d'une approximation pour la fonction inverse d'erreur
    p := (1 + confidenceInterval) / 2
    t := math.Sqrt(-2 * math.Log(1 - p))
    c0, c1, c2 := 2.515517, 0.802853, 0.010328
    d1, d2, d3 := 1.432788, 0.189269, 0.001308
    
    return t - ((c0 + c1*t + c2*t*t) / (1 + d1*t + d2*t*t + d3*t*t*t))
}

func main() {
    ci := 0.95
    zScore := confidenceToStdDev(ci)
    fmt.Printf("%.2f%% d'intervalle de confiance correspond à %.4f écarts types\n", ci*100, zScore)
}

import Foundation

func confidenceToStdDev(_ confidenceInterval: Double) -> Double {
    // Utilisation d'une approximation pour la fonction inverse d'erreur
    let p = (1 + confidenceInterval) / 2
    let t = sqrt(-2 * log(1 - p))
    let c0 = 2.515517, c1 = 0.802853, c2 = 0.010328
    let d1 = 1.432788, d2 = 0.189269, d3 = 0.001308
    
    return t - ((c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t))
}

// Exemple d'utilisation :
let ci = 0.95
let zScore = confidenceToStdDev(ci)
print(String(format: "%.2f%% d'intervalle de confiance correspond à %.4f écarts types", ci*100, zScore))

import unittest
import math

def confidence_to_std_dev(confidence_interval):
    return stats.norm.ppf((1 + confidence_interval) / 2)

class TestConfidenceToStdDev(unittest.TestCase):
    def test_common_confidence_intervals(self):
        self.assertAlmostEqual(confidence_to_std_dev(0.6827), 1.0, places=4)
        self.assertAlmostEqual(confidence_to_std_dev(0.95), 1.96, places=2)
        self.assertAlmostEqual(confidence_to_std_dev(0.99), 2.576, places=3)
        self.assertAlmostEqual(confidence_to_std_dev(0.9973), 3.0, places=4)

    def test_edge_cases(self):
        self.assertAlmostEqual(confidence_to_std_dev(0.5), 0.6745, places=4)
        self.assertTrue(math.isinf(confidence_to_std_dev(1.0)))
        self.assertEqual(confidence_to_std_dev(0.0), -float('inf'))

if __name__ == '__main__':
    unittest.main()