Optimum_Tracking.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f14d8eaf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "from scipy import special"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c911e68c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_expected_edges_p(n, p):\n",
    "    if n < 2:\n",
    "        raise ValueError(\"n muss größer als 1 sein!\")\n",
    "    if p < 0 or p > 1:\n",
    "        raise ValueError(\"p muss Wahrscheinlichkeit sein!\")\n",
    "    \n",
    "    return n-1 + p * ((n**2-3*n+2)/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "534a85c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_number_edge_combis(n, e):\n",
    "    s = 0\n",
    "    for i in range(n):\n",
    "        s += math.comb(e, i)\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d1add47b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "7\n",
      "42\n",
      "386\n",
      "4944\n",
      "82160\n",
      "1683218\n",
      "40999516\n",
      "1156626990\n"
     ]
    }
   ],
   "source": [
    "for i in [0,1,2,3,4,5,6,7,8,9,10]:\n",
    "    print(calc_number_edge_combis(i, math.comb(i,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "54616d6f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1156626990"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_number_edge_combis(10, math.comb(10,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0f27c411",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_optimum_tracking_files(p):\n",
    "    \"\"\"\n",
    "    p ist pfad zu einer simulation_x\n",
    "    \n",
    "    \"\"\"\n",
    "    pt = os.path.join(p, \"Tracking\")\n",
    "    pt_check = os.path.join(pt, \"check\")\n",
    "#     print(pt_opt)\n",
    "    \n",
    "    df = pd.DataFrame()\n",
    "    \n",
    "    df['loop_counter'] = np.loadtxt(os.path.join(pt, \"optimum_loop_counter.txt\"), dtype=int)\n",
    "    df['total[s]'] = np.loadtxt(os.path.join(pt, \"optimum.txt\"))\n",
    "    check = [np.loadtxt(os.path.join(pt_check, i)) for i in sorted(os.listdir(pt_check), key=lambda x: int(x.split(\".\")[0]))]\n",
    "    \n",
    "    sums = [sum(i) for i in check]\n",
    "    \n",
    "    df['sum_check[s]'] = sums\n",
    "#     d_f = {'counters': counters, 'setup_zeiten': setup, 'loop_zeiten': loop, 'total': total, 'opt': opt}\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d75cb5f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = r\"D:\\Uni\\Masterarbeit\\Daten\\Optimum_Tracking\\Optimum_TimeTest_FC_8_nodes_5_scenarios\\FullyConnected_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\"\n",
    "a = load_optimum_tracking_files(p1)\n",
    "a['anteil_check'] = a['sum_check[s]'] / a['total[s]']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "249fcb96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>loop_counter</th>\n",
       "      <th>total[s]</th>\n",
       "      <th>sum_check[s]</th>\n",
       "      <th>anteil_check</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [loop_counter, total[s], sum_check[s], anteil_check]\n",
       "Index: []"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# schonmal gut, dass dis sum_checks immer kleiner als die Gesamtlaufzeit ist\n",
    "a[a['total[s]'] < a['sum_check[s]']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8e82f392",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "loop_counter    4489.026000\n",
       "total[s]           0.175228\n",
       "sum_check[s]       0.073295\n",
       "anteil_check       0.407823\n",
       "dtype: float64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "92019c59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9973330691568175"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 - (a.mean().loop_counter / calc_number_edge_combis(8, math.comb(8,2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12b928ed",
   "metadata": {},
   "source": [
    "# Auswertung\n",
    "Es ist so, dass hier, wenn ich einen Graph FC mit 8 Knoten nehme, dann im Schnitt 4489 (+1 wegen keine 1. stage Kanten) mal eine Kantenkombination checken muss. Das bedeutet, dass ich hier schon im mittel 99,73% aller möglichen Kombinationen abschneide."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "342153b4",
   "metadata": {},
   "source": [
    "### jetzt das TreePlusP pendant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1d21d3a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28.0\n",
      "28\n"
     ]
    }
   ],
   "source": [
    "# soviele Kanten hab ich wenn bei 8 Knoten FC:\n",
    "print(calc_expected_edges_p(8, 1))\n",
    "print(math.comb(8,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "23f543e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.00008"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_expected_edges_p(10, 0.52778)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51bc4edc",
   "metadata": {},
   "source": [
    "Wenn ich 10 Knoten nehme und ein p von 0.52778, dann hab ich im Schnitt fast genau 28 Kanten, also genauso viele, wie im FC Fall.\n",
    "\n",
    "## Überlegung:\n",
    "Es ist aber so, dass ein Run mit 30 Kanten prozentual deutlich länger als ein 28 Kanten run dauert, als ein 26 Kanten run einspart. Das liegt daran, dass das Problem mit höherer Kantenzahl exponentiell schwerer wird, also kann man das so gar nicht vergleichen. Nur weil ich im Mittel die selbe Kantenanzahl habe, heißt das noch nicht, dass ich auch die selbe Laufzeit erwarte. Von diesem Run müsste ich eher alle runs mit genau 28 Kanten rausfiltern und nur für die vergleichen und da sollte aber dann das selbe rauskommen (stimmt auch nicht, siehe unten)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "22d54ea3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#lese die Ergebnisse ein und mache bool_mask wo nur die true sind, die genau 28 Kanten haben"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4a90cead",
   "metadata": {},
   "outputs": [],
   "source": [
    "# die Optimums maps einlesen\n",
    "def readLGF_Network(source):\n",
    "    mInFile = open(source, mode='r')\n",
    "    fileString = mInFile.read()\n",
    "    mInFile.close()\n",
    "    if '@arcs' in fileString:\n",
    "        initKey = '@arcs'\n",
    "        initPos = 6\n",
    "    elif '@edges' in fileString:\n",
    "        initKey = '@edges'\n",
    "        initPos = 7\n",
    "    else:\n",
    "        print('No keyword \\'@arcs\\' or \\'@edges\\' found\\n Wrong file format')\n",
    "        return\n",
    "    strDat = fileString[fileString.find(initKey)+initPos:].split(\"\\n\", 1)[1]\n",
    "    \n",
    "    df = pd.DataFrame(columns=['u', 'v', 'id', 'first_stage'])\n",
    "    \n",
    "    for row in strDat.split('\\n')[:-1]:\n",
    "        s = row.split(\"\\t\")\n",
    "        df = pd.concat([df,  pd.DataFrame({'u': int(s[0]), 'v': int(s[1]), 'id': int(s[2]), 'first_stage': int(s[3])}, index=[0])], ignore_index=True)\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "d6092d65",
   "metadata": {},
   "outputs": [],
   "source": [
    "path_pendant = r\"D:\\Uni\\Masterarbeit\\Daten\\Optimum_Tracking\\Optimum_TimeTest_FC_pendant_10_nodes_5_scenarios\\TreePlusP_0.527780_p_10_nodes_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\\Optimum\"\n",
    "number_edges = [readLGF_Network(os.path.join(path_pendant, i)).shape[0] for i in sorted(os.listdir(path_pendant), key=lambda x: int(x.split(\".\")[0]))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "6ebd790b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>loop_counter</th>\n",
       "      <th>total[s]</th>\n",
       "      <th>sum_check[s]</th>\n",
       "      <th>num_edges</th>\n",
       "      <th>anteil_check</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5955</td>\n",
       "      <td>0.251635</td>\n",
       "      <td>0.097666</td>\n",
       "      <td>29</td>\n",
       "      <td>0.388126</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>18523</td>\n",
       "      <td>0.629330</td>\n",
       "      <td>0.227317</td>\n",
       "      <td>30</td>\n",
       "      <td>0.361204</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>20960</td>\n",
       "      <td>0.712488</td>\n",
       "      <td>0.285068</td>\n",
       "      <td>32</td>\n",
       "      <td>0.400102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3207</td>\n",
       "      <td>0.116902</td>\n",
       "      <td>0.045768</td>\n",
       "      <td>30</td>\n",
       "      <td>0.391510</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>65982</td>\n",
       "      <td>3.883070</td>\n",
       "      <td>2.453197</td>\n",
       "      <td>32</td>\n",
       "      <td>0.631767</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>495</th>\n",
       "      <td>29524</td>\n",
       "      <td>1.334450</td>\n",
       "      <td>0.711461</td>\n",
       "      <td>24</td>\n",
       "      <td>0.533149</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>496</th>\n",
       "      <td>24179</td>\n",
       "      <td>0.936134</td>\n",
       "      <td>0.424877</td>\n",
       "      <td>26</td>\n",
       "      <td>0.453864</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>497</th>\n",
       "      <td>36876</td>\n",
       "      <td>1.406450</td>\n",
       "      <td>0.649360</td>\n",
       "      <td>31</td>\n",
       "      <td>0.461701</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>498</th>\n",
       "      <td>13510</td>\n",
       "      <td>0.684186</td>\n",
       "      <td>0.393363</td>\n",
       "      <td>28</td>\n",
       "      <td>0.574935</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>499</th>\n",
       "      <td>3428</td>\n",
       "      <td>0.163783</td>\n",
       "      <td>0.082056</td>\n",
       "      <td>29</td>\n",
       "      <td>0.501002</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>500 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     loop_counter  total[s]  sum_check[s]  num_edges  anteil_check\n",
       "0            5955  0.251635      0.097666         29      0.388126\n",
       "1           18523  0.629330      0.227317         30      0.361204\n",
       "2           20960  0.712488      0.285068         32      0.400102\n",
       "3            3207  0.116902      0.045768         30      0.391510\n",
       "4           65982  3.883070      2.453197         32      0.631767\n",
       "..            ...       ...           ...        ...           ...\n",
       "495         29524  1.334450      0.711461         24      0.533149\n",
       "496         24179  0.936134      0.424877         26      0.453864\n",
       "497         36876  1.406450      0.649360         31      0.461701\n",
       "498         13510  0.684186      0.393363         28      0.574935\n",
       "499          3428  0.163783      0.082056         29      0.501002\n",
       "\n",
       "[500 rows x 5 columns]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# jetzt die tracking daten einlesen und die number_edges als neue Spalte reinpacken\n",
    "b = load_optimum_tracking_files(r\"D:\\Uni\\Masterarbeit\\Daten\\Optimum_Tracking\\Optimum_TimeTest_FC_pendant_10_nodes_5_scenarios\\TreePlusP_0.527780_p_10_nodes_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\")\n",
    "b['num_edges'] = number_edges \n",
    "b['anteil_check'] = b['sum_check[s]'] / b['total[s]']\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "3693233b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "loop_counter    34757.000000\n",
       "total[s]            1.457896\n",
       "sum_check[s]        0.727438\n",
       "num_edges          28.000000\n",
       "anteil_check        0.501203\n",
       "dtype: float64"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b_28_sub = b[b['num_edges']==28]\n",
    "b_28_sub.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1e0941e",
   "metadata": {},
   "source": [
    "# Auswertung\n",
    "Es ist so, dass hier, obwohl die Anzahl der Edges gleich ist, deutlich mehr Kombinationen angeschaut werden müssen und außerdem sind die optimalen Lösungen im Durchschnitt für das 'Pendant' teurer, nämlich 11.16, wohingegen, der Wert bei FC bei ca. 6.3 liegt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "c7bf9fa1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Optimum      11.16035\n",
       "num_edges    28.00000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt_p10 = pd.read_csv(os.path.join(r\"D:\\Uni\\Masterarbeit\\Daten\\Optimum_Tracking\\Optimum_TimeTest_FC_pendant_10_nodes_5_scenarios\\TreePlusP_0.527780_p_10_nodes_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\", \"results.txt\"), header=0, usecols=['Optimum'])\n",
    "opt_p10['num_edges'] = np.loadtxt(os.path.join(r\"D:\\Uni\\Masterarbeit\\Daten\\Optimum_Tracking\\Optimum_TimeTest_FC_pendant_10_nodes_5_scenarios\\TreePlusP_0.527780_p_10_nodes_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\", \"edges_count.txt\"), dtype=int)\n",
    "(opt_p10[opt_p10['num_edges']==28]).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "c49f1759",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Optimum    6.29655\n",
       "dtype: float64"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt_fc8 = pd.read_csv(os.path.join(r\"D:\\Uni\\Masterarbeit\\Daten\\Optimum_Tracking\\Optimum_TimeTest_FC_8_nodes_5_scenarios\\FullyConnected_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\", \"results.txt\"), header=0, usecols=['Optimum'])\n",
    "opt_fc8.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "a560cc1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.949915578374281"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(math.comb(28,8) + math.comb(28,9)) / calc_number_edge_combis(8, 28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "b844c72d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.949915578374281"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_number_edge_combis(10,28) / calc_number_edge_combis(8,28)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6e49592",
   "metadata": {},
   "source": [
    "Es kommen über 5x soviele neue Kombinationen dazu, als es bei 8 FC insgesamt gibt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "d5466c16",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.319988296266576"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b_28_sub.mean()['total[s]'] / a.mean()['total[s]'] "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb4cc35e",
   "metadata": {},
   "source": [
    "Wenn ich 10 Kantengraph mit 28 Kanten nehme, dann dauert eine Optimierung mehr als 8x so lange, wie bei 8 Knoten FC, also mit 28 Kanten. Da es 7x so viele Kombinationen zu überprüfen gibt, muss es aber noch einen anderen (kleinen) Teil des Algorithmus geben, der etwas länger braucht oder (also extra skaliert, vllt Kruskal?)? Weil eigentlich würde ich erwarten, dass der Algorithmus mit der Anzahl an Kantenkombinationen skaliert. Die Größenordnung ist zwar die selbe, aber trotzdem, will ich **das noch genauer untersuchen!!!**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d80a85ef",
   "metadata": {},
   "source": [
    "Das liegt denke ich daran, dass ich bei FC weniger Kanten für einen Spannbaum brauche. Wenn ich 10 Knoten habe, dann brauche ich 9 Kanten für den Spannbaum und nicht nur 7. Da kommen nochmal 10Mio mögliche Kombinationen dazu. Die Problemstellung ist einfach eine andere. Prozentual gesehen, werden ungefähr gleich viele Kombinationen weggeschnitten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "30ddc040",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.997028864982314"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# halt: ich brauche ja auch mehr Kanten für einen Spannbaum\n",
    "1-(b_28_sub.mean().loop_counter / calc_number_edge_combis(10, 28))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3daf2a0",
   "metadata": {},
   "source": [
    "# Jetzt meine aktuelle Verbesserung\n",
    "Da will ich jetzt wissen, wie sehr verbessert das nochmal die Laufzeit (in Kombination mit der bisherigen Optimierung). Ich muss also verschiedene Problemstellungen simulieren und zwar einmal mit dem alten bruteforce Algorithmus und einmal mit dem neuen. Am besten über die exakt selben Problemstellungen, damit ich wirklich einen Unterschied bei den selben Bedingungen sehen kann."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f228065",
   "metadata": {},
   "source": [
    "Außerdem will ich den obigen Test für den LP-Alg. wiederholen. Also schauen, ob der LP-Alg. auch für FC schneller ist, als für TreePlusP mit der selben Kantenanzahl wie der FC Graph."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c63b3485",
   "metadata": {},
   "source": [
    "Und ich will nach der Optimierung vom optimalen Alg timen, wie die Zeitunterschied zwischen LP-Approx und Optimalem Alg ist."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63093aad",
   "metadata": {},
   "source": [
    "### Zuerst schauen, ob die selben Ergebnisse rauskommen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4d01cf7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_files(konfig_path):\n",
    "    \"\"\"\n",
    "    Ist dafuer da, fuer eine Konfiguration alle Simulationen einzulesen und in ein Dataframe zu packen\n",
    "    \"\"\"\n",
    "    \n",
    "    # muss erstmal rausfinden, welche Simulationen alle gemacht wurden\n",
    "    sims = os.listdir(konfig_path)\n",
    "#     print(sims)\n",
    "\n",
    "    # erstes Dataframe, an das dann angebaut wird\n",
    "    df = pd.read_csv(os.path.join(konfig_path, sims[0], \"results.txt\")).iloc[:,:-1]\n",
    "    \n",
    "    for sim in sims[1:]:\n",
    "#         print(sim)\n",
    "#         # nehme nur alle Ordner und keine Datein\n",
    "#         for alg in [a for a in os.listdir(os.path.join(dir_path, sim)) if not \".\" in a]:\n",
    "#             print(alg)\n",
    "\n",
    "        # nehme die results und packe sie an df dran\n",
    "        df_sim = pd.read_csv(os.path.join(konfig_path, sim, \"results.txt\")).iloc[:,:-1]\n",
    "        # dabei gehe ich aus, dass selbst, wenn die results in unterschiedlichen Spalten gespeichert werden, dass\n",
    "        # die an die dazugehoerige, bereits vorhandene Spalte angegliedert werden\n",
    "        df = pd.concat([df, df_sim], ignore_index=True)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "3424595d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Optimum</th>\n",
       "      <th>Optimum2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [Optimum, Optimum2]\n",
       "Index: []"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ovo_res = read_files(r\"D:\\Uni\\Masterarbeit\\Daten\\optimum_vs_optimum\\OptimumVSOptimum8_nodes_5_scenarios\\FullyConnected_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\")\n",
    "ovo_res[ovo_res[\"Optimum\"]!=ovo_res['Optimum2']]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d8b2a5b",
   "metadata": {},
   "source": [
    "Es kommt also immer das selbe raus. Das ist schon mal sehr gut. **Jetzt will ich die Laufzeiten und Anzahl an gecheckten Edge-Kombinationen vergleichen**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "148b7600",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_ovo_tracking_files(p):\n",
    "    \"\"\"\n",
    "    p ist pfad zu einer simulation_x\n",
    "    \n",
    "    \"\"\"\n",
    "    pt = os.path.join(p, \"Tracking\")\n",
    "    pt_check = os.path.join(pt, \"check\")\n",
    "    pt_check_neu = os.path.join(pt, \"check2\")\n",
    "#     print(pt_opt)\n",
    "    \n",
    "    df_alt = pd.DataFrame()\n",
    "    \n",
    "    df_alt['loop_counter'] = np.loadtxt(os.path.join(pt, \"optimum_loop_counter.txt\"), dtype=int)\n",
    "    df_alt['total[s]'] = np.loadtxt(os.path.join(pt, \"optimum.txt\"))\n",
    "    check_alt = [np.loadtxt(os.path.join(pt_check, i)) for i in sorted(os.listdir(pt_check), key=lambda x: int(x.split(\".\")[0]))]\n",
    "    \n",
    "    sums_alt = [sum(i) for i in check_alt]\n",
    "    \n",
    "    df_alt['sum_check[s]'] = sums_alt\n",
    "#     d_f = {'counters': counters, 'setup_zeiten': setup, 'loop_zeiten': loop, 'total': total, 'opt': opt}\n",
    "    \n",
    "    df_neu = pd.DataFrame()\n",
    "    \n",
    "    df_neu['loop_counter'] = np.loadtxt(os.path.join(pt, \"optimum_loop_counter2.txt\"), dtype=int)\n",
    "    df_neu['total[s]'] = np.loadtxt(os.path.join(pt, \"optimum2.txt\"))\n",
    "    check_neu = [np.loadtxt(os.path.join(pt_check_neu, i)) for i in sorted(os.listdir(pt_check_neu), key=lambda x: int(x.split(\".\")[0]))]\n",
    "    \n",
    "    sums_neu = [sum(i) for i in check_neu]\n",
    "    \n",
    "    df_neu['sum_check[s]'] = sums_neu\n",
    "    \n",
    "    return df_alt, df_neu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "8109fe4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_alt, df_neu = load_ovo_tracking_files(r\"D:\\Uni\\Masterarbeit\\Daten\\optimum_vs_optimum\\OptimumVSOptimum8_nodes_5_scenarios\\FullyConnected_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "731b8ef4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "loop_counter    4329.782000\n",
       "total[s]           0.229405\n",
       "sum_check[s]       0.083641\n",
       "anteil_check       0.340399\n",
       "dtype: float64"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_alt['anteil_check'] = df_alt['sum_check[s]'] / df_alt['total[s]']\n",
    "df_neu['anteil_check'] = df_neu['sum_check[s]'] / df_neu['total[s]']\n",
    "df_alt.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "5684833f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "loop_counter    1547.486000\n",
       "total[s]           0.143267\n",
       "sum_check[s]       0.062309\n",
       "anteil_check       0.428800\n",
       "dtype: float64"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_neu.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "35256ed6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9990806383962149"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 - (df_neu.mean().loop_counter / calc_number_edge_combis(8, 28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "1f30da23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.comb(4,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "644bfbfb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_number_edge_combis(4, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48d2f4df",
   "metadata": {},
   "source": [
    "## Jetzt 11 Knoten FC\n",
    "Das Einlesen der Daten dauert ewig (wegen check, weil ich so viele Iterationen habe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bd917fbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_alt11, df_neu11 = load_ovo_tracking_files(r\"D:\\Uni\\Masterarbeit\\Daten\\optimum_vs_optimum\\OptimumVSOptimum11_nodes_5_scenarios\\FullyConnected_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "933c6a84",
   "metadata": {},
   "source": [
    "Wie viele moeglichen Erstphasenselektionen gibt es?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e2dfbe9",
   "metadata": {},
   "source": [
    "Hab hier 500 runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "ff1e7c3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "dfe11 = pd.DataFrame()\n",
    "dfe11['loop_counter'] = np.loadtxt(os.path.join(r'D:\\Uni\\Masterarbeit\\Daten\\optimum_vs_optimum\\OptimumVSOptimum11_nodes_5_scenarios', \"optimum_loop_counter2.txt\"), dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "e39ee60d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99.99981871542896"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 - dfe11['loop_counter'] / calc_number_edge_combis(11, math.comb(11,2))).mean() * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "e04a91c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99.99981876782643"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 - df11c['loop_counter'] / calc_number_edge_combis(11, math.comb(11,2))).mean() * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "beeffc9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "df11c = pd.concat([df_neu11, dfe11], ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "85dfcfc8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0002213741879099331"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((1-(df11c['loop_counter'] / calc_number_edge_combis(11, math.comb(11,2))))*100).std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "8e807fb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100.00004014201434"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "99.99981876782643 + 0.0002213741879099331"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bd3ba72",
   "metadata": {},
   "source": [
    "99.9998(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a7e539ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "105"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.comb(15,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a58a82f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "37060382822"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_number_edge_combis_edge_combis(11, math.comb(11,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "2e422267",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "loop_counter    180573.592000\n",
       "total[s]             8.933071\n",
       "sum_check[s]         4.110229\n",
       "anteil_check         0.447276\n",
       "dtype: float64"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_alt11['anteil_check'] = df_alt11['sum_check[s]'] / df_alt11['total[s]']\n",
    "df_neu11['anteil_check'] = df_neu11['sum_check[s]'] / df_neu11['total[s]']\n",
    "df_alt11.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "bf502cb1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "loop_counter    67126.500000\n",
       "total[s]            5.137850\n",
       "sum_check[s]        3.215376\n",
       "anteil_check        0.616012\n",
       "dtype: float64"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_neu11.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "274a73c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99.9995127584276"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 - (df_alt11.mean().loop_counter / calc_number_edge_combis(11, math.comb(11,2)))) * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "10aa01a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99.99981887262113"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 - (df_neu11.mean().loop_counter / calc_number_edge_combis(11, math.comb(11,2)))) * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "03cb8a6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4248506211656029"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(df_alt11.mean()['total[s]'] - df_neu11.mean()['total[s]']) / df_alt11.mean()['total[s]']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4482ced9",
   "metadata": {},
   "source": [
    "Ok, beide Versionen schneiden einen sehr großen Anteil an Kantenkombinationen weg und die neue Version ist nochmal besser und braucht 43% weniger Zeit, als die bisherige Version. Das ist schon echt nicht schlecht. So kann ich dieses Problem mit 11 Knoten Fc, also 55 Kanten mit 5 Szenarien und random Kosten zwischen 0 und 10 in etwas über 5s lösen. Außerdem geht ein deutlich größerer Teil der Gesamtlaufzeit bei der optimierten Version für die check-Aufrufe drauf. Das bedeutet, dass ich bei dieser Version weniger Zeit außerhalb dieser Aufrufe verbringe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "f1b02544",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "105"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.comb(15,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21f6aaa5",
   "metadata": {},
   "source": [
    "Jetzt mit 15 Knoten, aber da sind die check_Ordner so groß geworden, dass ich sie weglasse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "83f906fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_ovo_tracking_files_no_check(p):\n",
    "    \"\"\"\n",
    "    p ist pfad zu einer simulation_x\n",
    "    \n",
    "    \"\"\"\n",
    "    pt = os.path.join(p, \"Tracking\")\n",
    "\n",
    "#     print(pt_opt)\n",
    "    \n",
    "    df_alt = pd.DataFrame()\n",
    "    \n",
    "    df_alt['loop_counter'] = np.loadtxt(os.path.join(pt, \"optimum_loop_counter.txt\"), dtype=int)\n",
    "    df_alt['total[s]'] = np.loadtxt(os.path.join(pt, \"optimum.txt\"))\n",
    "#     check_alt = [np.loadtxt(os.path.join(pt_check, i)) for i in sorted(os.listdir(pt_check), key=lambda x: int(x.split(\".\")[0]))]\n",
    "    \n",
    "#     sums_alt = [sum(i) for i in check_alt]\n",
    "    \n",
    "#     df_alt['sum_check[s]'] = sums_alt\n",
    "#     d_f = {'counters': counters, 'setup_zeiten': setup, 'loop_zeiten': loop, 'total': total, 'opt': opt}\n",
    "    \n",
    "    df_neu = pd.DataFrame()\n",
    "    \n",
    "    df_neu['loop_counter'] = np.loadtxt(os.path.join(pt, \"optimum_loop_counter2.txt\"), dtype=int)\n",
    "    df_neu['total[s]'] = np.loadtxt(os.path.join(pt, \"optimum2.txt\"))\n",
    "#     check_neu = [np.loadtxt(os.path.join(pt_check_neu, i)) for i in sorted(os.listdir(pt_check_neu), key=lambda x: int(x.split(\".\")[0]))]\n",
    "    \n",
    "#     sums_neu = [sum(i) for i in check_neu]\n",
    "    \n",
    "#     df_neu['sum_check[s]'] = sums_neu\n",
    "    \n",
    "    return df_alt, df_neu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "88aa6523",
   "metadata": {},
   "outputs": [],
   "source": [
    "dfe15 = pd.DataFrame()\n",
    "dfe15['loop_counter'] = np.loadtxt(os.path.join(r'D:\\Uni\\Masterarbeit\\Daten\\optimum_vs_optimum\\OptimumVSOptimum15_nodes_5_scenarios', \"optimum_loop_counter2.txt\"), dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "96f81b94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "loop_counter    1.912509e+07\n",
       "total[s]        9.915773e+02\n",
       "dtype: float64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_alt15, df_neu15 = load_ovo_tracking_files_no_check(r\"D:\\Uni\\Masterarbeit\\Daten\\optimum_vs_optimum\\OptimumVSOptimum15_nodes_5_scenarios\\FullyConnected_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\")\n",
    "df_alt15.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f6531576",
   "metadata": {},
   "outputs": [],
   "source": [
    "df15c = pd.concat([df_neu15, dfe15], ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "609bd599",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99.99999999208256"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 - df15c['loop_counter'] / calc_number_edge_combis(15, math.comb(15,2))).mean() * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7c9fff80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0770157896818393e-08"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((1-(df15c['loop_counter'] / calc_number_edge_combis(15, math.comb(15,2))))*100).std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "af7e7efd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1e-08"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.00000001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6d4bef80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.467179534567478e-09"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((1-(df_neu15['loop_counter'] / calc_number_edge_combis(15, math.comb(15,2))))*100).std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "763b5a46",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7e-09"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.000000007"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "65509f9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.6104211005672577"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_alt15.mean().loop_counter / df_neu15.mean().loop_counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "cf929c14",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99.99999998228229"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 - (df_alt15.mean().loop_counter / calc_number_edge_combis(15, math.comb(15,2)))) * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "2727f4ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99.9999999932127"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 - (df_neu15.mean().loop_counter / calc_number_edge_combis(15, math.comb(15,2)))) * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "e1ae65ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100.00000000067988"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "99.9999999932127 + 7.467179534567478e-09"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "8c8fd30b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3578855558287901"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(df_alt15.mean()['total[s]'] - df_neu15.mean()['total[s]']) / df_alt15.mean()['total[s]']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c82f1c6",
   "metadata": {},
   "source": [
    "Es ist anscheinend so, dass ich je mehr Möglichkeiten es gibt, auch prozentual gesehen immer mehr davon wegschneide, das geht auch exponentiell, schafft es aber nicht das einzuholen. Der Check_Zeit anteil ist vllt. doch interessant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "6facf555",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_long_check_files(p_check_neu, p_save):\n",
    "    # ist gedacht zum nur 1x ausfuehren\n",
    "    \n",
    "#     sums_alt = []\n",
    "    sums_neu = []\n",
    "    \n",
    "#     for f1 in os.listdir(p_check_alt):\n",
    "#         a = np.loadtxt(os.path.join(p_check_alt, f1))\n",
    "#         sums_alt.append(a.sum())\n",
    "    for f2 in os.listdir(p_check_neu):\n",
    "        a = np.loadtxt(os.path.join(p_check_neu, f2))\n",
    "        sums_neu.append(a.sum())\n",
    "    \n",
    "    # speichern und returnen\n",
    "#     np.savetxt(os.path.join(p_save, \"summe_alt_s.txt\"), sums_alt)\n",
    "    np.savetxt(os.path.join(p_save, \"summe_neu_s.txt\"), sums_neu)\n",
    "    \n",
    "    return sums_neu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "f471f4a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "p_check_alt = r\"\\\\?\\D:\\Uni\\Masterarbeit\\Daten\\optimum_vs_optimum\\OptimumVSOptimum15_nodes_5_scenarios\\FullyConnected_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\\OptimumVSOptimum15_nodes_5_scenarios\\FullyConnected_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\\Tracking\\check\"\n",
    "p_check_neu = r\"\\\\?\\D:\\Uni\\Masterarbeit\\Daten\\optimum_vs_optimum\\OptimumVSOptimum15_nodes_5_scenarios\\FullyConnected_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\\OptimumVSOptimum15_nodes_5_scenarios\\FullyConnected_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\\Tracking\\check2\"\n",
    "p_save = r\"D:\\Uni\\Masterarbeit\\Daten\\optimum_vs_optimum\\OptimumVSOptimum15_nodes_5_scenarios\\FullyConnected_5_RandomScenarioCreator_RandomTestCreator_0.000000_10.000000\\simulation_0\\Tracking\"\n",
    "sn = read_long_check_files(p_check_neu, p_save)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "id": "e280bff3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# muss die listen sa und sn umsortieren\n",
    "arr = list(np.arange(50))\n",
    "arra=list(np.arange(51))\n",
    "iis = [pair[0] for pair in sorted(zip(arr, os.listdir(p_check_neu)), key=lambda n: int(n[1].split(\".\")[0]))]\n",
    "iisa = [pair[0] for pair in sorted(zip(arra, os.listdir(p_check_alt)), key=lambda n: int(n[1].split(\".\")[0]))]\n",
    "# iisa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "id": "aa2f7b6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_alt15['sum_check[s]'] = (np.array(sa)[iisa])[:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "05099cd7",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_neu15['sum_check[s]'] = np.array(sn)[iis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "id": "e3472cfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# so, jetzt die Verhaeltnisse ausrechnen\n",
    "df_alt15['anteil_check'] = df_alt15['sum_check[s]'] / df_alt15['total[s]']\n",
    "df_neu15['anteil_check'] = df_neu15['sum_check[s]'] / df_neu15['total[s]']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "id": "863bfa5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5644053556522841\n",
      "0.7177991458369624\n"
     ]
    }
   ],
   "source": [
    "print(df_alt15.mean().anteil_check)\n",
    "print(df_neu15.mean().anteil_check)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7fc12aa6",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}