import numpy as np
import math

def werteListe(absoluteHaufigkeiten):
    werte = []
    for wert in absoluteHaufigkeiten.keys():
        for i in range(absoluteHaufigkeiten[wert]):
            werte.append(wert)
    return werte

def mittelwert(werte=[], haufigkeiten={}):
    count = 0
    sum = 0
    if(len(haufigkeiten) > 0):
        for wert in haufigkeiten.keys():
            sum = sum + wert * haufigkeiten[wert]
            count = count + haufigkeiten[wert]
        return sum / count
    else:
        return np.sum(werte) / len(werte)

def anzahlElemente(werte, absoluteHaufigkeiten={}):
    if(len(absoluteHaufigkeiten) > 0):
        sum(absoluteHaufigkeiten.values())
    else:
        return len(werte)

def absoluteHaufigkeiten(werte):
    haufigkeiten = {}
    for wert in werte:
        if(wert in haufigkeiten):
            haufigkeiten[wert] = haufigkeiten[wert] + 1
        else:
            haufigkeiten[wert] = 1
    return haufigkeiten

def relativeHaufigkeiten(werte=[], absoluteWerte={}):
    haufigkeiten = {}
    if(len(absoluteWerte) == 0):
        absoluteWerte = absoluteHaufigkeiten(werte)
    anzahl = anzahlElemente(werte)
    for wert in absoluteWerte.keys():
        haufigkeiten[wert] = absoluteWerte[wert] / anzahl
    return haufigkeiten

def qquantil(werte, q):
    werteSortiert = sorted(werte)
    nq = len(werteSortiert) * q
    if nq % 1 == 0: #ganze Zahl
        nq = int(nq - 1)
        return 0.5 * (werteSortiert[nq] + werteSortiert[nq+1])
    else: #nicht ganze Zahl
        return werteSortiert[int(np.ceil(nq - 1))]

def median(werte):
    return qquantil(werte, 0.5)

def interqurartilsabstand(werte):
    return qquantil(werte, 0.75) - qquantil(werte, 0.25)



def varianz(werte=[], absoluteHaufigkeiten={}, relativeHaufigkeiten={}, pdf={}, stichprobengroesse=0, korrigiert=False):
    summe = 0
    if(len(relativeHaufigkeiten) > 0):
        mittel = mittelwert(haufigkeiten=relativeHaufigkeiten)
        for wert in relativeHaufigkeiten.keys():
            summe = summe + (relativeHaufigkeiten[wert] * (wert - mittel) ** 2)
        if (korrigiert):
            return summe * stichprobengroesse / (stichprobengroesse - 1)
        else:
            return summe
    elif (len(pdf) > 0):
        mittel = mittelwert(haufigkeiten=pdf)
        for wert in pdf.keys():
            summe = summe + (pdf[wert] * (wert - mittel) ** 2)
        if(korrigiert):
            return (summe / sum(pdf.values())) * stichprobengroesse / (stichprobengroesse - 1)
        else:
            return summe / sum(pdf.values())
    elif(len(absoluteHaufigkeiten) > 0):
        werte = werteListe(absoluteHaufigkeiten)
    if(len(werte) > 0):
        mittel = mittelwert(werte=werte)
        for wert in werte:
            summe = summe + (wert - mittel)**2
        if(korrigiert):
            return summe / (anzahlElemente(werte=werte) - 1)
        else:
            return summe / anzahlElemente(werte=werte)

def standardabweichung(werte=[], absuluteHaufigkeit={}, relativeHaufigkeiten={}, pdf={}, stichprobengroesse=0, korrigiert=False):
    return np.sqrt(varianz(werte, absuluteHaufigkeit, relativeHaufigkeiten, pdf, stichprobengroesse, korrigiert))


def kovarianz(wertePaare=[]):
    summe = 0
    n = len(wertePaare)
    xMittel = mittelwert([wert[0] for wert in wertePaare])
    yMittel = mittelwert([wert[1] for wert in wertePaare])
    for wert in wertePaare:
        x = wert[0]
        y = wert[1]
        summe = summe + ((x - xMittel) * (y - yMittel))
    return float(summe) / float(n)

