2_Portfoliooptimierung.py

# -*- coding: utf-8 -*-
"""
Created on Wed Jun  9 00:49:15 2021

@author: jonas
"""

import pandas as pd
import xlrd
import numpy as np
import matplotlib.pyplot as plt
import scipy.optimize as sco

#Methode zum Einlesen der Daten aus der Excel Datei
def read_excel_file(filename, spalte_von, spalte_bis, zeile_von, zeile_bis):
    book = xlrd.open_workbook(filename, encoding_override = "utf-8")
    sheet = book.sheet_by_index(0)
    #"leere" Matrix der größe aller einzulesenen Daten
    data = np.zeros([zeile_bis - zeile_von + 1, spalte_bis - spalte_von + 1])
    #spaltenweises Einlesen der Daten aus der übergebenen Excel-Datei
    spalte = 0
    for j in range (spalte_von - 1, spalte_bis):
        data[:, spalte] = np.asarray([sheet.cell(i, j).value for i in range(zeile_von -1, zeile_bis)])
        spalte += 1
    #Rückgabe der Matrix, alle Werte (=Strompreise) dabei gerundet auf 2 Nachkommastellen
    return np.around(data, 2)

#Funktion die die basierend auf einem Cashflow-Array und einem K-Wert die Cashflows des FPIC (als Array), den Erwartungswert(=0), die Standardabweichung und den pi-Wert zurückgibt
def fpic_berechnung (cf_flexibilitaet, K = 0, K_anteil_von_erwartungswert = 0):

    #Berechnung von K falls kein bestimmtes K angegeben wurde sondern ein Anteil am Erwartungswert
    if (K == 0):
        K = np.mean(cf_flexibilitaet) * K_anteil_von_erwartungswert

    #Berechnung des "fairen" pi-Wertes
    berechnung_pi = np.zeros(len(cf_flexibilitaet))
    for i in range (0, len(cf_flexibilitaet)):
        berechnung_pi[i] = max(K - cf_flexibilitaet[i], 0)
    pi = np.around(np.mean(berechnung_pi), 2)

    #leeres Ergebnis-Array für die Cashflows des FPIC
    fpic_cfs = np.zeros(len(cf_flexibilitaet))
    #Berechnen der einzelnenen Cashflows und Einfügen in das Array
    for i in range (0, len(cf_flexibilitaet)):
        fpic_cfs[i] = pi - max(K - cf_flexibilitaet[i], 0)

    #Erwartungswert
    fpic_mean = np.around(np.mean(fpic_cfs), 2)

    #Standardabweichung
    fpic_std = np.around(np.std(fpic_cfs), 2)

    #Rückgabe der FPIC-Cashflows als array, des Mittelwertes (=0), der Standardabweichung und des pi-Wertes
    return fpic_cfs, fpic_mean, fpic_std, pi

#Funktion die die basierend auf einem Cashflow-Array und einem K-Wert die Cashflows des FSG (als Array), den Erwartungswert(=0), die Standardabweichung und den alpha-Wert zurückgibt
def fsg_berechnung (cf_flexibilitaet, K = 0, K_anteil_von_erwartungswert = 0):

    #Berechnung von K falls kein bestimmtes K angegeben wurde sondern ein Anteil am Erwartungswert
    if (K == 0):
        K = np.mean(cf_flexibilitaet) * K_anteil_von_erwartungswert

    #Berechnung des "fairen" alpha Wertes
    hilfe = np.zeros(len(cf_flexibilitaet))
    for i in range (0, len(cf_flexibilitaet)):
        hilfe[i] = max(cf_flexibilitaet[i] - K, 0)

    #Falls "np.mean(hilfe) == 0" ist alpha unendlich. Damit hier kein fehler geworfen wird, wird mit einer miimal kleinen Zahl gerechnet (hat keine Auswirkungen auf späteres Endergebnis)
    if (np.mean(hilfe) == 0):
        fsg_alpha = fpic_berechnung(cf_flexibilitaet=cf_flexibilitaet, K = K, K_anteil_von_erwartungswert = K_anteil_von_erwartungswert)[3] / 0.0000000001
    else:
        fsg_alpha = fpic_berechnung(cf_flexibilitaet=cf_flexibilitaet, K = K, K_anteil_von_erwartungswert = K_anteil_von_erwartungswert)[3] / np.mean(hilfe)

    #leeres Ergebnis-Array für die Cashflows des FSG
    fsg_cfs = np.zeros(len(cf_flexibilitaet))
    #Berechnen der einzelnenen Cashflows und Einfügen in das Array
    for i in range (0, len(cf_flexibilitaet)):
        fsg_cfs[i] = fsg_alpha * max(cf_flexibilitaet[i] - K, 0) - max(K - cf_flexibilitaet[i], 0)

    #Erwartungswert
    fsg_mean = np.around(np.mean(fsg_cfs), 2)

    #Standardabweichung
    fsg_std = np.around(np.std(fsg_cfs), 2)

    #Rückgabe der FSG-Cashflows als array, des Mittelwertes (=0), der Standardabweichung und des alpha-Wertes
    return fsg_cfs, fsg_mean, fsg_std, np.around(fsg_alpha, 4)

