J'ai essayé de programmer le test du chi carré en Python et Java.

Test du chi carré souvent utilisé dans les statistiques. Il s'agit d'une hypothèse nulle pour vérifier si les groupes d'échantillons sont liés les uns aux autres. J'ai pensé que ce serait amusant si je pouvais programmer cela. Reportez-vous à ce qui suit pour la méthode de calcul du test du chi carré.

http://kogolab.chillout.jp/elearn/hamburger/chap3/sec0.html

D'abord de Python

code

kai.py

import numpy as np


def chi_squared(array):
    #Obtenez la valeur totale verticale et horizontale
    low_sums = np.array(array).sum(axis=1)
    col_sums = np.array(array).sum(axis=0)
    #Obtenez le grand total
    the_total = sum(low_sums)
    #Obtenez la fréquence attendue
    ex_freq = []
    for i in low_sums:
        for j in col_sums:
            ex_freq.append(i * j/the_total)
    pass
    ex_freq = np.array(np.array_split(ex_freq, len(array)))
    diff = np.array(array) - ex_freq
    #Pour prendre en charge plusieurs lignes et colonnes
    ex_freq_flt = ex_freq.flatten()
    diff_flt = diff.flatten()
    return sum(diff_flt ** 2 / ex_freq_flt)


pass


def d_f(array):
    s = list(np.array(array).shape)
    d = 1
    for i in s:
        d *= (i - 1)
    return d


waku_mogu = [[435, 165],
             [265, 135]]

print("Le chi carré est", chi_squared(waku_mogu))
print("Le degré de liberté", d_f(waku_mogu))

"""
Résultat d'exécution
Kai au carré est 4.464285714285714
Le degré de liberté est 1

"""

La somme des colonnes, Numpy, peut être effectuée en une seule fois. c'est bien.

Ensuite, un programme qui se comporte de la même manière en Java

code

Kai.java

import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;

public class Kai {
    public static void main(String[] args) {

        Calc c = new Calc();
        double[][] waku_mogu = {{435, 165}, {265, 135}};
        System.out.println("Le chi carré est" + c.chi_squared(waku_mogu));
        System.out.println("Le degré de liberté" + c.d_f(waku_mogu));
    }
}


class Calc {


    public double chi_squared(double[][] arr) {
        List<Double> low_sums = new ArrayList<>();
        List<Double> col_sums = new ArrayList<>();
        List<Double> ex_freq = new ArrayList<>();
        List<Double> diff = new ArrayList<>();

        //Trouvez la valeur totale de chaque ligne.
        for (int i = 0; i < arr.length; i++) {
            double total_l = 0;
            for (int j = 0; j < arr[i].length; j++) {
                total_l += arr[i][j];
            }
            low_sums.add(total_l);
        }

        //Trouvez la valeur totale de chaque colonne. C'était le point le plus difficile...Numpy est une ligne
        for (int j = 0; j < arr[0].length; j++) {
            double total_c = 0;
            for (int i = 0; i < arr.length; i++) {
                total_c += arr[i][j];
            }
            col_sums.add(total_c);
        }

        double the_total = 0;
        Iterator<Double> iterator = low_sums.iterator();
        while (iterator.hasNext()) {
            double i = iterator.next();
            the_total += i;
        }

        iterator = low_sums.iterator();
        while (iterator.hasNext()) {
            double i = iterator.next();
            Iterator<Double> iterator2 = col_sums.iterator();
            while (iterator2.hasNext()) {
                double j = iterator2.next();
                ex_freq.add(i * j / the_total);
            }
        }

//Le deuxième point le plus difficile pour pouvoir gérer plusieurs lignes et colonnes
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                diff.add(arr[i][j] - ex_freq.get(count));
                count++;
            }
        }

        double chi_val = 0;
        for (int i = 0; i < ex_freq.size(); i++) {
            chi_val += Math.pow(diff.get(i), 2) / ex_freq.get(i);
        }
        return chi_val;
    }

    public int d_f(double[][] arr) {
        return (arr.length - 1) * (arr[0].length - 1);
    }
}


/*
Résultat d'exécution

Kai au carré est 4.464285714285714
Le degré de liberté est 1

 */

J'ai eu beaucoup de mal à obtenir la somme des lignes.

Bien sûr, je ne suis pas doué pour cela, mais Python est beaucoup plus propre à écrire. Mais j'aime aussi le sentiment que Java est en cours d'assemblage tout en vérifiant la sécurité par moi-même.