def korrelationskoeffizentPearson(wertePaare=[]):
    xStandardabweichung = standardabweichung([wert[0] for wert in wertePaare])
    yStandardabweichung = standardabweichung([wert[1] for wert in wertePaare])
    return float(kovarianz(wertePaare)) / float(xStandardabweichung * yStandardabweichung)

def rang(wertePaare=[], xWerte=[], yWerte=[]):
    if(len(wertePaare) < 1):
        wertePaare = bildeWertePaare(xWerte, yWerte)
    wertePaare.sort(key=lambda tup: tup[0])
    wertePaare = [(wertePaare[i][0], wertePaare[i][1], i + 1) for i in range(len(wertePaare))]
    wertePaare.sort(key=lambda tup: tup[1])
    wertePaare = [(wertePaare[i][0], wertePaare[i][1], wertePaare[i][2], i + 1) for i in range(len(wertePaare))]
    return wertePaare

def korrelationskoeffizentPearsonRang(wertePaare=[]):
    wertePaare = rang(wertePaare=wertePaare)
    n = len(wertePaare)
    rangMittelwert = float((len(wertePaare) + 1)) / 2.0
    summeZahler = 0
    summeNennerX = 0
    summeNennerY = 0
    for wertePaar in wertePaare:
        summeZahler = summeZahler + (wertePaar[2] - rangMittelwert) * (wertePaar[3] - rangMittelwert)
        summeNennerX = summeNennerX + math.pow(wertePaar[2] - rangMittelwert, 2)
        summeNennerY = summeNennerY + math.pow(wertePaar[3] - rangMittelwert, 2)
    return summeZahler / (math.sqrt(summeNennerX) * math.sqrt(summeNennerY))







def bildeWertePaare(x=[], y=[]):
    wertePaare = []
    if not len(x) == len(y):
        return False
    for i in range(len(x)):
        wertePaare.append((x[i], y[i]))
    return wertePaare

if __name__ == '__main__':
    #werte = [12, -5, 5, 52, -6, -5, 8, -7, 22, -46, 8, -14, 5, 47]
    #haufigkeiten = {0: 6, 1: 6, 2: 3, 3: 5, 8: 6}
    werteX = [59, 35, 43, 23, 42, 27]
    werteY = [14.6, 11.8, 14.3, 13.0, 14.2, 11.0]
    werte = bildeWertePaare(werteX, werteY)
    print(kovarianz(werte))
    print(korrelationskoeffizentPearson(werte))
    print(korrelationskoeffizentPearsonRang(werte))
    #werte = [9, 7, 7, 6, 1]
    # haufigkeiten = {11: 3/20, 13: 1/2, 15: 1/10, 17: 1/5, 19: 1/20}
    # print("Anzahl Elemente: " , anzahlElemente(werte))
    # print("Absolute häufigkeiten: " , absoluteHaufigkeiten(werte))
    # print("RElative Haufigkeiten: ", relativeHaufigkeiten(werte))
    # print("Mittelwert: ", mittelwert(werte))
    # print("q1: " ,qquantil(werte, 0.25))
    # print("q2: " , qquantil(werte, 0.5))
    # print("q3: " , qquantil(werte, 0.75))
    # print("Interquartilsabstand: ", interqurartilsabstand(werte))
    # print("Varianz: ", varianz(absoluteHaufigkeiten=haufigkeiten))
    #print("Standardabweichung: ", standardabweichung(werte, korrigiert=True))
    # print("Mittelwert : ", mittelwert(haufigkeiten=haufigkeiten))
    # print("empirische Varianz: ", varianz(absoluteHaufigkeiten=haufigkeiten, stichprobengroesse=0, korrigiert=True))
    # print("empirische Standardabweichung", standardabweichung(absuluteHaufigkeit=haufigkeiten, stichprobengroesse=20, korrigiert=False))
    # print("empirische Varianz: ", varianz(absoluteHaufigkeiten=haufigkeiten, stichprobengroesse=20, korrigiert=True))
    #print("empirische Standardabweichung", standardabweichung(werte=werte, stichprobengroesse=0, korrigiert=True))