#Funktion, die für eine Matrix mit spaltenweisen Werten eine Covarianz-Matrix zurückgibt
def covarianz_matrix (erwartungswerte_flexibilitaeten_matrix):
    #Bestimmung der Anzahl der übergebenen Flexibilitäten (=Anzahl der Spalten)
    anzahl_flexibilitaeten = erwartungswerte_flexibilitaeten_matrix[0, :].size
    #leere Covarianz-Matrix der dimension nxn mit n der Anzahl an übergebenen flexibilitäten
    cov_matrix = np.zeros((anzahl_flexibilitaeten, anzahl_flexibilitaeten))
    #Befüllung der Matrix
    for i in range (anzahl_flexibilitaeten) :
        for j in range (anzahl_flexibilitaeten):
            cov_matrix[i, j] = np.cov(erwartungswerte_flexibilitaeten_matrix[:, i], erwartungswerte_flexibilitaeten_matrix[:, j]) [0, 1]
    #Rückgabe der Covarianz-Matrix
    return cov_matrix

#Berechnung der Werte eines Portfolios
def portfolio_berechnung(gewichtungen, erwartungswerte_flexibilitaeten, cov_matrix):
    #Berechnung des Portfolioerwartungswertes
    portfolio_erwartungswert = np.sum(erwartungswerte_flexibilitaeten * gewichtungen )
    #Berechnung der Portfoliostandardabweichung
    portfolio_std = np.sqrt(np.dot(gewichtungen.T, np.dot(cov_matrix, gewichtungen).T))
    #Rückgabe der Portfolio-Standardabweichung und des Portfolio-Erwartungswertes
    return portfolio_std, portfolio_erwartungswert

#Methode identisch zu "portfolio_berechnung" nur mit nur einem Rückgabewert
def portfolio_berechnung_std(gewichtungen, erwartungswerte_flexibilitaeten, cov_matrix):
    #Rückgabe der Portfolio-Standardabweichung
    return float(portfolio_berechnung(gewichtungen, erwartungswerte_flexibilitaeten, cov_matrix)[0])

#Berechnung zufälliger Portfolios
def random_protfolios(anzahl_random_portfolios, erwartungswerte_flexibilitaeten, cov_matrix):
    #leere Matrix zum Speichern der Erwartungswerte und der Standardabweichungen
    results = np.zeros((2, anzahl_random_portfolios))
    #leere Matrix zum Speichern der zufälligen Gewichtungen
    gewichtungen_liste = []

    #erstellen von zufälligen Porfolios und Hinzufügen der Gewichtungen zur Gewichtung-Liste und der Ergebnisse zum Erebnis-Array
    for i in range (anzahl_random_portfolios):
      gewichtungen = np.random.random(len(erwartungswerte_flexibilitaeten))
      gewichtungen /= np.sum(gewichtungen)
      gewichtungen_liste.append(gewichtungen)
      portfolio_std, portfolio_erwartungswert =portfolio_berechnung(gewichtungen, erwartungswerte_flexibilitaeten, cov_matrix)
      results[0,i] = portfolio_std
      results[1,i] = portfolio_erwartungswert
    return  results, gewichtungen_liste

