dhondt.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
import datetime
import numpy as np

#Anzahl der Möglichkeiten berechnen:
#https://de.numberempire.com/combinatorialcalculator.php
#(n + m - 1)! / ((n - 1)! * m!) = 4183713304

# Anzahl der Fälle einer prozentuellen Abweichung
anzahl_abrundungen = [0,0,0,0]
anzahl_gleich = [0,0,0,0]
anzahl_aufrundungen = [0,0,0,0]

# Diese Summen werden am Ende durch die Anzahl der Fälle (oben) dividiert um einen Mittelwert der prozentuellen Abweichung zu bestimmen.
summe_prozent_dazu = [0,0,0,0]
summe_prozent_weg = [0,0,0,0]

# Es wird erfasst, wie oft pro Partei die Anzahl der Mandate gleich bleibt bzw. 
# sich gegenüber einer prozentuellen Verteilung um wie viele Mandate nach oben 
# oder unten verschiebt.
# Die Anzahl der Ereignisse wird für jeweilige Größe eines Mandatssprungs 
# separat gespeichert.
# [0][1,12,3,2] heißt also: Partei mit Ordnungszahl 0 (die Mehrheitspartei) hat 
# 1 Mal exakt so viele Mandate nach d'Hondt erhalten, wie die Prozentrechnung 
# auch ergeben hätte, 12 Mal hat sie ein Mandat mehr erhalten, 3 Mal zwei 
# Mandate mehr und 2 Mal 3 Mandate mehr.
partei_mandate_dazu = [
[0,0,0,0,0,0],
[0,0,0,0,0,0],
[0,0,0,0,0,0],
[0,0,0,0,0,0]
]
partei_mandate_weg = [
[0,0,0,0,0,0],
[0,0,0,0,0,0],
[0,0,0,0,0,0],
[0,0,0,0,0,0]
]


# Wie hoch ist im Schnitt die Mandatsverschiebung, wenn es zu einer Verschiebung kommt (nur in diesen Fällen).
summe_prozent_dazu_bei_mandatsverschiebung = [0,0,0,0]
summe_prozent_weg_bei_mandatsverschiebung = [0,0,0,0]
summe_varianz_bei_mandatsgleichheit = [0,0,0,0]


anzahl_mandat_dazu = [0,0,0,0]
anzahl_mandat_gleich = [0,0,0,0]
anzahl_mandat_weg = [0,0,0,0]

varianten_gesamt = 0
varianten_mehrheitspartei = 0
subcount = 0

zu_vergebende_mandate = 5
anzahl_parteien = 4
#gueltige_stimmen = 2926
gueltige_stimmen = 50
varianten_gesamt = 0

def takeFraction(elem):
  return elem[1]

def MandateNachDHondt(partei_summen, zu_vergebende_mandate):
    anzahl_parteien = len(partei_summen)
    parteien_bruchzahlen = []
    anzahl_mandate_pro_partei_nach_d_hondt = []
    for partei in range(0, anzahl_parteien):
        anzahl_mandate_pro_partei_nach_d_hondt.append(0)
        for divisor in range(1,zu_vergebende_mandate + 1):
            # Brüche an Liste der Bruchzahlen anfügen
            parteien_bruchzahlen.extend([[partei, float(partei_summen[partei])/divisor]])

    # Sortieren der parteien_bruchzahlen
    parteien_bruchzahlen.sort(key=takeFraction,reverse=True)
    
    # Reduzieren der Liste auf Anzahl der zu vergebenen Mandate
    # Wenn zwei Parteien dieselben Bruchzahlen haben, müsste verlost werden.
    # Für die statistische Auseinandersetzung stellen wir auf den Anspruch auf
    # einen Sitz ab, nicht auf das zugesprochene Mandat. Deshalb müssen alle 
    # Parteien, die einen Anspruch haben (ergo die selbe Bruchzahl) registriert 
    # werden.
    
    for mandat in parteien_bruchzahlen:
        if mandat[1] >= parteien_bruchzahlen[zu_vergebende_mandate - 1][1]:
            anzahl_mandate_pro_partei_nach_d_hondt[mandat[0]] += 1
        else:
            break
            
    return anzahl_mandate_pro_partei_nach_d_hondt
# Ende der Funktion

def MandateNachProzent(gueltige_stimmen, partei_summen, zu_vergebende_mandate):
    # Prozentuelle Mandatsberechnung (bei 0,5 wird aufgerundet)
    mandate_nach_prozent = []
    for stimmen in partei_summen:
        mandate = zu_vergebende_mandate / gueltige_stimmen * stimmen
        rest = mandate - int(mandate)
        if (rest >= 0.5 ):
            mandate_nach_prozent.extend([int(mandate) + 1])
        else:
            mandate_nach_prozent.extend([int(mandate)])
    return mandate_nach_prozent
