1confidence_to_std_dev <- function(confidence_interval) {
2  qnorm((1 + confidence_interval) / 2)
3}
4
5# การใช้งานตัวอย่าง:
6ci <- 0.95  # ช่วงความเชื่อมั่น 95%
7z_score <- confidence_to_std_dev(ci)
8cat(sprintf("%.2f%% ช่วงความเชื่อมั่นตรงกับ %.4f ส่วนเบี่ยงเบนมาตรฐาน\n", ci*100, z_score))
9

1function z = confidenceToStdDev(confidenceInterval)
2    z = norminv((1 + confidenceInterval) / 2);
3end
4
5% การใช้งานตัวอย่าง:
6ci = 0.95;  % ช่วงความเชื่อมั่น 95%
7zScore = confidenceToStdDev(ci);
8fprintf('%.2f%% ช่วงความเชื่อมั่นตรงกับ %.4f ส่วนเบี่ยงเบนมาตรฐาน\n', ci*100, zScore);
9

1import scipy.stats as stats
2
3def confidence_to_std_dev(confidence_interval):
4    return stats.norm.ppf((1 + confidence_interval) / 2)
5
6# การใช้งานตัวอย่าง:
7ci = 0.95  # ช่วงความเชื่อมั่น 95%
8z_score = confidence_to_std_dev(ci)
9print(f"{ci*100}% ช่วงความเชื่อมั่นตรงกับ {z_score:.4f} ส่วนเบี่ยงเบนมาตรฐาน")
10

1function confidenceToStdDev(confidenceInterval) {
2  // ใช้การประมาณสำหรับฟังก์ชันย้อนกลับของข้อผิดพลาด
3  function erfInv(x) {
4    const a = 0.147;
5    const y = Math.log(1 - x*x);
6    const z = 2/(Math.PI * a) + y/2;
7    return Math.sign(x) * Math.sqrt(Math.sqrt(z*z - y/a) - z);
8  }
9  
10  return Math.sqrt(2) * erfInv(confidenceInterval);
11}
12
13// การใช้งานตัวอย่าง:
14const ci = 0.95;
15const zScore = confidenceToStdDev(ci);
16console.log(`${ci*100}% ช่วงความเชื่อมั่นตรงกับ ${zScore.toFixed(4)} ส่วนเบี่ยงเบนมาตรฐาน`);
17

1public class ConfidenceIntervalConverter {
2    public static double confidenceToStdDev(double confidenceInterval) {
3        // ใช้อัลกอริธึมของมอโรสำหรับการประมาณ CDF ปกติย้อนกลับ
4        double p = (1 + confidenceInterval) / 2;
5        double t = Math.sqrt(-2 * Math.log(1 - p));
6        double c0 = 2.515517;
7        double c1 = 0.802853;
8        double c2 = 0.010328;
9        double d1 = 1.432788;
10        double d2 = 0.189269;
11        double d3 = 0.001308;
12        
13        return t - ((c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t));
14    }
15
16    public static void main(String[] args) {
17        double ci = 0.95;
18        double zScore = confidenceToStdDev(ci);
19        System.out.printf('%.2f%% ช่วงความเชื่อมั่นตรงกับ %.4f ส่วนเบี่ยงเบนมาตรฐาน%n', ci*100, zScore);
20    }
21}
22

1#include <iostream>
2#include <cmath>
3
4double confidenceToStdDev(double confidenceInterval) {
5    // ใช้อัลกอริธึมของมอโรสำหรับการประมาณ CDF ปกติย้อนกลับ
6    double p = (1 + confidenceInterval) / 2;
7    double t = std::sqrt(-2 * std::log(1 - p));
8    double c0 = 2.515517, c1 = 0.802853, c2 = 0.010328;
9    double d1 = 1.432788, d2 = 0.189269, d3 = 0.001308;
10    
11    return t - ((c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t));
12}
13
14int main() {
15    double ci = 0.95;
16    double zScore = confidenceToStdDev(ci);
17    printf('%.2f%% ช่วงความเชื่อมั่นตรงกับ %.4f ส่วนเบี่ยงเบนมาตรฐาน\n', ci*100, zScore);
18    return 0;
19}
20

1def confidence_to_std_dev(confidence_interval)
2  # ใช้การประมาณสำหรับฟังก์ชันย้อนกลับของข้อผิดพลาด
3  p = (1 + confidence_interval) / 2
4  t = Math.sqrt(-2 * Math.log(1 - p))
5  c0, c1, c2 = 2.515517, 0.802853, 0.010328
6  d1, d2, d3 = 1.432788, 0.189269, 0.001308
7  
8  t - ((c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t))
9end
10
11# การใช้งานตัวอย่าง:
12ci = 0.95
13z_score = confidence_to_std_dev(ci)
14puts "#{ci*100}% ช่วงความเชื่อมั่นตรงกับ #{z_score.round(4)} ส่วนเบี่ยงเบนมาตรฐาน"
15

