Ich habe versucht, den Chi-Quadrat-Test in Python und Java zu programmieren.

Chi-Quadrat-Test häufig in der Statistik verwendet. Dies ist eine Nullhypothese, um zu überprüfen, ob die Stichprobengruppen miteinander verwandt sind. Ich dachte, es würde Spaß machen, wenn ich das programmieren könnte. Die Berechnungsmethode für den Chi-Quadrat-Test finden Sie im Folgenden.

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

Zuerst von Python

Code

kai.py

import numpy as np


def chi_squared(array):
    #Erhalten Sie den vertikalen und horizontalen Gesamtwert
    low_sums = np.array(array).sum(axis=1)
    col_sums = np.array(array).sum(axis=0)
    #Holen Sie sich die Gesamtsumme
    the_total = sum(low_sums)
    #Holen Sie sich die erwartete Frequenz
    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
    #Unterstützung mehrerer Zeilen und Spalten
    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("Chi Quadrat ist", chi_squared(waku_mogu))
print("Der Freiheitsgrad", d_f(waku_mogu))

"""
Ausführungsergebnis
Kai im Quadrat ist 4.464285714285714
Der Freiheitsgrad ist 1

"""

Die Summe der Spalten, Numpy, kann auf einmal erstellt werden. Es ist großartig.

Als nächstes ein Programm, das sich in Java gleich verhält

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("Chi Quadrat ist" + c.chi_squared(waku_mogu));
        System.out.println("Der Freiheitsgrad" + 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<>();

        //Finden Sie den Gesamtwert für jede Zeile.
        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);
        }

        //Finden Sie den Gesamtwert für jede Spalte. Dies war der schwierigste Punkt...Numpy ist eine Zeile
        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);
            }
        }

//Der zweitschwerste Punkt, um mehrere Zeilen und Spalten verarbeiten zu können
        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);
    }
}


/*
Ausführungsergebnis

Kai im Quadrat ist 4.464285714285714
Der Freiheitsgrad ist 1

 */

Ich hatte große Probleme, die Summe der Zeilen zu ermitteln.

Natürlich bin ich nicht gut darin, aber Python ist viel sauberer zu schreiben. Ich mag aber auch das Gefühl, dass Java zusammengebaut wird, während ich die Sicherheit selbst überprüfe.