# Ende der Funktion

def Prozent(ergebnisse):
    summe = 0
    prozente = []
    for ergebnis in ergebnisse:
        summe += ergebnis
    for ergebnis in ergebnisse:
        prozente.extend([float(ergebnis) / summe])
    return prozente
# Ende der Funktion

if __name__ == '__main__':
    start = datetime.datetime.now()
    print(start)

    for a in range(0, gueltige_stimmen + 1):
        for b in range(0, a + 1):
            for c in range(0, b + 1):
                varianten_gesamt += 1
                subcount +=1

                # Parteisummen speichern
                partei_summen = [0,0,0,0]
                partei_summen[0] = gueltige_stimmen - a
                partei_summen[1] = a - b
                partei_summen[2] = b - c
                partei_summen[3] = c
                sum = partei_summen[0] + partei_summen[1] + partei_summen[2] + partei_summen[3]

                # Prozentanteil errechnen
                prozente = []
                prozente = Prozent(partei_summen)
                
                mandate_nach_prozent = []
                mandate_nach_prozent = MandateNachProzent(gueltige_stimmen, partei_summen, zu_vergebende_mandate)
                
                mandate_nach_d_hondt = []
                mandate_nach_d_hondt = MandateNachDHondt(partei_summen, zu_vergebende_mandate)
                
                prozent_nach_d_hondt = []
                prozent_nach_d_hondt = Prozent(mandate_nach_d_hondt)
                
                if subcount == 10000:
                    print('Parteisummen: {}, Prozent: {}, Prozent nach d\'Hondt: {}, nach d\'Hondt: {}, nach Prozent: {}'.format(partei_summen, prozente, prozent_nach_d_hondt, mandate_nach_d_hondt, mandate_nach_prozent))
                    subcount = 0
                if partei_summen[0] > partei_summen[1] and partei_summen[0] > partei_summen[2] and partei_summen[0] > partei_summen[3]:
                    varianten_mehrheitspartei += 1
                
                    for index in range(0, anzahl_parteien):
                        # Wenn Partei nach d'Hondt mehr Sitze erhält
                        if (mandate_nach_d_hondt[index] > mandate_nach_prozent[index]):
                            #print('more {} {}'.format(mandate_nach_d_hondt[index], mandate_nach_prozent[index]))
                            anzahl_mandat_dazu[index] += 1
                            unterschied = mandate_nach_d_hondt[index] - mandate_nach_prozent[index]
                            partei_mandate_dazu[index][unterschied] += 1
                        # Wenn Partei nach d'Hondt weniger Sitze erhält
                        if (mandate_nach_d_hondt[index] < mandate_nach_prozent[index]):
                            anzahl_mandat_weg[index] += 1
                            unterschied = mandate_nach_prozent[index] - mandate_nach_d_hondt[index]
                            partei_mandate_weg[index][unterschied] += 1
                        # Wenn die Anzahl der Sizte gleich bleibt
                        if (mandate_nach_d_hondt[index] == mandate_nach_prozent[index]):
                            anzahl_mandat_gleich[index] += 1
                            partei_mandate_dazu[index][0] += 1
                            partei_mandate_weg[index][0] += 1

    stop = datetime.datetime.now()
    print(stop)
    print('Berechnungsdauer: {}'.format(stop-start))

    print('Fälle gesamt: {}'.format(varianten_gesamt))
    print('Fälle mit Mehrheit Partei 1: {}'.format(varianten_mehrheitspartei))
    print(anzahl_mandat_dazu)
    print(anzahl_mandat_gleich)
    print(anzahl_mandat_weg)

    print(partei_mandate_dazu)
    print(partei_mandate_weg)

#for index in range(anzahl_parteien):
#    print('partei_mandate_dazu[{}]: {}'.format(index + 1, partei_mandate_dazu))
#    print('partei_mandate_weg[{}]: {}'.format(index + 1, partei_mandate_weg))

#for index in range(anzahl_parteien):
#    print('Partei {}: '.format(index + 1))
#    print('Sitze Zugewinn:')
#    for j in range(0, len(partei_mandate_dazu)):
#        print('{} Sitze: {}, '.format(j, partei_mandate_dazu[index][j]), end = '')
#    print()
#    print('Sitze Verlust:')
#    for j in range(0, len(partei_mandate_weg)):
#        print('{} Sitze: {}, '.format(j, partei_mandate_weg[index][j]), end = '')
#    print()