#Graphische Darstelllung der Berechnung zufälliger Portfolios
def darstellung_der_simulationen(anzahl_random_portfolios, erwartungswerte_flexibilitaeten, cov_matrix):

    #Durchfhrung der simulation von verschiedenen zufälligen Portfolios
    results, gewichtungen_liste = random_protfolios(anzahl_random_portfolios, erwartungswerte_flexibilitaeten, cov_matrix)

    #"suchen" des varianzminimalsten Portfolios aus den zufälligen Porfolios und Herauslesen der dazugehörigen Daten
    min_std = np.argmin(results[0])
    sdp_min, erw_min = results[0,min_std], results[1,min_std]
    min_std_allocation = pd.DataFrame(gewichtungen_liste[min_std],columns=['allocation'])
    min_std_allocation.allocation = [round(i*100,2)for i in min_std_allocation.allocation]
    min_std_allocation = min_std_allocation.T

    #Ausgabe des varianzminimalen Portfolios aus den zufäligen Portfolios (entpsircht Annährung, meist relativ genau)
    #print(gewichtungen_liste[min_std])

    #Plotten der verschiedenen zufälligen Porfolios, führt bei Erwartungswert von 0 zu unspektakulären Ergebnissen, sonst aber gute visuelle Darstellung
    plt.figure()
    plt.scatter(results[0,:],results[1,:],cmap='YlGnBu', marker='o', s=5, alpha=0.2)
    plt.scatter(sdp_min,erw_min,marker='*',color='r',s=50, label='Minimale Varianz')
    plt.xlabel('Standardabweichung',fontsize=18)
    plt.ylabel('Erwartungswert',fontsize=18)
    plt.xticks(fontsize=10)
    plt.yticks(fontsize=10)
    plt.legend(labelspacing=0.4)

#Funktion zur Berechnung eines varianzminimalen-Pportfolios
def varianzminimales_portfolio(erwartungswerte_flexibilitaeten, cov_matrix):
    anzahl = len(erwartungswerte_flexibilitaeten)
    #Derfinition der Optimierung zu übergebenden Parameter
    args = (erwartungswerte_flexibilitaeten, cov_matrix)
    #Nebenbedinung der Optimierung
    constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
    #Grenzen der Zielvariablen der Optimierung
    bound = (0.0,1.0)
    #Anwendung der Grenze auf alle Zielvariablen
    bounds = tuple(bound for flex in range(anzahl))
    #Startwert für die Optimierung
    initial_guess = np.zeros(anzahl)
    initial_guess[0] = 1
    #Optimierung
    result = sco.minimize(portfolio_berechnung_std, initial_guess, args=args, method='SLSQP', bounds=bounds, constraints=constraints)
    #Rückgabe der Ergebnisse der Optimierung = varianzminimales Portfolio (Gewichtung und Standardabweichung)
    return result.x, result.fun