1<?php
2function confidenceToStdDev($confidenceInterval) {
3    // ใช้การประมาณสำหรับฟังก์ชันย้อนกลับของข้อผิดพลาด
4    $p = (1 + $confidenceInterval) / 2;
5    $t = sqrt(-2 * log(1 - $p));
6    $c0 = 2.515517; $c1 = 0.802853; $c2 = 0.010328;
7    $d1 = 1.432788; $d2 = 0.189269; $d3 = 0.001308;
8    
9    return $t - (($c0 + $c1 * $t + $c2 * $t * $t) / (1 + $d1 * $t + $d2 * $t * $t + $d3 * $t * $t * $t));
10}
11
12// การใช้งานตัวอย่าง:
13$ci = 0.95;
14$zScore = confidenceToStdDev($ci);
15printf('%.2f%% ช่วงความเชื่อมั่นตรงกับ %.4f ส่วนเบี่ยงเบนมาตรฐาน\n', $ci*100, $zScore);
16?>
17

1fn confidence_to_std_dev(confidence_interval: f64) -> f64 {
2    // ใช้การประมาณสำหรับฟังก์ชันย้อนกลับของข้อผิดพลาด
3    let p = (1.0 + confidence_interval) / 2.0;
4    let t = (-2.0 * (1.0 - p).ln()).sqrt();
5    let c0 = 2.515517;
6    let c1 = 0.802853;
7    let c2 = 0.010328;
8    let d1 = 1.432788;
9    let d2 = 0.189269;
10    let d3 = 0.001308;
11    
12    t - ((c0 + c1 * t + c2 * t * t) / (1.0 + d1 * t + d2 * t * t + d3 * t * t * t))
13}
14
15fn main() {
16    let ci = 0.95;
17    let z_score = confidence_to_std_dev(ci);
18    println!("{:.2}% ช่วงความเชื่อมั่นตรงกับ {:.4} ส่วนเบี่ยงเบนมาตรฐาน", ci*100.0, z_score);
19}
20

1using System;
2
3class ConfidenceIntervalConverter
4{
5    static double ConfidenceToStdDev(double confidenceInterval)
6    {
7        // ใช้การประมาณสำหรับฟังก์ชันย้อนกลับของข้อผิดพลาด
8        double p = (1 + confidenceInterval) / 2;
9        double t = Math.Sqrt(-2 * Math.Log(1 - p));
10        double c0 = 2.515517, c1 = 0.802853, c2 = 0.010328;
11        double d1 = 1.432788, d2 = 0.189269, d3 = 0.001308;
12        
13        return t - ((c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t));
14    }
15
16    static void Main()
17    {
18        double ci = 0.95;
19        double zScore = ConfidenceToStdDev(ci);
20        Console.WriteLine($"{ci*100:F2}% ช่วงความเชื่อมั่นตรงกับ {zScore:F4} ส่วนเบี่ยงเบนมาตรฐาน");
21    }
22}
23

1package main
2
3import (
4    "fmt"
5    "math"
6)
7
8func confidenceToStdDev(confidenceInterval float64) float64 {
9    // ใช้การประมาณสำหรับฟังก์ชันย้อนกลับของข้อผิดพลาด
10    p := (1 + confidenceInterval) / 2
11    t := math.Sqrt(-2 * math.Log(1 - p))
12    c0, c1, c2 := 2.515517, 0.802853, 0.010328
13    d1, d2, d3 := 1.432788, 0.189269, 0.001308
14    
15    return t - ((c0 + c1*t + c2*t*t) / (1 + d1*t + d2*t*t + d3*t*t*t))
16}
17
18func main() {
19    ci := 0.95
20    zScore := confidenceToStdDev(ci)
21    fmt.Printf("%.2f%% ช่วงความเชื่อมั่นตรงกับ %.4f ส่วนเบี่ยงเบนมาตรฐาน\n", ci*100, zScore)
22}
23

1import Foundation
2
3func confidenceToStdDev(_ confidenceInterval: Double) -> Double {
4    // ใช้การประมาณสำหรับฟังก์ชันย้อนกลับของข้อผิดพลาด
5    let p = (1 + confidenceInterval) / 2
6    let t = sqrt(-2 * log(1 - p))
7    let c0 = 2.515517, c1 = 0.802853, c2 = 0.010328
8    let d1 = 1.432788, d2 = 0.189269, d3 = 0.001308
9    
10    return t - ((c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t))
11}
12
13// การใช้งานตัวอย่าง:
14let ci = 0.95
15let zScore = confidenceToStdDev(ci)
16print(String(format: "%.2f%% ช่วงความเชื่อมั่นตรงกับ %.4f ส่วนเบี่ยงเบนมาตรฐาน", ci*100, zScore))
17