def portfoliooptimierung (filename, f_eins, f_zwei, f_drei, f_vier, f_fuenf, f_sechs, f_sieben, f_acht, f_neun, f_zehn, f_elf, f_zwoelf, f_dreizehn, K_Wert_Anteil: int, Vertrag=True):

    #Einlesen der Flexibilitäts-Daten
    flexibilitaeten_alle = read_excel_file(filename=filename, spalte_von=12, spalte_bis=21, zeile_von = 3, zeile_bis = 158)

    #Anlegen aller Flexibilitäten mit Erwartungswert und Standardabweichung (etwas unschön aber nicht einfach "automatisch zu machen", da sonst ein Array erstellt werden muss und das ständig geändert werden muss)
    anzahl = 0
    flex_ID_1 = np.zeros(120)
    flex_ID_1_mean = 0
    flex_ID_1_std = 0
    flex_ID_2 = np.zeros(120)
    flex_ID_2_mean = 0
    flex_ID_2_std = 0
    flex_ID_3 = np.zeros(120)
    flex_ID_3_mean = 0
    flex_ID_3_std = 0
    flex_ID_4 = np.zeros(120)
    flex_ID_4_mean = 0
    flex_ID_4_std = 0
    flex_ID_5 = np.zeros(120)
    flex_ID_5_mean = 0
    flex_ID_5_std = 0
    flex_ID_6 = np.zeros(120)
    flex_ID_6_mean = 0
    flex_ID_6_std = 0
    flex_ID_7 = np.zeros(120)
    flex_ID_7_mean = 0
    flex_ID_7_std = 0
    flex_ID_8 = np.zeros(120)
    flex_ID_8_mean = 0
    flex_ID_8_std = 0
    flex_ID_9 = np.zeros(120)
    flex_ID_9_mean = 0
    flex_ID_9_std = 0
    flex_ID_10 = np.zeros(120)
    flex_ID_10_mean = 0
    flex_ID_10_std = 0
    flex_ID_11 = np.zeros(120)
    flex_ID_11_mean = 0
    flex_ID_11_std = 0
    flex_ID_12 = np.zeros(120)
    flex_ID_12_mean = 0
    flex_ID_12_std = 0
    flex_ID_13 = np.zeros(120)
    flex_ID_13_mean = 0
    flex_ID_13_std = 0

    #Einlesen der benötigten Flexibilitäten und Berechnung der dazugehörigen FPIC-Varianz
    if (f_eins):
        for i in range (0, 12):
            flex_ID_1[10*i:10*i +10] = flexibilitaeten_alle[i, 0:10]
        flex_ID_1_fpic, flex_ID_1_mean_fpic, flex_ID_1_std_fpic = fpic_berechnung(flex_ID_1, 0, K_Wert_Anteil)[0:3]
        flex_ID_1_fsg, flex_ID_1_mean_fsg, flex_ID_1_std_fsg = fsg_berechnung(flex_ID_1, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_1, flex_ID_1_mean, flex_ID_1_std =  flex_ID_1_fpic, flex_ID_1_mean_fpic, flex_ID_1_std_fpic
        else:
             flex_ID_1, flex_ID_1_mean, flex_ID_1_std =  flex_ID_1_fsg, flex_ID_1_mean_fsg, flex_ID_1_std_fsg
        anzahl +=1
    if (f_zwei):
        for i in range (0, 12):
            flex_ID_2[10*i:10*i +10] = flexibilitaeten_alle[i+12, 0:10]
        flex_ID_2_fpic, flex_ID_2_mean_fpic, flex_ID_2_std_fpic = fpic_berechnung(flex_ID_2, 0, K_Wert_Anteil)[0:3]
        flex_ID_2_fsg, flex_ID_2_mean_fsg, flex_ID_2_std_fsg = fsg_berechnung(flex_ID_2, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_2, flex_ID_2_mean, flex_ID_2_std =  flex_ID_2_fpic, flex_ID_2_mean_fpic, flex_ID_2_std_fpic
        else:
            flex_ID_2, flex_ID_2_mean, flex_ID_2_std =  flex_ID_2_fsg, flex_ID_2_mean_fsg, flex_ID_2_std_fsg
        anzahl +=1
    if (f_drei):
        for i in range (0, 12):
            flex_ID_3[10*i:10*i +10] = flexibilitaeten_alle[i+24, 0:10]
        flex_ID_3_fpic, flex_ID_3_mean_fpic, flex_ID_3_std_fpic = fpic_berechnung(flex_ID_3, 0, K_Wert_Anteil)[0:3]
        flex_ID_3_fsg, flex_ID_3_mean_fsg, flex_ID_3_std_fsg = fsg_berechnung(flex_ID_3, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_3, flex_ID_3_mean, flex_ID_3_std =  flex_ID_3_fpic, flex_ID_3_mean_fpic, flex_ID_3_std_fpic
        else:
            flex_ID_3, flex_ID_3_mean, flex_ID_3_std =  flex_ID_3_fsg, flex_ID_3_mean_fsg, flex_ID_3_std_fsg
        anzahl +=1
    if (f_vier):
        for i in range (0, 12):
            flex_ID_4[10*i:10*i +10] = flexibilitaeten_alle[i+36, 0:10]
        flex_ID_4_fpic, flex_ID_4_mean_fpic, flex_ID_4_std_fpic = fpic_berechnung(flex_ID_4, 0, K_Wert_Anteil)[0:3]
        flex_ID_4_fsg, flex_ID_4_mean_fsg, flex_ID_4_std_fsg = fsg_berechnung(flex_ID_4, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_4, flex_ID_4_mean, flex_ID_4_std =  flex_ID_4_fpic, flex_ID_4_mean_fpic, flex_ID_4_std_fpic
        else:
            flex_ID_4, flex_ID_4_mean, flex_ID_4_std =  flex_ID_4_fsg, flex_ID_4_mean_fsg, flex_ID_4_std_fsg
        anzahl +=1
    if (f_fuenf):
        for i in range (0, 12):
            flex_ID_5[10*i:10*i +10] = flexibilitaeten_alle[i+48, 0:10]
        flex_ID_5_fpic, flex_ID_5_mean_fpic, flex_ID_5_std_fpic = fpic_berechnung(flex_ID_5, 0, K_Wert_Anteil)[0:3]
        flex_ID_5_fsg, flex_ID_5_mean_fsg, flex_ID_5_std_fsg = fsg_berechnung(flex_ID_5, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_5, flex_ID_5_mean, flex_ID_5_std =  flex_ID_5_fpic, flex_ID_5_mean_fpic, flex_ID_5_std_fpic
        else:
            flex_ID_5, flex_ID_5_mean, flex_ID_5_std =  flex_ID_5_fsg, flex_ID_5_mean_fsg, flex_ID_5_std_fsg
        anzahl +=1
    if (f_sechs):
        for i in range (0, 12):
            flex_ID_6[10*i:10*i +10] = flexibilitaeten_alle[i+60, 0:10]
        flex_ID_6_fpic, flex_ID_6_mean_fpic, flex_ID_6_std_fpic = fpic_berechnung(flex_ID_6, 0, K_Wert_Anteil)[0:3]
        flex_ID_6_fsg, flex_ID_6_mean_fsg, flex_ID_6_std_fsg = fsg_berechnung(flex_ID_6, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_6, flex_ID_6_mean, flex_ID_6_std =  flex_ID_6_fpic, flex_ID_6_mean_fpic, flex_ID_6_std_fpic
        else:
            flex_ID_6, flex_ID_6_mean, flex_ID_6_std =  flex_ID_6_fsg, flex_ID_6_mean_fsg, flex_ID_6_std_fsg
        anzahl +=1
    if (f_sieben):
        for i in range (0, 12):
            flex_ID_7[10*i:10*i +10] = flexibilitaeten_alle[i+72, 0:10]
        flex_ID_7_fpic, flex_ID_7_mean_fpic, flex_ID_7_std_fpic = fpic_berechnung(flex_ID_7, 0, K_Wert_Anteil)[0:3]
        flex_ID_7_fsg, flex_ID_7_mean_fsg, flex_ID_7_std_fsg = fsg_berechnung(flex_ID_7, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_7, flex_ID_7_mean, flex_ID_7_std =  flex_ID_7_fpic, flex_ID_7_mean_fpic, flex_ID_7_std_fpic
        else:
            flex_ID_7, flex_ID_7_mean, flex_ID_7_std =  flex_ID_7_fsg, flex_ID_7_mean_fsg, flex_ID_7_std_fsg
        anzahl +=1
    if (f_acht):
        for i in range (0, 12):
            flex_ID_8[10*i:10*i +10] = flexibilitaeten_alle[i+84, 0:10]
        flex_ID_8_fpic, flex_ID_8_mean_fpic, flex_ID_8_std_fpic = fpic_berechnung(flex_ID_8, 0, K_Wert_Anteil)[0:3]
        flex_ID_8_fsg, flex_ID_8_mean_fsg, flex_ID_8_std_fsg = fsg_berechnung(flex_ID_8, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_8, flex_ID_8_mean, flex_ID_8_std =  flex_ID_8_fpic, flex_ID_8_mean_fpic, flex_ID_8_std_fpic
        else:
            flex_ID_8, flex_ID_8_mean, flex_ID_8_std =  flex_ID_8_fsg, flex_ID_8_mean_fsg, flex_ID_8_std_fsg
        anzahl +=1
    if (f_neun):
        for i in range (0, 12):
            flex_ID_9[10*i:10*i +10] = flexibilitaeten_alle[i+96, 0:10]
        flex_ID_9_fpic, flex_ID_9_mean_fpic, flex_ID_9_std_fpic = fpic_berechnung(flex_ID_9, 0, K_Wert_Anteil)[0:3]
        flex_ID_9_fsg, flex_ID_9_mean_fsg, flex_ID_9_std_fsg = fsg_berechnung(flex_ID_9, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_9, flex_ID_9_mean, flex_ID_9_std =  flex_ID_9_fpic, flex_ID_9_mean_fpic, flex_ID_9_std_fpic
        else:
            flex_ID_9, flex_ID_9_mean, flex_ID_9_std =  flex_ID_9_fsg, flex_ID_9_mean_fsg, flex_ID_9_std_fsg
        anzahl +=1
    if (f_zehn):
        for i in range (0, 12):
            flex_ID_10[10*i:10*i +10] = flexibilitaeten_alle[i+108, 0:10]
        flex_ID_10_fpic, flex_ID_10_mean_fpic, flex_ID_10_std_fpic = fpic_berechnung(flex_ID_10, 0, K_Wert_Anteil)[0:3]
        flex_ID_10_fsg, flex_ID_10_mean_fsg, flex_ID_10_std_fsg = fsg_berechnung(flex_ID_10, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_10, flex_ID_10_mean, flex_ID_10_std =  flex_ID_10_fpic, flex_ID_10_mean_fpic, flex_ID_10_std_fpic
        else:
            flex_ID_10, flex_ID_10_mean, flex_ID_10_std =  flex_ID_10_fsg, flex_ID_10_mean_fsg, flex_ID_10_std_fsg
        anzahl +=1
    if (f_elf):
        for i in range (0, 12):
            flex_ID_11[10*i:10*i +10] = flexibilitaeten_alle[i+120, 0:10]
        flex_ID_11_fpic, flex_ID_11_mean_fpic, flex_ID_11_std_fpic = fpic_berechnung(flex_ID_11, 0, K_Wert_Anteil)[0:3]
        flex_ID_11_fsg, flex_ID_11_mean_fsg, flex_ID_11_std_fsg = fsg_berechnung(flex_ID_11, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_11, flex_ID_11_mean, flex_ID_11_std =  flex_ID_11_fpic, flex_ID_11_mean_fpic, flex_ID_11_std_fpic
        else:
            flex_ID_11, flex_ID_11_mean, flex_ID_11_std =  flex_ID_11_fsg, flex_ID_11_mean_fsg, flex_ID_11_std_fsg
        anzahl +=1
    if (f_zwoelf):
        for i in range (0, 12):
            flex_ID_12[10*i:10*i +10] = flexibilitaeten_alle[i+132, 0:10]
        flex_ID_12_fpic, flex_ID_12_mean_fpic, flex_ID_12_std_fpic = fpic_berechnung(flex_ID_12, 0, K_Wert_Anteil)[0:3]
        flex_ID_12_fsg, flex_ID_12_mean_fsg, flex_ID_12_std_fsg = fsg_berechnung(flex_ID_12, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_12, flex_ID_12_mean, flex_ID_12_std =  flex_ID_12_fpic, flex_ID_12_mean_fpic, flex_ID_12_std_fpic
        else:
            flex_ID_12, flex_ID_12_mean, flex_ID_12_std =  flex_ID_12_fsg, flex_ID_12_mean_fsg, flex_ID_12_std_fsg
        anzahl +=1
    if (f_dreizehn):
        for i in range (0, 12):
            flex_ID_13[10*i:10*i +10] = flexibilitaeten_alle[i+144, 0:10]
        flex_ID_13_fpic, flex_ID_13_mean_fpic, flex_ID_13_std_fpic = fpic_berechnung(flex_ID_13, 0, K_Wert_Anteil)[0:3]
        flex_ID_13_fsg, flex_ID_13_mean_fsg, flex_ID_13_std_fsg = fsg_berechnung(flex_ID_13, 0, K_Wert_Anteil)[0:3]
        if (Vertrag):
            flex_ID_13, flex_ID_13_mean, flex_ID_13_std =  flex_ID_13_fpic, flex_ID_13_mean_fpic, flex_ID_13_std_fpic
        else:
            flex_ID_13, flex_ID_13_mean, flex_ID_13_std =  flex_ID_13_fsg, flex_ID_13_mean_fsg, flex_ID_13_std_fsg
        anzahl +=1

    #Erstellung eines Arrays mit den ausgewählten Zeitreihen
    list_hilfe_1 =[f_eins, f_zwei, f_drei, f_vier, f_fuenf, f_sechs, f_sieben, f_acht, f_neun, f_zehn, f_elf, f_zwoelf, f_dreizehn]
    flex_hilfe = np.zeros ((120, 13))
    flex_hilfe[:, 0]= flex_ID_1
    flex_hilfe[:, 1]= flex_ID_2
    flex_hilfe[:, 2]= flex_ID_3
    flex_hilfe[:, 3]= flex_ID_4
    flex_hilfe[:, 4]= flex_ID_5
    flex_hilfe[:, 5]= flex_ID_6
    flex_hilfe[:, 6]= flex_ID_7
    flex_hilfe[:, 7]= flex_ID_8
    flex_hilfe[:, 8]= flex_ID_9
    flex_hilfe[:, 9]= flex_ID_10
    flex_hilfe[:, 10]= flex_ID_11
    flex_hilfe[:, 11]= flex_ID_12
    flex_hilfe[:, 12]= flex_ID_13

    flex = np.zeros ((120, anzahl))

    for i in range (0, anzahl):
        for j in range (0, 13):
            if (list_hilfe_1[j]):
                flex[:,i] = flex_hilfe[:, j]
                list_hilfe_1[j] = False
                break

    #Erstellung des Arrays mit den Mittelwerten der Flexibilitaet
    list_hilfe_2 =[f_eins, f_zwei, f_drei, f_vier, f_fuenf, f_sechs, f_sieben, f_acht, f_neun, f_zehn, f_elf, f_zwoelf, f_dreizehn]
    erwartungswerte_flex_hilfe = np.zeros(13)
    erwartungswerte_flex_hilfe[0] = flex_ID_1_mean
    erwartungswerte_flex_hilfe[1] = flex_ID_2_mean
    erwartungswerte_flex_hilfe[2] = flex_ID_3_mean
    erwartungswerte_flex_hilfe[3] = flex_ID_4_mean
    erwartungswerte_flex_hilfe[4] = flex_ID_5_mean
    erwartungswerte_flex_hilfe[5] = flex_ID_6_mean
    erwartungswerte_flex_hilfe[6] = flex_ID_7_mean
    erwartungswerte_flex_hilfe[7] = flex_ID_8_mean
    erwartungswerte_flex_hilfe[8] = flex_ID_9_mean
    erwartungswerte_flex_hilfe[9] = flex_ID_10_mean
    erwartungswerte_flex_hilfe[10] = flex_ID_11_mean
    erwartungswerte_flex_hilfe[11] = flex_ID_12_mean
    erwartungswerte_flex_hilfe[12] = flex_ID_13_mean

    erwartungswerte_flex = np.zeros(anzahl)

    for i in range (0, anzahl):
        for j in range (0, 13):
            if (list_hilfe_2[j]):
                erwartungswerte_flex[i] = erwartungswerte_flex_hilfe[j]
                list_hilfe_2[j] = False
                break

    #Erstellung eines Arrays mit den Standardabweichungen
    list_hilfe_3 =[f_eins, f_zwei, f_drei, f_vier, f_fuenf, f_sechs, f_sieben, f_acht, f_neun, f_zehn, f_elf, f_zwoelf, f_dreizehn]
    std_flex_hilfe = np.zeros(13)
    std_flex_hilfe[0] = flex_ID_1_std
    std_flex_hilfe[1] = flex_ID_2_std
    std_flex_hilfe[2] = flex_ID_3_std
    std_flex_hilfe[3] = flex_ID_4_std
    std_flex_hilfe[4] = flex_ID_5_std
    std_flex_hilfe[5] = flex_ID_6_std
    std_flex_hilfe[6] = flex_ID_7_std
    std_flex_hilfe[7] = flex_ID_8_std
    std_flex_hilfe[8] = flex_ID_9_std
    std_flex_hilfe[9] = flex_ID_10_std
    std_flex_hilfe[10] = flex_ID_11_std
    std_flex_hilfe[11] = flex_ID_12_std
    std_flex_hilfe[12] = flex_ID_13_std

    std_flex = np.zeros(anzahl)

    for i in range (0, anzahl):
        for j in range (0, 13):
            if (list_hilfe_3[j]):
                std_flex[i] = std_flex_hilfe[j]
                list_hilfe_3[j] = False
                break

    #Erstellung des eines Arrays zur Aufzählung der Flexibilitäten
    list_hilfe_4 =[f_eins, f_zwei, f_drei, f_vier, f_fuenf, f_sechs, f_sieben, f_acht, f_neun, f_zehn, f_elf, f_zwoelf, f_dreizehn]
    aufzaehlung_flex_hilfe = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13])

    aufzaehlung_flex = np.zeros(anzahl, dtype=int)

    for i in range (0, anzahl):
        for j in range (0, 13):
            if (list_hilfe_4[j]):
                aufzaehlung_flex[i] = aufzaehlung_flex_hilfe[j]
                list_hilfe_4[j] = False
                break

    #Erstellung der Covarianz-Matrix
    cov_matrix =  covarianz_matrix(flex)

    #Berechnung der minimalen Varianz
    min_var_portfolio = varianzminimales_portfolio(erwartungswerte_flex, cov_matrix)

    gewichtungen_min_var_portfolio = min_var_portfolio[0]

    std_min_var_portfolio = min_var_portfolio [1]

    #Plotten des Portfolios (unspektakuläres Ergebnis, deshalb auskommentiert)
    #darstellung_der_simulationen(anzahl_random_portfolios=10000, erwartungswerte_flexibilitaeten=erwartungswerte_flex, cov_matrix=cov_matrix)

    #Plotten der ausgewählten Flexibilitaeten
    if (f_eins):
        plt.plot(flex_ID_1, label = 'Flexibilität 1')
    if (f_zwei):
        plt.plot(flex_ID_2, label = 'Flexibilität 2')
    if (f_drei):
        plt.plot(flex_ID_3, label = 'Flexibilität 3')
    if (f_vier):
        plt.plot(flex_ID_4, label = 'Flexibilität 4')
    if (f_fuenf):
        plt.plot(flex_ID_5, label = 'Flexibilität 5')
    if (f_sechs):
        plt.plot(flex_ID_6, label = 'Flexibilität 6')
    if (f_sieben):
        plt.plot(flex_ID_7, label = 'Flexibilität 7')
    if (f_acht):
        plt.plot(flex_ID_8, label = 'Flexibilität 8')
    if (f_neun):
        plt.plot(flex_ID_9, label = 'Flexibilität 9')
    if (f_zehn):
        plt.plot(flex_ID_10, label = 'Flexibilität 10')
    if (f_elf):
        plt.plot(flex_ID_11, label = 'Flexibilität 11')
    if (f_zwoelf):
        plt.plot(flex_ID_12, label = 'Flexibilität 12')
    if (f_dreizehn):
        plt.plot(flex_ID_13, label = 'Flexibilität 13')

    #Plotten der Flexibilitäten mit Beschriftungen, Vertragsauswahl, K-Wert,...
    plt.xticks(size=10)
    if (Vertrag):
        plt.ylabel('Cashflow FPIC-Vertrag [€]')
    else:
        plt.ylabel('Cashflow FSG-Vertrag [€]')
    plt.yticks(size = 10)
    plt.xlabel('simulierte Zeitreihe (1 Monat)')
    plt.legend(loc=4, prop={'size': 7})
    vertrag = 'FSG'
    if (Vertrag):
        vertrag = 'FPIC'
    title_plot = 'Vertrag: ' + vertrag + '; K-Wert: ' + str(K_Wert_Anteil *100) + ' %'
    plt.title(title_plot)

    #Ausgabe
    for i in range (anzahl):
        print("Anteil Flexibilitaet", aufzaehlung_flex[i], ":", np.around(gewichtungen_min_var_portfolio[i], 4)*100, "%")

    #Rückgabe der Gewichtungen und der Standardabweichung des varianzminimalen Portfolios, Aufzählung der ausgewählten Flexibilitäten und der Standardabweichungen der einzelnen Flexibilitäten
    return gewichtungen_min_var_portfolio, std_min_var_portfolio, aufzaehlung_flex, std_flex

if __name__ == "__main__":

    #HIER DIE GEWÜNSCHTN WERTE ÜBERGEBEN
    #"True" bei den einzelnen Flexibilitäten bedeutet, dass diese ausgewählt wurden, zudem muss ein K-Wert übergeben werden (NICHT als Prozentzahl sondern bsp. 100% = 1.0), beim Vertrag bedeutet "True" FPIC und "False" FSG
    gewichtungen_min_var_portfolio, std_min_var_portfolio, aufzaehlung_flex, std_flex = portfoliooptimierung(filename='Daten/Ergebnisse_Flexibilitaetenoptimierung.xlsx'f_eins=False, f_zwei=True, f_drei=True, f_vier=False, f_fuenf=True, f_sechs=False, f_sieben=True, f_acht=True, f_neun=False, f_zehn=True, f_elf=True, f_zwoelf=False ,f_dreizehn=True, K_Wert_Anteil=1.0, Vertrag=False)

    #Ausgabe der Ergebnisse
    print('Standardabweichung varianzminimales Portfolio', np.around(std_min_var_portfolio, 2))
    ausgabe_std = 'Standardabweichungen der einzelnen Flexibilitäten aus dem Portfolio:'
    for i in range (len(aufzaehlung_flex)):
        ausgabe_std += "\nStandardabweichung Flexibilität: " + str(aufzaehlung_flex[i]) + ": " + str(std_flex[i])
    print(ausgabe_std)