{ "cells": [ { "cell_type": "markdown", "id": "cfa9d168", "metadata": {}, "source": [ "# Illustrative examples of MCDA methods: CRADIS, COPRAS, ARAS, MARCOS, PROMETHEE II, PROSA-C, SAW, AHP" ] }, { "cell_type": "markdown", "id": "ee58c188", "metadata": {}, "source": [ "## Import necessary packages" ] }, { "cell_type": "markdown", "id": "603f0510", "metadata": {}, "source": [ "Import of the necessary Python packages necessary for running codes provided in examples." ] }, { "cell_type": "code", "execution_count": 1, "id": "e8a38427", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "import pandas as pd\n", "import matplotlib" ] }, { "cell_type": "markdown", "id": "35c770dc", "metadata": {}, "source": [ "Import the necessary Python modules from `pyrepo-mcda` package." ] }, { "cell_type": "code", "execution_count": 2, "id": "2b163d03", "metadata": {}, "outputs": [], "source": [ "from pyrepo_mcda.mcda_methods import CRADIS, AHP, MARCOS, SAW, ARAS, COPRAS, PROMETHEE_II, PROSA_C\n", "from pyrepo_mcda.mcda_methods import TOPSIS, VIKOR, MABAC, EDAS, SPOTIS, WASPAS\n", "\n", "from pyrepo_mcda import normalizations as norms\n", "from pyrepo_mcda.additions import rank_preferences\n", "from pyrepo_mcda import correlations as corrs\n", "from pyrepo_mcda import weighting_methods as mcda_weights" ] }, { "cell_type": "markdown", "id": "4d39c123", "metadata": {}, "source": [ "Supporting function for running provided examples including visualization. Here are functions called `plot_barplot` for displaying bar chart showing rankings and `draw_heatmap` for displaying heat map with rankings correlations. You can copy and customize their codes to your case. Class `Create_dictionary` helps create a correlation matrix to show rankings correlations." ] }, { "cell_type": "code", "execution_count": 3, "id": "cfd30928", "metadata": {}, "outputs": [], "source": [ "# bar (column) chart\n", "def plot_barplot(df_plot, legend_title, num):\n", " \"\"\"\n", " Visualization method to display column chart of alternatives rankings obtained with \n", " different methods.\n", "\n", " Parameters\n", " ----------\n", " df_plot : DataFrame\n", " DataFrame containing rankings of alternatives obtained with different methods.\n", " The particular rankings are included in subsequent columns of DataFrame.\n", " title : str\n", " Title of the legend (Name of group of explored methods, for example MCDA methods or Distance metrics).\n", " \n", " Examples\n", " ----------\n", " >>> plot_barplot(df_plot, legend_title='MCDA methods')\n", " \"\"\"\n", " step = 1\n", " list_rank = np.arange(1, len(df_plot) + 1, step)\n", "\n", " ax = df_plot.plot(kind='bar', width = 0.8, stacked=False, edgecolor = 'black', figsize = (9,4))\n", " ax.set_xlabel('Alternatives', fontsize = 12)\n", " ax.set_ylabel('Rank', fontsize = 12)\n", " ax.set_yticks(list_rank)\n", "\n", " ax.set_xticklabels(df_plot.index, rotation = 'horizontal')\n", " ax.tick_params(axis = 'both', labelsize = 12)\n", " y_ticks = ax.yaxis.get_major_ticks()\n", " ax.set_ylim(0, len(df_plot) + 1)\n", "\n", " plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc='lower left',\n", " ncol=4, mode=\"expand\", borderaxespad=0., edgecolor = 'black', title = legend_title, fontsize = 12)\n", "\n", " ax.grid(True, linestyle = ':')\n", " ax.set_axisbelow(True)\n", " plt.tight_layout()\n", " legend_title = legend_title.replace(\"$\", \"\")\n", " plt.savefig('./results/' + 'bar_chart_' + legend_title + str(num) + '.eps')\n", " plt.savefig('./results/' + 'bar_chart_' + legend_title + str(num) + '.png')\n", " plt.show()\n", "\n", "\n", "# heat maps with correlations\n", "def draw_heatmap(df_new_heatmap, title, num):\n", " \"\"\"\n", " Visualization method to display heatmap with correlations of compared rankings generated using different methods\n", " \n", " Parameters\n", " ----------\n", " data : DataFrame\n", " DataFrame with correlation values between compared rankings\n", " title : str\n", " title of chart containing name of used correlation coefficient\n", " \n", " Examples\n", " ---------\n", " >>> draw_heatmap(df_new_heatmap, title)\n", " \"\"\"\n", " plt.figure(figsize = (8, 5))\n", " sns.set(font_scale = 1.2)\n", " heatmap = sns.heatmap(df_new_heatmap, annot=True, fmt=\".3f\", cmap=\"RdYlGn\",\n", " linewidth=0.5, linecolor='w')\n", " plt.yticks(va=\"center\")\n", " plt.xlabel('MCDA methods')\n", " plt.title('Correlation: ' + title)\n", " plt.tight_layout()\n", " title = title.replace(\"$\", \"\")\n", " plt.savefig('./results/' + 'correlations_' + title + str(num) + '.eps')\n", " plt.savefig('./results/' + 'correlations_' + title + str(num) + '.png')\n", " plt.show()\n", " \n", "# Create dictionary class\n", "class Create_dictionary(dict):\n", " \n", " # __init__ function\n", " def __init__(self):\n", " self = dict()\n", " \n", " # Function to add key:value\n", " def add(self, key, value):\n", " self[key] = value" ] }, { "cell_type": "markdown", "id": "b0b08c35", "metadata": {}, "source": [ "An example decision problem involves selecting the best alternative for the location of an offshore wind farm based on Ziemba, P., Wątróbski, J., Zioło, M., & Karczmarczyk, A. (2017). Using the PROSA method in offshore wind farm location problems. Energies, 10(11), 1755. DOI: https://doi.org/10.3390/en10111755. \n", "The problem includes four alternatives evaluated against twelve criteria. The evaluation criteria are displayed below. Preference direction `Max` denotes profit criteria with maximization aim, and `Min` represents cost criteria with minimalization aim.\n", "\n", "In this case, the preference function V-shape for PROMETHEE II and PROSA-C was selected, which means that there is required a vector `p` (Preference Threshold) with values of the threshold of absolute preference, above which there is a total preference for one of the two actions and assigning the preference degree the value of 1.\n", "\n", "More detailed information about preference functions, preference and indifference thresholds are available in reference paper:\n", "\n", "Papathanasiou, J., & Ploskas, N. (2018). Promethee. In Multiple Criteria Decision Aid (pp. 57-89). Springer, Cham. DOI: https://doi.org/10.1007/978-3-319-91648-4_3" ] }, { "cell_type": "code", "execution_count": 4, "id": "d04ac6bc", "metadata": {}, "outputs": [], "source": [ "crits = pd.read_csv('example1criteria.csv', index_col = 'Cj')" ] }, { "cell_type": "code", "execution_count": 5, "id": "43b9fc04", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Criterion NameUnit of MeasurementPreference DirectionWeight of CriterionPreference function for PROMETHEE II and PROSA-CPreference Threshold (p) for PROMETHEE II and PROSA-C
Cj
C1Investment costmln PLNMin20.00V-shape7280.0
C2Payback periodyearsMin5.00V-shape4.0
C3Distance from power stationskmMin5.00V-shape13.4
C4Mean sea water depthmMin1.67V-shape7.4
C5Undersea geological conditionpointsMin1.67V-shape3.0
C6EmploymentnumberMax11.67V-shape1662.0
C7Conflict with fisheriespointsMin11.67V-shape3.0
C8Density of shipping trafficpointsMin5.00V-shape3.0
C9Distance from shorekmMax5.00V-shape13.8
C10Influence on protected areaspointsMin16.67V-shape3.0
C11CO2 reductiontonnesMax8.33V-shape766240.0
C12SO2 reductiontonnesMax8.33V-shape17820.0
\n", "
" ], "text/plain": [ " Criterion Name Unit of Measurement Preference Direction \\\n", "Cj \n", "C1 Investment cost mln PLN Min \n", "C2 Payback period years Min \n", "C3 Distance from power stations km Min \n", "C4 Mean sea water depth m Min \n", "C5 Undersea geological condition points Min \n", "C6 Employment number Max \n", "C7 Conflict with fisheries points Min \n", "C8 Density of shipping traffic points Min \n", "C9 Distance from shore km Max \n", "C10 Influence on protected areas points Min \n", "C11 CO2 reduction tonnes Max \n", "C12 SO2 reduction tonnes Max \n", "\n", " Weight of Criterion Preference function for PROMETHEE II and PROSA-C \\\n", "Cj \n", "C1 20.00 V-shape \n", "C2 5.00 V-shape \n", "C3 5.00 V-shape \n", "C4 1.67 V-shape \n", "C5 1.67 V-shape \n", "C6 11.67 V-shape \n", "C7 11.67 V-shape \n", "C8 5.00 V-shape \n", "C9 5.00 V-shape \n", "C10 16.67 V-shape \n", "C11 8.33 V-shape \n", "C12 8.33 V-shape \n", "\n", " Preference Threshold (p) for PROMETHEE II and PROSA-C \n", "Cj \n", "C1 7280.0 \n", "C2 4.0 \n", "C3 13.4 \n", "C4 7.4 \n", "C5 3.0 \n", "C6 1662.0 \n", "C7 3.0 \n", "C8 3.0 \n", "C9 13.8 \n", "C10 3.0 \n", "C11 766240.0 \n", "C12 17820.0 " ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "crits" ] }, { "cell_type": "markdown", "id": "6b37832f", "metadata": {}, "source": [ "Load a decision matrix containing the performance values of an example decision problem from a CSV file as a `DataFrame`." ] }, { "cell_type": "code", "execution_count": 6, "id": "4b365bd1", "metadata": {}, "outputs": [], "source": [ "data = pd.read_csv('./results/dataset1.csv', index_col = 'Ai')" ] }, { "cell_type": "code", "execution_count": 7, "id": "26ad34a4", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
$C_{1}$$C_{2}$$C_{3}$$C_{4}$$C_{5}$$C_{6}$$C_{7}$$C_{8}$$C_{9}$$C_{10}$$C_{11}$$C_{12}$
Ai
$A_{1}$16347.09.073.836.71.53730.02.01.038.84.01720524.040012.0
$A_{2}$14219.08.555.036.02.03240.01.01.033.12.01496512.034803.0
$A_{3}$8160.09.064.828.52.01860.02.02.045.84.0858830.019973.0
$A_{4}$8160.08.562.529.51.51860.01.03.027.33.0858830.019973.0
\n", "
" ], "text/plain": [ " $C_{1}$ $C_{2}$ $C_{3}$ $C_{4}$ $C_{5}$ $C_{6}$ $C_{7}$ \\\n", "Ai \n", "$A_{1}$ 16347.0 9.0 73.8 36.7 1.5 3730.0 2.0 \n", "$A_{2}$ 14219.0 8.5 55.0 36.0 2.0 3240.0 1.0 \n", "$A_{3}$ 8160.0 9.0 64.8 28.5 2.0 1860.0 2.0 \n", "$A_{4}$ 8160.0 8.5 62.5 29.5 1.5 1860.0 1.0 \n", "\n", " $C_{8}$ $C_{9}$ $C_{10}$ $C_{11}$ $C_{12}$ \n", "Ai \n", "$A_{1}$ 1.0 38.8 4.0 1720524.0 40012.0 \n", "$A_{2}$ 1.0 33.1 2.0 1496512.0 34803.0 \n", "$A_{3}$ 2.0 45.8 4.0 858830.0 19973.0 \n", "$A_{4}$ 3.0 27.3 3.0 858830.0 19973.0 " ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data" ] }, { "cell_type": "markdown", "id": "280dc0eb", "metadata": {}, "source": [ "Convert a DataFrame with decision matrix `data` to a `NumPy` array `matrix` to use the `NumPy` package for computation" ] }, { "cell_type": "code", "execution_count": 8, "id": "a01b9ff1", "metadata": {}, "outputs": [], "source": [ "matrix = data.to_numpy()" ] }, { "cell_type": "markdown", "id": "cb8798ab", "metadata": {}, "source": [ "Provide criteria weights. The weights must be normalized using sum normalization and give a value of 1 after being summed." ] }, { "cell_type": "code", "execution_count": 9, "id": "9d0c65e9", "metadata": {}, "outputs": [], "source": [ "weights = np.array([20, 5, 5, 1.67, 1.67, 11.67, 11.67, 5, 5, 16.67, 8.33, 8.33])\n", "weights = weights / np.sum(weights)" ] }, { "cell_type": "code", "execution_count": 10, "id": "cd0d4893", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.19998 , 0.049995 , 0.049995 , 0.01669833, 0.01669833,\n", " 0.11668833, 0.11668833, 0.049995 , 0.049995 , 0.16668333,\n", " 0.08329167, 0.08329167])" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "weights" ] }, { "cell_type": "markdown", "id": "8bf26578", "metadata": {}, "source": [ "Provide criteria types. Assign 1 to profit criteria and -1 to cost criteria. Other values are not allowed." ] }, { "cell_type": "code", "execution_count": 11, "id": "b52cd864", "metadata": {}, "outputs": [], "source": [ "types = np.array([-1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 1, 1])" ] }, { "cell_type": "markdown", "id": "f0440049", "metadata": {}, "source": [ "Create the DataFrame for results rankings, including rankings provided by investigated MCDA methods." ] }, { "cell_type": "code", "execution_count": 12, "id": "5e32b76a", "metadata": {}, "outputs": [], "source": [ "alt_names = [r'$A_{' + str(el) + '}$' for el in range(1, matrix.shape[0] + 1)]\n", "rank_results = pd.DataFrame(index=alt_names)" ] }, { "cell_type": "markdown", "id": "5c5e7555", "metadata": {}, "source": [ "All MCDA methods investigated here sort alternatives according to preference values in descending order. It means that the best alternative has the highest preference value. Thus, we rank alternatives using the `rank_preferences` function with parameter `reverse=True`." ] }, { "cell_type": "markdown", "id": "2e004ef4", "metadata": {}, "source": [ "## PROMETHEE II" ] }, { "cell_type": "markdown", "id": "489ef801", "metadata": {}, "source": [ "In this case, you will use the V-shape preference function, so provide vector `p`." ] }, { "cell_type": "code", "execution_count": 13, "id": "b8c60946", "metadata": {}, "outputs": [], "source": [ "p = np.array([7280, 4, 13.4, 7.4, 3, 1662, 3, 3, 13.8, 3, 766240, 17820])" ] }, { "cell_type": "code", "execution_count": 14, "id": "d9d80559", "metadata": {}, "outputs": [], "source": [ "# Create the PROMETHEE II method object\n", "promethee_II = PROMETHEE_II()\n", "# Assign preference functions to each criterion\n", "preference_functions = [promethee_II._vshape_function for pf in range(len(weights))]\n", "\n", "# Calculate the utility function value (the preference value) for each alternative\n", "pref = promethee_II(matrix, weights, types, preference_functions, p = p)\n", "# Determine the ranking based on `pref` by sorting it in descending order (reverse = True)\n", "rank = rank_preferences(pref, reverse=True)\n", "# Save the PROMETHEE II ranking in the DataFrame\n", "rank_results['PROMETHEE II'] = rank" ] }, { "cell_type": "markdown", "id": "22c0c7db", "metadata": {}, "source": [ "PROMETHEE II utility function values" ] }, { "cell_type": "code", "execution_count": 15, "id": "fe9a0663", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([-0.04449699, 0.18838474, -0.09537616, -0.04851159])" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pref" ] }, { "cell_type": "markdown", "id": "0546ddea", "metadata": {}, "source": [ "The best scored is alternative $A_2$ because it has the highest preference value." ] }, { "cell_type": "markdown", "id": "8d2a0afe", "metadata": {}, "source": [ "PROMETHEE II ranking" ] }, { "cell_type": "code", "execution_count": 16, "id": "b098bf05", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([2, 1, 4, 3])" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rank" ] }, { "cell_type": "markdown", "id": "069d53f6", "metadata": {}, "source": [ "If you would like to use the linear preference function (V-shape with indifference) or Level function, Gaussian function, using PROMETHEE II is as follows: pref = promethee_II(matrix, weights, types, preference_functions, p = p, q = q) with additional `q` providing. U-shape function requires `q`, and the Usual function does not require any parameter.\n", "\n", "Here is a summary of the required parameters for the preference function for PROMETHEE II and PROSA-C:\n", "\n", "- Usual: No parameters\n", "- U-shape: `q`\n", "- V-shape: `p`\n", "- Level: `p`, `q`\n", "- Linear (V-shape with indifference): `p`, `q`\n", "- Gaussian: `p`, `q`" ] }, { "cell_type": "markdown", "id": "6313d865", "metadata": {}, "source": [ "## PROSA-C" ] }, { "cell_type": "markdown", "id": "2cd96515", "metadata": {}, "source": [ "Using PROSA-C is similar to PROMETHEE II, but it requires providing an additional argument, a vector `s` including sustainability coefficients for each criterion. The sustainability coefficient determines the reduction of criteria compensation. If you do not specify the arguments `p`, `q`, and `s` for the PROMETHEE II and PROSA methods, they will be set automatically, based on:\n", "\n", "Ziemba, P. (2020). Multi-criteria stochastic selection of electric vehicles for the sustainable development of local government and state administration units in Poland. Energies, 13(23), 6299. DOI: https://doi.org/10.3390/en13236299 in following way:\n", "\n", "u = np.sqrt(np.sum(np.square(np.mean(matrix, axis = 0) - matrix), axis = 0) / matrix.shape[0])\n", "\n", "p = 2 * u\n", "\n", "q = 0.5 * u\n", "\n", "s = np.repeat(0.3, len(weights))" ] }, { "cell_type": "code", "execution_count": 17, "id": "b4167121", "metadata": {}, "outputs": [], "source": [ "s = np.repeat(0.3, len(weights))\n", "prosa_c = PROSA_C()\n", "pref = prosa_c(matrix, weights, types, preference_functions, p = p, s = s)\n", "rank = rank_preferences(pref, reverse=True)\n", "rank_results['PROSA C'] = rank" ] }, { "cell_type": "markdown", "id": "a618c423", "metadata": {}, "source": [ "## ARAS" ] }, { "cell_type": "markdown", "id": "b793b457", "metadata": {}, "source": [ "In contrast to PROMETHEE II and PROSA-C, ARAS requires normalization of the decision matrix. In the ARAS method you can choose one technique for normalization decision matrix from five available: `linear_normalization`, `minmax_normalization`, `max_normalization`, `sum_normalization` and `vector_normalization`. The default normalization for ARAS is `sum_normalization`. The normalization method is chosen in method object initialization in the constructor of the method. In the case of other MCDA methods presented below, normalization method selection is analogous." ] }, { "cell_type": "code", "execution_count": 18, "id": "ff86413c", "metadata": {}, "outputs": [], "source": [ "aras = ARAS(normalization_method=norms.linear_normalization)\n", "pref = aras(matrix, weights, types)\n", "rank = rank_preferences(pref, reverse=True)\n", "rank_results['ARAS'] = rank" ] }, { "cell_type": "markdown", "id": "a7ceb7c0", "metadata": {}, "source": [ "## COPRAS" ] }, { "cell_type": "markdown", "id": "32bad2db", "metadata": {}, "source": [ "The COPRAS method also requires the normalization of the decision matrix. The default normalization method for COPRAS is the Sum normalization used like for profit criteria because in COPRAS decision matrix is normalized before dividing criteria into profit and cost. There is also an option to select another normalization method from `normalizations` submodule. Chosen normalization method is performed automatically like for profit criteria, according to the COPRAS algorithm." ] }, { "cell_type": "code", "execution_count": 19, "id": "d2849938", "metadata": {}, "outputs": [], "source": [ "copras = COPRAS(normalization_method = norms.sum_normalization)\n", "pref = copras(matrix, weights, types)\n", "rank = rank_preferences(pref, reverse=True)\n", "rank_results['COPRAS'] = rank" ] }, { "cell_type": "markdown", "id": "f77fa204", "metadata": {}, "source": [ "## CRADIS" ] }, { "cell_type": "markdown", "id": "95ecedfe", "metadata": {}, "source": [ "The CRADIS method enables choosing a normalization technique. The default is `linear_normalization`." ] }, { "cell_type": "code", "execution_count": 20, "id": "f239facd", "metadata": {}, "outputs": [], "source": [ "cradis = CRADIS()\n", "pref = cradis(matrix, weights, types)\n", "rank = rank_preferences(pref, reverse=True)\n", "rank_results['CRADIS'] = rank" ] }, { "cell_type": "markdown", "id": "f43ff4a9", "metadata": {}, "source": [ "## MARCOS" ] }, { "cell_type": "markdown", "id": "ee3d698b", "metadata": {}, "source": [ "The MARCOS method does not enable the selection of the normalization technique because this method normalizes the decision matrix using a specific method involving ideal and anti-ideal solutions." ] }, { "cell_type": "code", "execution_count": 21, "id": "2359d03f", "metadata": {}, "outputs": [], "source": [ "marcos = MARCOS()\n", "pref = marcos(matrix, weights, types)\n", "rank = rank_preferences(pref, reverse=True)\n", "rank_results['MARCOS'] = rank" ] }, { "cell_type": "markdown", "id": "c54e22bc", "metadata": {}, "source": [ "## SAW" ] }, { "cell_type": "markdown", "id": "41f8c418", "metadata": {}, "source": [ "The SAW method enables choosing a normalization technique. The default is `linear_normalization`." ] }, { "cell_type": "code", "execution_count": 22, "id": "d5436494", "metadata": {}, "outputs": [], "source": [ "saw = SAW()\n", "pref = saw(matrix, weights, types)\n", "rank = rank_preferences(pref, reverse=True)\n", "rank_results['SAW'] = rank" ] }, { "cell_type": "markdown", "id": "226e8626", "metadata": {}, "source": [ "Display rankings determined by each investigated MCDA method." ] }, { "cell_type": "code", "execution_count": 23, "id": "6426fb09", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
PROMETHEE IIPROSA CARASCOPRASCRADISMARCOSSAW
$A_{1}$2332333
$A_{2}$1111111
$A_{3}$4444444
$A_{4}$3223222
\n", "
" ], "text/plain": [ " PROMETHEE II PROSA C ARAS COPRAS CRADIS MARCOS SAW\n", "$A_{1}$ 2 3 3 2 3 3 3\n", "$A_{2}$ 1 1 1 1 1 1 1\n", "$A_{3}$ 4 4 4 4 4 4 4\n", "$A_{4}$ 3 2 2 3 2 2 2" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rank_results" ] }, { "cell_type": "code", "execution_count": 24, "id": "9b69c966", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAEXCAYAAAA9RvVFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABAoUlEQVR4nO3deVxU9f4/8NcHhn3fZEdNxQ0CBPfUNNM2syLNNJcsU79l95d21dTvw+pmZdfq5m3RcstdKzNTu1pZ2vKNEJRYApEEZAcBh5F1mM/vDxgvIuqAI4dhXs/HYx4655zP57xneM9n3vM5Z+YIKSWIiIiIyHxYKB0AEREREbUvFoBEREREZoYFIBEREZGZYQFIREREZGZYABIRERGZGZXSAVyPEMK6S5cunwgh7gBgqXQ8RERERCZAp1KpCoqKil6pra090tIGHboAdHJymj9u3LjhH3/8cbmdnR1/r4aIiIjoBmpqasTp06ddZs2a9b61tfVzLRWBoiP/DmBAQMDpn376SXTv3r1O6ViIiIiITElMTIxddHT0xZycnGHN13XocwC1Wq1LYGAgiz8iIiKiVgoPD6/WarU+La3r0AUgAKFSdeij1EREREQdko2NjcQ1ar2OXgASERERkZGxACQikyCEiJw4cWJ3/f26ujq4ubmFjR49uqd+2d69e51DQkL69ujRo3/fvn37zZkzJwAAFi5c6NelS5fb+/Tp069r164h48aN6xEXF2fbtP9ff/3VTggR+fnnnzvfivjT0tKs161b566/v3btWo8ZM2YEtbW/m21PROaNBSARmQQ7OztdWlqanUajEQDw5ZdfOnt7e18+Rzg2NtZ20aJFQdu2bTuXkZGRnJiYmNKzZ88a/fp58+YVpqampmRlZSVNmjSpdPz48b3z8vIun2Oybds29wEDBmh27tzpjlsgPT3dZs+ePbekbyKi1mIBSEQmY+zYsRc/++wzVwDYtWuXe3R0dKl+3euvv+6zaNGi/IiIiGoAUKlUWLJkSXFL/cyZM6dsxIgRFzdu3OgOADqdDl9//bX71q1bM3/++WfnyspK0VI7e3v7iLlz5wb07Nmz/7Bhw4J/+OEH+0GDBvUOCAgI3bFjhwsAaLVazJ07NyAkJKRvcHBwv3/+85+eALB8+XL/kydPOvbp06ffK6+80gUACgoKrEaMGNGra9euIfPmzQvQ72f9+vXuwcHB/Xr16tV//vz5/vrl7733nke3bt1CQkND+/7666+O+uWbNm1y69WrV//evXv3i4qK6t3mJ5iIzAYLQCIyGdOnTy/ds2ePW2Vlpfjzzz/thw4dekm/Li0tzW7w4MGVhvYVERFRmZqaagsA3333nUNgYGBN//79awYPHlyxd+9el5baVFVVWdx1113qs2fPJjs4ONSvWLHC/6effjrz2Wefnf3HP/7hDwD/+te/PF1cXOqTkpL+TEhI+PPTTz/1Sk1NtV61alVuVFSUJjU1NWXlypVFAJCSkmK/f//+v/7888/kAwcOuJ09e9YqMzPT6uWXX/b/8ccfz6SkpCSfOnXKYdu2ba5ZWVlWb775pt+vv/6aGhsbm3rmzBk7fVxvvvmm79GjR8+kpaWl/Oc//znb1ueXiMwHv2JLRCZj8ODBVTk5OTaffPKJ+9ixYy/eTF9NfwN1+/btHo8++mgpAEyZMqV027ZtHrNmzSpv3sbKyko++uijagDo379/lY2Njc7GxkYOGjSoKjc31xoAvvvuO+fU1FT7AwcOuAFARUWFZUpKiq21tfVVP7p6xx13qD08POoBoGfPntUZGRk2xcXFqiFDhlT4+flpAeCxxx4rPX78uCMANF3+yCOPlJ45c8YWAKKiojTTpk3rFh0dXTZt2rSym3leiMg8sAAkIpNyzz33lK9cuTLw6NGjaUVFRZfHsODg4OqYmBj7oUOHVhnSz+nTp+0jIyMrtVotvvnmG9ejR4+6vvPOO75SSpSXl6vKysos3NzcdE3bqFQqaWHRcODEwsJC/xMLsLS0RH19vQAAKaV4++23s6Ojo9VN2x48eNCpeQxNi0JLS0tZV1fX4qHnG9m5c2f2sWPHHA4cOOASGRnZLy4uLsXHx6e+LX0RkXngIWAiMinz588vefHFF/MGDRp0RaH30ksvFbzzzju+f/zxhw0A1NfX46233vJqqY8tW7a4/vTTTy6zZ88uPXDggHPv3r2rCgoK/sjNzU3My8tLvOeee8p27Njh1pb47r777osfffSRV01NjQCAP/74w0atVlu4uLjUazSaG17TfMSIEZdiYmKc8vPzVVqtFp999pn7nXfeqRk5cuSlmJgYp4KCAsuamhrx5ZdfXo4vOTnZZsyYMZf+9a9/5bm5uWn/+usv67bETkTmgzOARGRSevToUbdixYqi5ssHDx5ctXr16vOPP/74bVVVVRZCCNx9992XDxOvW7fOe+/evR5VVVUWwcHBVUeOHEnz8/PT7ty50/3BBx8sb9pXdHR02fr167s899xzF1ob3wsvvFCSmZlpExoa2ldKKdzd3esOHz6cMWjQoCpLS0vZu3fvflOnTi1xc3NrcYaua9eudStXrswdNWpUsJRSjB07tvyJJ54oB4AlS5bkDRkypK+Tk1N9SEhIZZN9BmRmZtpIKcUdd9yhHjJkiEGzoERkvjr0tYB9fHwyCwoKSpSOg4iIiMgU+fj4eBYUFHRrvpyHgImIiIjMDAtAIiIiIjPDApCIiIjIzLAAJCIiIjIzLACJiIiIzAwLQCIiIiIzwwKQiIiIyMywACQiIiIyMyZXAHr5+IUJISJv1c3Lxy/MkDj8/f1DbW1tB9jb20d4eHiERUdHd7t48aIFAAwaNKi3jY3NAHt7+wg3N7ewcePG9cjKyrJq2j4uLs52zJgxPZ2cnMIdHBwiBg8eHPztt9866NenpaVZCyEi+/bt269pu/z8fJWVldUAf3//0JZi0d9mzJgRtHTpUh/9fRsbmwGWlpaR+vs9e/bsDwBCiMikpCSbpvtYuHCh38SJE7vr7wshIu3s7CKa9r9ixQpv/bYqleqKfTs5OYW39JzpH1NdXR0AIDo6utvzzz/vZ8jzTdfn5et1a18Xvl4GvS70Bg0a1NvZ2Tm8qqrq8rVto6Oju1lZWQ2wt7ePcHFxCR82bFivU6dO2RrSFgAyMjKsxo8f38PNzS3MyckpvFevXv3Xrl3r0fZnjYzJ1/vWjs2+3oaNzU2tW7fOPSQkpK+9vX2El5fX7SNHjux15MgRx6bjlpOTU3hERESf7777zqF5++jo6G4qlSqy+fitb+/g4BDh4OAQ0a1bt5AZM2YENd3u4MGDTt7e3rfr7588edJ2+PDhvVxcXMKdnJzC+/fv33fPnj0urX1MZDj/W1wv+BtYLwDAkSNHHCMiIvo4OTmFu7i4hA8YMKDP8ePH7fXrL168aGFvbx8xcuTIXvplWVlZVkKIyPPnz1++atuSJUt8Wlo2YsSIXmglk7sUXElhvqrrkoO3rP+s1Q8Y/Jzs3r07/aGHHqo4d+6c1bhx44Jfeukl3w8//DAXAN54443shQsXlpSUlFhOnDjxtgULFgQcOHDgHNBw3c7Ro0f3mTlzZvGuXbvOWVtbyw8++MBz4sSJwQcOHDgzduzYS/p9VFVVWcTGxtoOHDiwGgA2btzo7u/vX9v8ovH6WJrH+OabbxYAwNq1az0+/fRTz7i4uLS2PC+xsbEpISEhNS2tu//++8u++uqrc23pl4yjpKBEFbIl5Jb1nzQryeDXRVpamnVcXJyjo6Nj/a5du1xnz55dpl83f/78grVr1+ZpNBoxc+bMrk899VS3+Pj4VEPaTp06tXv//v2rsrKyEu3s7HS///67XW5urlXz/ZMyCoryVe/P/f6W9f/c+rta9X718ssve69du9bn3XffzXr44YfVNjY28osvvnDet2+fq4ODg04/btXV1WHhwoX+06ZN61FYWPiHvr1arbb4z3/+4+bo6Fi/YcMG93/84x+FTfvXt6+pqRGJiYk2K1as8Bs4cGDf2NjYP7t27VrXPJ6HHnqo15NPPln0/fffnwWAEydO2EspRfPtyHjyCvNV55ecuGX9B64eaVBOlpaWWjz66KM916xZk/3UU0+VVldXi6NHjzrZ2tpevhTb1q1b3aytreWvv/7qnJ2drQoKCtJ27dq1LigoqObbb7910o+Fv/zyi1P37t2rmy+74447rnr/vxGTmwHsiLp37143ZsyYi3/++add83Wenp71EyZMKE9JSblc6S9fvtwvIiJC8+9//zvX29u73s3NTbdixYqihx9++MLSpUsDmrafPHnyhQ0bNnjq7+/evdvjscce4+XxqMP65JNPPMLCwi5NmjSpZNu2bS3O0Dk6OsrJkyeXNX/NXK9tYmKiw9NPP13i7Oyss7KywvDhw6smT56svpWPhUzThQsXLN966y2/NWvWZM+cObPc2dlZZ2NjI6dOnXpx/fr1OU23tbKywqxZsy4UFRVZ5eXlXX5D37p1q5uTk1P9okWL8nbv3u159V4a2NjYyKioqOqDBw/+5ebmpl21apV3823y8/NVubm51n/7299KbG1tpa2trRw3btyl8ePHa4z7yKkjSkpKsgWAuXPnlqpUKjg6OspHHnlEPXjw4MvX7N6xY4fH9OnTi4ODgys3bNhweewbPHhwxfHjxx0BQKvVIjk52X7evHlFTZedPn3acfTo0a3OJRaARnD27Fmr77//3uX222+vbL6uoKDA8sCBA25du3at1i/7+eefnR955JGy5ttOmTKl7NSpU44ajebyp8KnnnrqwldffeWu1WoRFxdne+nSJYuhQ4deat6WqKPYu3evx+TJky/MnDmz9KeffnJueqhCT61WW+zatcs9KCioxtC24eHhl5577rmuH3/8sVt6erp1ezwWMk0//PCDQ21trcX06dOvGmebq66uFhs3bvRwdXXVenl5afXLd+zY4fHQQw+Vzpo1q/TcuXO2P/30k/31+lGpVLj33nvLf/vtN8fm67y9vbVBQUE1kyZN6r5t2zbXll4T1HmFhIRUW1pa4pFHHum2d+9e5+LiYsum68+cOWP9+++/O82aNevCpEmTSnfv3n25ABwxYoTmt99+cwKAX3/91b5Hjx7V9957r7rpMq1WK0aNGtXquoAF4E2YOnVqTycnp/CRI0f2GTJkSMWqVavy9euWL18e6OTkFO7r6xteWlqqWrdu3Xn9uvLycpW/v/9VhwgCAgLqdDodiouLLw8Ot912W+1tt91W/dVXXzlv3LjRY/LkyReuF4v+9vbbb1/zE2tzQ4YM6de07QcffOBzo22++OILZ/26w4cPuzVdN3jw4GBD902dy5EjRxzz8vKsZ86cWTZixIjKwMDAmk2bNrnr169fv97Hyckp3NXVNSI2NtZx69at5wxt+9VXX2UMGTKk4q233vLr06dPaJ8+ffo1PYeGSK+4uFjl6uqqtbK69hkC+nHLwcFhwM6dO722bdv2l3779PR065iYGKcZM2ZcCAwM1A4ZMkS9adOmG55v6ufnV3fx4sWrijsLCwscO3YsLTAwsHbZsmUBXbt2DYuKiuqdmJho01I/1Lm4u7vrjh07liqEwIIFC7r5+vqGjxkzpqf+g8CGDRs8goODqyIjI6tnzZpVmpGRYffLL7/YAcC4ceMqzp49a1dSUmL5ww8/OA4dOlQTGhpaU1ZWptIvCwsL0zQ9nGwoFoA3YefOnWcrKipO5+XlJW7fvj3b0dHx8h9g1apV5ysqKk7HxMSkqNVqy8zMzMsjkaurq7alc5dycnKsLCws4OnpWd90+dSpUy9s2bLFY//+/e5PP/106fVi0d8WLVpk8GHi3377LaVp22effbbgRttER0dfPvR23333lTVdFxMTc8bQfVPnsnnzZo877rhD7evrqwWA6Ojo0l27dl3+MDJ37tyCioqK02lpaYm2tra65ORkW0Pbenl51X/44Ye5Z8+eTc7JyUno379/5aRJk3rqdLr2fIhkAry8vLTl5eUq/RfOWqIft3JychJ69epVFRsbe/nDxIYNG9xvu+226mHDhlUBwJQpU0r379/vXlNTc91z9nJzc61cXFy0La3r0aNH3datW7PPnz+fdObMmT/s7e1106dP797SttT5DBgwoPqLL77ILCws/CM2Nja5qKjI6n/+538CgYYjH5MmTboANJxSNnDgwIqNGzd6AkDv3r1ru3TpUnv06FHHn3/+2WnUqFEVjf1p9MuGDRvWplMJWADeYoMGDapatGhR/vPPP99V/0Y1fPhw9b59+9yab7t792638PBwjZOT0xXvaDNmzCj74YcfXAMDA2t69epV206hE7WKRqMRhw4dcvv999+dPD09wzw9PcM+/vhj77S0NLv/+7//u+Jcv169etWuWbPm/NKlSwM1Go1oTVsA8PX11S5durSguLjYqqioyLL5ejJvo0ePvmRlZaXbvn37VeNsc76+vtoNGzZkrlmzxk//Ld49e/Z45uTk2Ohz8X//938DysvLVZ999tk1v7VbX1+PI0eOuA4ZMuSGb8Y9e/asmz9/flF6evpVuU2dX0RERPXUqVNL0tLS7L799luHrKwsm7Vr1/rq8y0hIcFh//797voPMIMGDdIcP37c6dSpU45jxozRAMDw4cM1x48fdzp58qTjnXfe2eovgAAsANvFs88+e+HChQuqnTt3ugLAa6+9lhcfH++4YMEC/8LCQsuysjKLVatWddm3b5/HG2+8kdO8vbOzs+7w4cNpmzZtymr34IkMtGPHDjcLCwskJCQkx8fHJ8fHxycnJSUlRUZGalo6fPbwww+ru3TpUvfuu+96GdJ2/vz5/rGxsbZ1dXUoKyuzWLt2bZegoKAaHx+f+qujIXPm4eFRv3jx4rwXX3wxaNu2ba4VFRUWNTU1Yu/evc7z5s0LaL59WFhYzYgRIy6++uqrPt99951DTk6OzYkTJ/7U52JCQkLyhAkTSlv6UlNdXR3i4+NtH3zwwdtKSkqsli1bVth8m+LiYssXXnjBLykpyaa+vh75+fmqzZs3e4aFhfFLIGbg1KlTtitXrvTOyMiwAhq+N/D55597DBgw4NLmzZs9hw0bpk5MTEzS59upU6eSa2pqLPQfOEaMGFHx+eefe3Tp0qXW3d1dBwB33nmn5vPPP/fQaDSWY8aMadP3AkzuRFRPb19ta36qpS39G7tPW1tbOWfOnKI333zT94knnigPDQ2tOXbsWOrixYsDevTocbtOp0NISEjl/v3708eNG9fiH3LkyJFXfcGkqSlTpvSysLC4fAh6+PDh6m+//TbDWI9h4MCB/YT479GPKVOmlGzatOk8ABw6dMjN3t7eten26enpif7+/kZ/Lqllnj6e2tb8VEtb+r/RNtu3b/eYPHlySfNZ6nnz5hUtXbo0aPjw4Vd9Y/dvf/tbwfLlywO7d+9efb22H374YU5lZaXFo48+2rO4uNjKxsZGFx4efunLL788e/OPjozBp4uvtrU/1dLa/luz/SuvvFLo4+NTt3r1at9nnnmmu4ODgy4kJOTS8uXL87/55purZvIWL15ceP/99wer1WrLu+66q3zQoEFVTde/8MILhePHj+9TWFhoCfx33JNSokuXLnUjRoxQx8bGpnTr1u2q4842NjYyKyvLevz48cFlZWUqe3t73dChQ9Xr16/Pbu3zQIbz8/bVGvpTLW3t35DtXF1d62NjYx0++ugj74qKCksnJ6f6sWPHXnz//ffPd+vW7fZ169adCwoKuqKvhx9++MLWrVs9pk6devHuu++u+Pvf/66aMGHC5VPAhg4dWllTU2PRv3//yuZHDQ0lpGz1eYPtxsfHJ7OgoIA/eUJERETUBj4+Pp4FBQXdmi/nIWAiIiIiM8MCkIiIiMjMsAAkIiIiMjMsAImIiIjMDAtAIiIiIjPDApCIiIjIzLAAJCIiIjIzLACJiIiIzAwLQCIiIiIzY3IFYICPZ5gQIvJW3QJ8PMMMicPf3z/U1tZ2gL29fYSHh0dYdHR0t4sXL1oAwKBBg3rb2NgMsLe3j3BzcwsbN25cD/1FxvXi4uJsx4wZ09PJySncwcEhYvDgwcHffvutQ9Nt3n33Xc/u3bv3d3BwiPDw8AgbNWpUz7Kysiv+ZgcPHnQSQkQuX77c50Yxl5aWWsyePTvQ19c31N7ePiIwMDBk9uzZgfn5+SZ3SUC6kr+X1y19Xfh7eRn0utBbt26de0hISF97e/sILy+v20eOHNnryJEjjsCNcz8tLc1aCBFpb28fYW9vH+Hv7x+6bNmyy/kthIi0s7OLsLe3j+jSpcvtTz/9dIBWe+UVmVJTU60tLCwip02bFtQ8tu3bt7v26dOnn6OjY4Sbm1vYkCFDglNTU61b/aTTFXy8u9zSHPTx7mJwDvr7+4daWVkNaD629e3bt58QIjItLe3y33vhwoV+QojIY8eOXTH+rl271sPS0jLS3t4+wtHRMaJ37979du3adcUl5L744gvnqKio3g4ODhFubm5hAwcO7L1jx47L22RkZFg9+OCD3V1dXcPt7OwiQkND+zbvg/lISjG5N/7cwgsqudL5lvUvXrlg8HOye/fu9Iceeqji3LlzVuPGjQt+6aWXfD/88MNcAHjjjTeyFy5cWFJSUmI5ceLE2xYsWBBw4MCBcwCQnJxsM3r06D4zZ84s3rVr1zlra2v5wQcfeE6cODH4wIEDZ8aOHXvp0KFDjq+99pr/gQMHzgwfPryqsLDQcu/eva7NY9iyZYuHi4tL/Z49ezxWrVpVcK1Yq6urxciRI3s7OztrDx48mB4eHl5dUFCg+te//uV14sQJh8cee+xiG54u6iDySkpUKb373LL++6WlGvy6ePnll73Xrl3r8+6772Y9/PDDahsbG/nFF18479u3zzUgIKDuRrmv7+fixYunrKys8N133zlMmDAheMCAAZWPPvqoGgBiY2NTQkJCapKSkmzGjBnTu2/fvtWLFi26fNnITz75xMPZ2bn+4MGD7lVVVeft7OwkACQlJdnMnz+/2/bt2zMmTJhQcfHiRYuvvvrK2dLS0phPl1kqLCpWrZl8/y3r/8W9h1r1fuXv71+7adMm9+XLlxcBwO+//25XVVV1xQdonU6HvXv3eri4uNRv3rzZY8yYMVdciz08PFwTFxeXVl9fj3feecfzqaeeuu3uu+/+w9PTs37z5s1uCxYs6Pbqq6+enzlz5llXV9f6//znP47btm3zmDZt2sXCwkLLkSNH9hk6dGjFH3/8keTu7l6/Y8cOtzlz5txWXV2d+eSTT5YxH0lJJjcD2BF17969bsyYMRf//PNPu+brPD096ydMmFCekpJir1+2fPlyv4iICM2///3vXG9v73o3NzfdihUrih5++OELS5cuDQCAmJgYh4iICM3w4cOrAMDb27t+wYIFF9zc3C5f9FmtVlt88803bm+99VZWVlaWzYkTJ+yb71/vww8/9MjPz7f+5ptvMiIjI6stLS3h7++v/ec//5nP4o+M5cKFC5ZvvfWW35o1a7JnzpxZ7uzsrLOxsZFTp069uH79+hxDcr+5sWPHXurRo0f1H3/8cdXrKyQkpCYqKkpz+vTpy7mvf1N/6aWXclUqldy9e7erfl1sbKy9v79/7cSJEyssLCzg5uammzVrVnmvXr1qb8kTQoqZPHnyhV27dnno72/YsMHjscceu+La8keOHHEsKSmxeuONN7K//vpr9+rqatFSX5aWlpg3b15pVVWVRXJyso1Op8OyZcsCXnjhhbyFCxeWeHh41FtaWuL+++/X7N69OwsAXn/9dW97e3vdnj17MoOCgrSOjo5y7ty5pX/729/yly9fHqDT6ZiPpCgWgEZw9uxZq++//97l9ttvr2y+rqCgwPLAgQNuXbt2rdYv+/nnn50feeSRsubbTpkypezUqVOOGo1GDBs27NLPP//s8sILL/gdPXrUoaqq6qqBadu2ba729vb1s2fPLhsxYoR648aNHs230Tt27JjzqFGjLrq4uOiutQ3Rzfrhhx8camtrLaZPn35VfgOG5X7T5TqdDkePHnXIyMiwjYyMvOr1derUKdvY2FjHnj17Xn59HT161LGwsNB69uzZpQ888EDptm3bLr8uBg8efOncuXO2Tz31VODXX3/tpD9tgzqfYcOGaTQajWV8fLytVqvFV1995f7UU0+VNt2mcdavfPbs2WUAsHv3bpeW+tJqtXj//fc9VCqV7NmzZ21CQoJtQUGB9bRp01rMcwD48ccfnR944IGy5rN506dPL83Pz7dOTEy0YT6SkphsN2Hq1Kk9nZycwkeOHNlnyJAhFatWrcrXr1u+fHmgk5NTuK+vb3hpaalq3bp15/XrysvLVf7+/nXN+wsICKjT6XQoLi5W3XPPPZqtW7eeTUhIsI+Oju7l4eER3vxcpx07dnhOmDChTKVS4bHHHis9cOCAe01NTYufYEtLSy19fHyu2ieRMRUXF6tcXV21VlZWLa43JPf1y9zd3cNdXV3D582b12358uW5EydOrNCvGzJkSD87O7uIAQMG9B8yZEjF4sWLi/XrNm/e7DFy5MiLXl5e9dOnTy89ceKEc25urgoA+vXrV3v48OG0/Px8qxkzZtzWpUuX8Kbn71LnMnny5AsbN2702L9/v3OPHj2qunfvfnlmraKiwuLw4cPujz/+eKmNjY287777ypp+WACAhIQERycnp3BbW9sBr7zySuBHH310zt/fX1tcXGwJAEFBQdccU8vKylS+vr5Xrde3KSwsVDEfSUlMspuwc+fOsxUVFafz8vISt2/fnu3o6Cj161atWnW+oqLidExMTIparbbMzMy8/I7o6uqqzc3NveodMicnx8rCwgKenp71ADB58mT1sWPHzpaXl5/etWvX2c8++8zz3Xff9QQaZh1jYmKcZs6ceQEApk6dWl5bW2uxd+/eFj/Buru71xcUFLT8rkxkJF5eXtry8nJVXV3L74uG5j4AlJaWnlar1af/+uuv5BUrVhQ13f63335LuXTp0qlPPvnkr1OnTjmq1WoLANBoNOLw4cNuU6dOLQUaDh/7+vrWbty40V3f9q677rp0+PDhv8rKyhKOHj2aGhMT47Rs2TJfIz0F1IE8/fTTF7788kv3LVu2eE6bNu1C03Xbt293tbS0lJMmTboIANOnT79w4sQJl7y8vMsfQsLCwjQVFRWnL1y4cPquu+4q/+mnnxwBwMvLqx4AsrOzrzmmurm5afPz869ar2/j7e2tBZiPpBwWgLfYoEGDqhYtWpT//PPPd9XpGo6+Dh8+XL1v3z635tvu3r3bLTw8XOPk5HTFYVpLS0tMnDixYujQoeqkpCQ7oOF8Fp1Oh+jo6F6enp5h3bt3D62pqRFbt25t8TDwmDFj1CdOnHDRv1ES3QqjR4++ZGVlpdu+fftV+Q20Pvevx8LCAk8//XTZgAEDNC+99JIfAGzfvt1No9FYLlq0KMjT0zPM09MzrKioyHrXrl2eLfUxatSoyvvuu6+spfN3yfQFBwfXBgQE1P74448u06dPL2+6bvv27R6VlZUWAQEBt3t6eoY98cQTPbRarWj6YUHPxcVFt2nTpqx9+/Z5/PLLL3ZhYWHVPj4+tTt37mwxzwFg1KhR6kOHDrnW19dfsXzbtm3uPj4+taGhoTUttGE+UrthMdAOnn322QsXLlxQ7dy50xUAXnvttbz4+HjHBQsW+BcWFlqWlZVZrFq1qsu+ffs83njjjRyg4dPpxx9/7FZcXGyp0+nwww8/2MfExDgNGTLkEgDs3r3b84UXXsiPj49P1t8+/fTTjOPHj7sUFBRc9RWy+fPnX/Dx8am9//77e5w6dcq2vr4eBQUFlkuXLvXZs2dPi7OGRK3l4eFRv3jx4rwXX3wxaNu2ba4VFRUWNTU1Yu/evc7z5s0LMCT3W2vFihUFu3bt8szOzlZt377dY9KkSSUJCQmXXxffffddalpamt3vv/9ud+TIEce3337bU39I+NSpU7ZHjx51HThwoMa4zwR1FJs3b848fPhwmrOz8+UPF1lZWVa//fab8549e87q8+TUqVPJ8+fPL9i9e3eLH6K9vb3rH3/88ZKXX37Zz8LCAq+//nrOu+++6/vee+95lJaWWtTX1+PIkSOOjz/+eFcAWLZsWWFFRYXlY4891i07O1tVWVkp1q9f7/7ee+/5vvrqqzkWFhZgPpKSTO5nYPy9PbSt+amWtvRv7D5tbW3lnDlzit58803fJ554ojw0NLTm2LFjqYsXLw7o0aPH7TqdDiEhIZX79+9PHzdu3CUA8PDw0H7wwQd+S5YsCaqtrbXw8vKqe/bZZwvmz59f+v333zvk5+dbv/jii0V+fn6X4502bdrFlStX1mzatMl92bJlxU1jsLOzk8ePHz/z97//3e/ee+8NVqvVlh4eHnXjx48vHzVqFAcbE+fn6altzU+1tKV/Q7d95ZVXCn18fOpWr17t+8wzz3R3cHDQhYSEXFq+fHm+IbnfWoMGDaoaOHCgZuHChQG//fab86+//poSFBR0Od6goCDtiBEjLm7YsMFjzpw5JYcOHXJ9/fXX/auqqizc3Ny0Dz74YOmrr75a2JZ90395d/HStvanWlrbf1va9e/f/6qZth9//NGpT58+lY888oi66fLFixcXffzxx96xsbG2LfW1ZMmSwr59+4bGxMTYPfnkk2VOTk71b7zxhu9LL70UZGNjo+vVq1f1woULCwDAx8en/sSJE2kLFy70Dw0NDamtrRU9evSoXrdu3bknnniiHADc3d21zEdSipBS3ngrhfj4+GQWFBSU3HhLIiIiImrOx8fHs6CgoFvz5TwETERERGRmWAASERERmRkWgERERERmhgUgERERkZnp6AWg7lpXtiAiIiKia2u8jGx9S+s6egGY9MEHH7iwCCQiIiIyjFarRUZGhtWcOXNcpZQ/t7RNh/4ZGCFEF29v7w0AQtDxi1UiIiKijkCnUqkuqtXqLRUVFR9JKWubb9ChC0AiIiIiMj7OqhERERGZmQ59KThPT0/ZrVs3pcPo9Gpra2Ftba10GNTBMU/IEMwTMhRzpX3ExcWVSCm9mi/v0AVgt27dcPLkSaXD6PSqqqpgZ2endBjUwTFPyBDMEzIUc6V9CCGyWlrOQ8CEvLw8pUMgE8A8IUMwT8hQzBVlsQAkuLu7Kx0CmQDmCRmCeUKGYq4oiwUgobKyUukQyAQwT8gQzBMyFHNFWSwACRYWTAO6MeYJGYJ5QoZiriiLzz7ByspK6RDIBDBPyBDMEzIUc0VZLAAJGo1G6RDIBDBPyBDMEzIUc0VZLAAJnp6eSodAJoB5QoZgnpChmCvKYgFIyMnJUToEMgHMEzIE84QMxVxRFgtAQs+ePZUOgUwA84QMwTwhQzFXlMUCkJCcnKx0CGQCmCdkCOYJGYq5oiwhpVQ6hmuKioqSvBQcERERUdsIIeKklFHNl3MGkBAXF6d0CGQCmCdkCOYJGYq5oizOABIRERF1UpwBpGvipzAyBPOEDME8IUMxV5TFGUAiIiKiToozgHRNiYmJSodAJoB5QoZgnpChmCvKYgFICA4OVjoEMgHMEzIE84QMxVxRFgtAQnZ2ttIhkAlgnpAhmCdkKOaKslgAEry9vZUOgUwA84QMwTwhQzFXlMUCkFBeXq50CGQCmCdkCOYJGYq5oiwWgARbW1ulQyATwDwhQzBPyFDMFWWxACQiIiIyMywACdXV1UqHQCaAeUKGYJ6QoZgrymIBSHB1dVU6BDIBzBMyBPOEDMVcURYLQEJhYaHSIZAJYJ6QIZgnZCjmirJYABKCgoKUDoFMAPOEDME8IUMxV5TFApBw5swZpUMgE8A8IUMwT8hQzBVlCSml0jFcU1RUlDx58qTSYRARERGZJCFEnJQyqvnydp8BFEL0EkJUCyG2t/e+qWVxcXFKh0AmgHlChmCekKGYK8pq9xlAIcRRAHYAsqSUT1xvW84AEhEREbVdh5gBFEJMAVAO4Pv23C9dHz+FkSGYJ2QI5gkZirmirHYrAIUQzgBeBbDwBts9I4Q4KYQ4mZ+fj5KSEuTn5yM3NxdlZWXIyMhAVVUVUlJSoNPpEB8fD+C/iRQfHw+dToeUlBRUVVUhIyMDZWVlyM3Nhb6/zMxMaDQapKamQqvVIiEh4Yo+9P8mJiaipqYG6enpUKvVyM7ORlFREYqKipCdnQ21Wo309HTU1NQgMTGxxT4SEhKg1WqRmpoKjUaDzMzMDveYAgMDO91j6ox/J6UfU79+/TrdY1Lq7+QbEAQhRJtv9taWN9XeylbV5rZ2quu3jYqKuu56W2vbm4rdxsrqJp87u5tqH+Djb9K515FeT3qd6TF11L9TS9rtELAQ4j0AeVLK1UKIlwH05CHgjiEhIQFhYWFKh0EdHPPEeIQQ6LrkYJvbZ61+AHKlc9v3/4oaIVtC2tQ2aVYSUnr3afO++6Wl4v25bT8I9Nz6u7Bm8v1tbv/i3kM4v+REm9sHrh6JjvzlSVPCMaV9XOsQsKqddh4OYCyAiPbYH7VO//79lQ6BTADzhIiMiWOKstrrEPCdALoByBZCFAB4EUC0ECK+nfZP13H27FmlQyATwDwhImPimKKsdpkBBPAxgN1N7r+IhoJwfjvtn64jICBA6RDIBDBPiMiYOKYoq11mAKWUlVLKAv0NgAZAtZSyuD32T9dXUlKidAhkApgnRGRMHFOU1V4zgFeQUr6sxH6pZY6OjkqHQCaAeUJExsQxRVm8FjChrq5O6RDIBDBPiMiYOKYoiwUgQafTKR0CmQDmCREZE8cUZbEAJNjb2ysdApkA5gkRGRPHFGWxACSUlpYqHQKZAOYJERkTxxRlsQAk+Pn5KR0CmQDmCREZE8cUZbEAJJw7d07pEMgEME+IyJg4piiLBSChT5+2X9eTzAfzhIiMiWOKslgAEk6fPq10CGQCmCdEZEwcU5TFApAwYMAApUMgE8A8ISJj4piiLBaAhLi4OKVDIBPAPCEiY+KYoiwWgITIyEilQyATwDwhImPimKIsFoCE+Ph4pUMgE8A8ISJj4piiLBaAhPDwcKVDIBPAPCEiY+KYoiwWgITU1FSlQyATwDwhImPimKIsFoCE7t27Kx0CmQDmCREZE8cUZbEAJOTl5SkdApkA5gkRGRPHFGWxACS4u7srHQKZAOYJERkTxxRlsQAkVFZWKh0CmQDmCREZE8cUZbEAJFhYMA3oxpgnRGRMHFOUxWefYGVlpXQIZAKYJ0RkTBxTlMUCkKDRaJQOgUwA84SIjIljirJYABI8PT2VDoFMAPOEiIyJY4qyWAAScnJylA6BTADzhIiMiWOKstqtABRCbBdC5Ash1EKIM0KIp9tr33R9PXv2VDoEMgHMEyIyJo4pymrPGcA3AHSTUjoDeBDAa0KIyHbcP11DcnKy0iGQCWCeEJExcUxRVrsVgFLKZClljf5u461He+2fri0sLEzpEMgEME+IyJg4piirXc8BFEJ8KISoBJAKIB/A4Ra2eUYIcVIIcTI/Px8lJSXIz89Hbm4uysrKkJGRgaqqKqSkpECn0yE+Ph4AEBcXBwCIj4+HTqdDSkoKqqqqkJGRgbKyMuTm5kLfX2ZmJjQaDVJTU6HVapGQkHBFH/p/ExMTUVNTg/T0dKjVamRnZ6OoqAhFRUXIzs6GWq1Geno6ampqkJiY2GIfCQkJ6BbgAyFEm28qW9VNtfcL9LvuY/rll1+u+5h8vH3bvG8bK6ubit3e2u6m2gf6Bhj8d9JqtUhNTYVGo0FmZmanyD1jPqaYmJhO95iU/DuR6Wqv3PMNCLqp8a+Lr5+ir6dAb++bij/A29usxwhjPqaWCCll67P/JgghLAEMBXAngNVSyrprbRsVFSVPnjzZXqHdMkIIyJXObW//ihohW0La3D5pVhJu5u8shMD7c79vU9vn1t+FNZPvb/O+X9x7COeXnGhz+8DVI2/qsRPdCkIIdF1ysM3ts1Y/oNiYkjQrCSm9+7R53/3SUts8ngDmNaYYJU8UHP+EEDedKxy/b54QIk5KGdV8ebt/C1hKWS+l/BlAAID57b1/uhpnJMgQzBMios5DyZ+BUYHnAHYIkZH8Lg7dGPOEiKjzaJcCUAjRRQgxRQjhKISwFEKMB/A4gLYfByCj0Z93QHQ9zBMios5D1U77kWg43LsODUVnFoD/J6U80E77p+sIDg5WOgQyAcwTIqLOw+AZQCHEohaWCSHEphu1lVIWSylHSSldpZTOUspQKeUnrQ2Wbo3s7GylQyATwDwhIuo8WnMIeIYQ4in9HSGEALANDV/mIBPm7e2tdAhkApgnRESdR2sKwHsALBZCTG78KZc9ANwATLglkVG7KS8vVzoEMgHMEyKizsPgAlBKmQ9gPIDVAH4EYAVgYpOre5CJsrW1VToEMgHMEyKizuO6XwIRQsxuYfE+AFMBbEfDYWFIKW94HiARERERdQw3+hbw9GssTwUwpfH/EgALQBNWXV2tdAhkApgnRESdx3ULQCnl6PYKhJTj6uqqdAhkApgnRESdR6t/B1AI0QWAY9NlUsq/jBYRtbvCwkI4O7f9uqJkHpgnRESdh8EFoBDiHgAbAfg2WyUBWBozKGpfQUFBSodAJoB5QkTUebTmZ2A+APAPAA5SSosmNxZ/Ju7MmTNKh0AmgHlCRNR5tOYQsBuA9VJKeauCIWWEhoYqHQKZAOYJEVHn0ZoZwI0AnrxVgZBy4uLilA6BTADzhIio82jNDOAQAM8LIZYCKGi6Qko50qhRUbuKjIxUOgQyAcwTIqLOozUF4IbGG3UycXFxfHOnG2KeEBF1HgYXgFLKT29lIKQcvqmTIZgnRESdR6t+B1AI4Q1gEABPAEK/nJeCM20JCQkICwtTOgzq4JgnRESdR2t+B/AhNFz/Nx1AfwDJAEIA/AxeCs6k9e/fX+kQyAQwT4iIOo/WfAv4NQBPSikjAFxq/PcZAPxqoIk7e/as0iGQCWCeEBF1Hq0pAIOklJ81W/YpgBlGjIcUEBAQoHQIZAKYJ0REnUdrCsCixnMAASBTCDEUQA/wMnAmr6SkROkQyAQwT4iIOo/WFICfALij8f/vAvgBQAKAD40dFLUvR0dHpUMgE8A8ISLqPFrzMzCrm/x/qxDiRwCuAP7X+GFRe6qrq1M6BDIBzBMios7jhjOAQgh7IcQ/hBBfCyHeEUI4CyFuA/AegF8AFN3yKOmW0ul0SodAJoB5QkTUeRgyA/gBgAgARwDcCyAUQB80fAFkjpSSJwaZOHt7e6VDIBPAPCEi6jwMOQdwPIBxUsolAO4DcBeAqVLKFYYWf0IIGyHERiFElhCiQghxWghx703ETUZUWlqqdAhkApgnRESdhyEFoKOUsggApJQ5ADRSyp9auR8VgPMARgFwAbACwF4hRLdW9kO3gJ+fn9IhkAlgnhARdR6GHAJWCSFGo8ml35rfl1Ieu14HUspLAF5usuigEOIcgEgAma2Il26Bc+fOoV+/fkqHQR0c84SIqPMwpAAswpWXervQ7L4EcFtrdtr4e4LBaLicHCmsT58+SodAJoB5QkTUedzwELCUspuUsvt1bq0t/qwA7ADwqZQytYX1zwghTgohTubn56OkpAT5+fnIzc1FWVkZMjIyUFVVhZSUFOh0OsTHxwMA4uIarkgXHx8PnU6HlJQUVFVVISMjA2VlZcjNzYW+v8zMTGg0GqSmpkKr1SIhIeGKPvT/JiYmoqamBl18/SCEaPNNadY3iM/S0rJDx3+z1Go10tPTUVNTg8TERABX/60TEhKg1WqRmpoKjUaDzMzMDpF76enpUKvVyM7ORlFREYqKipCdna3IYzp58mSne0xK/p3IdLVX7t0sG0vc1HuXla1K0fc+laVVm/dtY9X2tkII2NvY3VR7f++GU2Y6yrjXEiGlvOk/kqGEEBYAdgJwBjBRSnndHxaLioqSJ0+ebJfYrkcIga5LDra5fdbqByBXOrd9/6+oEbIlpM3tk2YlIaV322dv+qWl4v2537ep7XPr78Kayfe3ed8v7j2E80tOtLl94OqRaM8cJzKEKY8pSo4ngHmNKaacJwDfezrKe48QIk5KGdV8eWuuBHKzAQgAGwF4A4i+UfFHRB0LZ66IiDoPg68EYgQfAegLYKyUsqod90tERhAZGal0CEREZCTtMgMohOgKYC6AcAAFQghN421ae+yfiG6e/pwSIiIyfe0yAyilzEKTn40hItMTHh6udAhERGQk7XYOIBGZNmN8K5GIiDoGFoBEZJDu3bsrHQIRERkJC0AiMkheXp7SIRARkZGwACQig7i7uysdAhERGQkLQCIySGVlpdIhEBGRkbAAJCKDWFhwuCAi6iw4ohORQaysrJQOgYiIjIQFIBEZRKPRKB0CEREZCQtAIjKIp6en0iEQEZGRsAAkIoPk5OQoHQIRERkJC0AiMkjPnj2VDoGIiIyEBSARGSQ5OVnpEIiIyEhYABKRQcLCwpQOgYiIjIQFIBEZJC4uTukQiIjISFgAEpFBIiMjlQ6BiIiMhAUgERmEM4BERJ0HC0AiMghnAImIOg8WgERkkMTERKVDICIiI2EBSEQGCQ4OVjoEIiIyEhaARGSQ7OxspUMgIiIjYQFIRAbx9vZWOgQiIjISFoBEZJDy8nKlQyAiIiNhAUhEBrG1tVU6BCIiMpJ2KwCFEM8JIU4KIWqEEFvaa79EREREdCVVO+4rD8BrAMYDsGvH/RKREVRXVysdAhERGUm7FYBSyn0AIISIAhDQXvslIuNwdXVVOgQiIjISngNIRAYpLCxUOgQiIjKSDlcACiGeaTxX8GR+fj5KSkqQn5+P3NxclJWVISMjA1VVVUhJSYFOp0N8fDyA/16nND4+HjqdDikpKaiqqkJGRgbKysqQm5sLfX+ZmZnQaDRITU2FVqtFQkLCFX3o/01MTERNTY0CzwIZk1qtRnp6Ompqai5fzaL53zohIQFarRapqanQaDTIzMxsU+75BgRBCNHmm721ZZvbqmxUN7VvO9X12wcHB193vY217U3t38bK6iafO7s2tw3yC7ypMSI9PR1qtRrZ2dkoKipCUVERsrOzr5t7ZLpuZoxozfsTmb6bGSOM+f7UkvY8B9AgUsqPAXwMAFFRUdLT0/OK9W5ubgCAfv36AQAGDBgA4L/XKdXf16/v0aPHFe0AQN9nnz59AABhYWFX9KH/NzQ01GiPi5Tj7OwMZ2dnAP/9mzb/W+tzQJ8Tjo6OV/VjSO4V5J5H1yUH2xxr1uoHIFc6t6mteEWNkC0hbd530qwkpPTu0+b2/dJS8f7c79vc/rn1d2HN5Pvb3P7FvYdwfsmJNrUNXD0S/v7+l++3dozo1asXAFzOs6aulXtkuhwdHds8RjRdb8j7E5m2mxkjjPn+1JIONwNIRERERLdWu80ACiFUjfuzBGAphLAFoJVSatsrBiIiIiJq3xnAFQCqACwF8ETj/1e04/6JiIiICO37MzAvA3i5vfZHRERERC3jOYBEREREZoYFIBEREZGZYQFIREREZGZYABIRERGZGRaARERERGaGBSARERGRmWEBSERERGRmWAASERERmRkWgERERERmhgUgERERkZlhAUhERERkZlgAEhEREZkZFoBEREREZoYFIBEREZGZYQFIREREZGZYABIRERGZGRaARERERGaGBSARERGRmWEBSERERGRmWAASERERmRkWgERERERmhgUgERERkZlhAUhERERkZlgAEhEREZkZFoBEREREZoYFIBEREZGZYQFIREREZGaElFLpGK5JCFEMIEvpOMyAJ4ASpYOgDo95QoZgnpChmCvto6uU0qv5wg5dAFL7EEKclFJGKR0HdWzMEzIE84QMxVxRFg8BExEREZkZFoBEREREZoYFIAHAx0oHQCaBeUKGYJ6QoZgrCuI5gERERERmhjOARERERGaGBSARERGRmWEBSERERGRmWACaISGESgjxpxAiXelYqONinpChmCtkCOZJx6JSOgBSxDwAXQC4CiEcpJSXlA6IOiTmCRmKuUKGYJ50IJwBNDNCCBcAKwE8B6AeQIiyEVFHxDwhQzFXyBDMk46HBaD5+V8Af0kpdwE4A+B2heOhjol5QoZirpAhmCcdDAtAMyKEuA3AAgBLGhclo/FFKIRwEUL8LoTQCCH4ycyM3SBPBgkh/k8IcUIIsUsIYaVUnKS8G+SKtxDiVyHEcSHEMSGEr1JxkrKulydNtnlcCFHc3rGZMxaA5uUtAN9JKX9svJ8MIKzx/5UA7gfwuQJxUcdyvTw5D2CMlHIkgEwAE9s9OupIrpcrJQDukFKOArAVwFPtHx51ENfLEwghLAFMQsP4Qu2EXwIxE0KIOwBEA1ALIQoaF9sB0AGAlLIOQLEQQqEIqSMwIE/ym2xeq19O5seAXKlvsrkTGt70yczcKE8aPQ7gMwCL2jk8s8YZQDMgGqq6dwCsA9AbQHjjbRwavo0VpFhw1GG0Jk+EEF0bl3/d7oGS4gzNFSFEuBAiBg0n/scrEiwpxpA8aZz9mwxgj0Jhmi3OAJqHaQC8AfxdSqnRLxRCFAKoQMO5GNkKxUYdh0F5IoRwBrANwKzGmWMyPwblipTyNIDBQojJAF5Cw8+AkPkwJE9GA9grpdTxCFT7ElJKpWOgDkQIsQXAGillktKxUMcjhFABOADgbSnl90rHQx2XEMJaSlnb+P/xAMZLKRcqHBZ1MEKI1QAi0HBIeCiAT6WUzysblXlgAUiXCSEOo2F6PgvAeinlFkUDog5HCDEdwL8AJDYu+khKyUM3dBUhxCAAa9Dwm2/VAGY3O4eU6ApCiJNSyiil4zAXLACJiIiIzAy/BEJERERkZlgAEhEREZkZFoBEREREZoYFIBEREZGZYQFIREREZGZYABIRERGZGRaARNRpCCG2CCFeUzqOaxFCLBNCbFA6DiIiFoBEZJKEED8KIcqEEDbXWH+nECKnveO63v6llK9LKZ9WKiYiIj0WgERkcoQQ3QCMACABPHiL9sFrpRNRp8UCkIhM0QwAvwHYAmBm85VCCAcA3wDwE0JoGm9+QggLIcRSIUSGEOKCEGKvEMK9sU03IYQUQjwlhMgGcEwIMUsI8bMQYk3jbOM5IcS9TfbzpBDiTyFEhRDiLyHE3Bvs/2UhxPbGbb4RQjzXLO4EIcQjjf/vI4T4VghRKoRIE0JMbrLdfUKIlMb95gohXjTqs0tEnR4LQCIyRTMA7Gi8jRdCeDddKaW8BOBeAHlSSsfGWx6ABQAeAjAKgB+AMgAfNOt7FIC+AMY33h8MIA2AJ4C3AGwUQojGdUUAHgDgDOBJAO8KIQZcZ/9N7QLwuP6OEKIfgK4ADjUWkN8C2AmgC4ApAD5s3AYANgKYK6V0AhAC4JhhTxsRUQMWgERkUoQQd6ChUNorpYwDkAFgqoHN5wFYLqXMkVLWAHgZwKPNDve+LKW8JKWsaryfJaX8REpZD+BTAL4AvAFASnlISpkhGxwHcBQNh6YN8SWAcCFE18b70wDsa4zrAQCZUsrNUkqtlPIUgC8ATGrctg5APyGEs5SyTEoZb+A+iYgAsAAkItMzE8BRKWVJ4/2daOEw8DV0BfClEKJcCFEO4E8A9Wgs6Bqdb9amQP8fKWVl438dAUAIca8Q4rfGw7TlAO5Dw0zhDUkpKwAcQsPsHtAwG7ijSZyD9XE29j0NgE/j+ujGfWUJIY4LIYYask8iIj2e5ExEJkMIYQdgMgBLIYS+MLMB4CqECGu2uWyhi/MAZkspf2mh727XaddSLDZomJWbAeArKWWdEGI/AP3hYUP62QVgpRDiBABbAD80ifO4lPLulhpJKWMBTBRCWAF4DsBeAIGGxE1EBHAGkIhMy0NomLHrByC88dYXwE9oKMSaKgTgIYRwabJsHYBV+sOuQggvIcTENsZijYbisxiAtvHLIeNusP/mDqNhtu9VAHuklLrG5QcBBAshpgshrBpvA4UQfYUQ1kKIaUIIFyllHQA1AN01+iciahELQCIyJTMBbJZSZkspC/Q3AO+j4RDp5aMaUspUNMyw/dV4GNUPwHsADgA4KoSoQMM3iQe3JZDGQ7jPo2H2rQwN5yEeuMH+m/dRA2AfgLFoOJTdtO9xaDg8nIeGw9Cr0VBwAsB0AJlCCDUazmuc1pbHQETmS0hp0NEOIiIiIuokOANIREREZGZYABIRERGZGRaARERERGaGBSARERGRmWEBSERERGRmWAASERERmRkWgERERERmhgUgERERkZn5/7JG+oeJgfdKAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_barplot(rank_results, legend_title='MCDA methods', num = 1)" ] }, { "cell_type": "markdown", "id": "96a820b4", "metadata": {}, "source": [ "Calculate correlations between rankings using Weighted Spearman correlation coefficient." ] }, { "cell_type": "code", "execution_count": 25, "id": "29b19a17", "metadata": {}, "outputs": [], "source": [ "method_types = list(rank_results.columns)\n", "dict_new_heatmap_rw = Create_dictionary()\n", "for el in method_types:\n", " dict_new_heatmap_rw.add(el, [])\n", "\n", "\n", "# heatmaps for correlations coefficients\n", "for i, j in [(i, j) for i in method_types[::-1] for j in method_types]:\n", " dict_new_heatmap_rw[j].append(corrs.weighted_spearman(rank_results[i], rank_results[j]))\n", "\n", "df_new_heatmap_rw = pd.DataFrame(dict_new_heatmap_rw, index = method_types[::-1])\n", "df_new_heatmap_rw.columns = method_types" ] }, { "cell_type": "markdown", "id": "5c32e45f", "metadata": {}, "source": [ "Display the heat map of correlations." ] }, { "cell_type": "code", "execution_count": 26, "id": "de9ad308", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# correlation matrix with rw coefficient\n", "draw_heatmap(df_new_heatmap_rw, r'$r_w$', num = 1)" ] }, { "cell_type": "markdown", "id": "e97e4b74", "metadata": {}, "source": [ "## AHP" ] }, { "cell_type": "markdown", "id": "174e86b7", "metadata": {}, "source": [ "### Classical usage of AHP\n", "\n", "The classical application of AHP using pairwise comparisons of criteria and alternatives by decision-maker based on:\n", "\n", "Papathanasiou, J., & Ploskas, N. (2018). Ahp. In Multiple Criteria Decision Aid \n", "(pp. 109-129). Springer, Cham.\n", "DOI: https://doi.org/10.1007/978-3-319-91648-4_5" ] }, { "cell_type": "markdown", "id": "0028ed69", "metadata": {}, "source": [ "Step 1a. Provide matrix with pairwise comparison values of criteria" ] }, { "cell_type": "code", "execution_count": 27, "id": "6a57ac5a", "metadata": {}, "outputs": [], "source": [ "PCcriteria = np.array([[1, 1, 5, 3], [1, 1, 5, 3], \n", "[1/5, 1/5, 1, 1/3], [1/3, 1/3, 3, 1]])" ] }, { "cell_type": "code", "execution_count": 28, "id": "666493a2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1. , 1. , 5. , 3. ],\n", " [1. , 1. , 5. , 3. ],\n", " [0.2 , 0.2 , 1. , 0.33333333],\n", " [0.33333333, 0.33333333, 3. , 1. ]])" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "PCcriteria" ] }, { "cell_type": "markdown", "id": "cc0e4d64", "metadata": {}, "source": [ "Step 1b. Provide matrices with pairwise comparison values for alternatives" ] }, { "cell_type": "code", "execution_count": 29, "id": "33d4cb67", "metadata": {}, "outputs": [], "source": [ "PCM1 = np.array([[1, 5, 1, 1, 1/3, 3],\n", "[1/5, 1, 1/3, 1/5, 1/7, 1],\n", "[1, 3, 1, 1/3, 1/5, 1],\n", "[1, 5, 3, 1, 1/3, 3],\n", "[3, 7, 5, 3, 1, 7],\n", "[1/3, 1, 1, 1/3, 1/7, 1]])\n", "PCM2 = np.array([[1, 7, 3, 1/3, 1/3, 1/3],\n", "[1/7, 1, 1/3, 1/7, 1/9, 1/7],\n", "[1/3, 3, 1, 1/5, 1/5, 1/5],\n", "[3, 7, 5, 1, 1, 1],\n", "[3, 9, 5, 1, 1, 1],\n", "[3, 7, 5, 1, 1, 1]])\n", "PCM3 = np.array([[1, 1/9, 1/7, 1/9, 1, 1/5],\n", "[9, 1, 1, 1, 5, 3],\n", "[7, 1, 1, 1, 5, 1],\n", "[9, 1, 1, 1, 7, 3],\n", "[1, 1/5, 1/5, 1/7, 1, 1/3],\n", "[5, 1/3, 1, 1/3, 3, 1]])\n", "PCM4 = np.array([[1, 1/5, 1/5, 1/3, 1/7, 1/5],\n", "[5, 1, 1, 3, 1/3, 1],\n", "[5, 1, 1, 1, 1/3, 1],\n", "[3, 1/3, 1, 1, 1/7, 1],\n", "[7, 3, 3, 7, 1, 5],\n", "[5, 1, 1, 1, 1/5, 1]])" ] }, { "cell_type": "markdown", "id": "c5546656", "metadata": {}, "source": [ "Step 2. Create the AHP method object and check the consistency of matrix with criteria comparison. Values equal and below 0.1 $(\\leq 0.1)$ denote that the matrix is consistent and it is correct." ] }, { "cell_type": "code", "execution_count": 30, "id": "9fe4271d", "metadata": {}, "outputs": [], "source": [ "ahp = AHP()" ] }, { "cell_type": "code", "execution_count": 31, "id": "d1b9e4b6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Inconsistency index: 0.01610868948440318\n" ] } ], "source": [ "ahp._check_consistency(PCcriteria)" ] }, { "cell_type": "markdown", "id": "ed8936e9", "metadata": {}, "source": [ "Step 3. Calculate the priority vector of criteria (criteria weights). The AHP method can be used only for criteria weights determination incorporating a decision-maker." ] }, { "cell_type": "code", "execution_count": 32, "id": "1ca35d17", "metadata": {}, "outputs": [], "source": [ "weights = ahp._calculate_eigenvector(PCcriteria)" ] }, { "cell_type": "markdown", "id": "9ed99f63", "metadata": {}, "source": [ "AHP criteria weights:" ] }, { "cell_type": "code", "execution_count": 33, "id": "60ad8eda", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.38986164, 0.38986164, 0.06792478, 0.15235193])" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "weights" ] }, { "cell_type": "markdown", "id": "71f89db5", "metadata": {}, "source": [ "Step 4. Form pairwise comparison matrices of the alternatives for each criterion." ] }, { "cell_type": "code", "execution_count": 34, "id": "9a2802f2", "metadata": {}, "outputs": [], "source": [ "alt_matrices = []\n", "alt_matrices.append(PCM1)\n", "alt_matrices.append(PCM2)\n", "alt_matrices.append(PCM3)\n", "alt_matrices.append(PCM4)" ] }, { "cell_type": "markdown", "id": "b44ed776", "metadata": {}, "source": [ "Step 5. This step checks the consistency of pairwise comparison matrices of the alternatives. Values equal and below 0.1 denote that the matrix is consistent and it is correct." ] }, { "cell_type": "code", "execution_count": 35, "id": "2b51d715", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Inconsistency index: 0.03349113123332669\n", "Inconsistency index: 0.026437064499443722\n", "Inconsistency index: 0.022144721786307425\n", "Inconsistency index: 0.039785112041738534\n" ] } ], "source": [ "calculate_priority_vector_method = ahp._calculate_eigenvector\n", "pref = ahp._classic_ahp(alt_matrices, weights, calculate_priority_vector_method)" ] }, { "cell_type": "markdown", "id": "43b49b33", "metadata": {}, "source": [ "AHP utility (preference) function values:" ] }, { "cell_type": "code", "execution_count": 36, "id": "0e7a3c01", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.11737682, 0.07132502, 0.09472062, 0.21164765, 0.35008026,\n", " 0.15484963])" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pref" ] }, { "cell_type": "code", "execution_count": 37, "id": "289b5749", "metadata": {}, "outputs": [], "source": [ "rank = rank_preferences(pref, reverse = True)" ] }, { "cell_type": "markdown", "id": "a7ecd7b5", "metadata": {}, "source": [ "AHP ranking" ] }, { "cell_type": "code", "execution_count": 38, "id": "fe8244ba", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([4, 6, 5, 2, 1, 3])" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rank" ] }, { "cell_type": "markdown", "id": "07b039cc", "metadata": {}, "source": [ "### Another usage of AHP for ranking generation with numerical performance values, weights and criteria types" ] }, { "cell_type": "markdown", "id": "8d639319", "metadata": {}, "source": [ "If you have a decision matrix with numerical performance values, a vector with numerical criteria weights, and determined criteria types (profit or cost), you can use the AHP method like other MCDA methods (for example, SAW):" ] }, { "cell_type": "code", "execution_count": 39, "id": "07f4f08b", "metadata": {}, "outputs": [], "source": [ "matrix = np.array([[0.75, 0.50, 0.75, 0, 0, 0, 1],\n", "[0.75, 1, 0.75, 0, 0, 0, 0.75],\n", "[0.75, 0.75, 0.75, 0, 0.50, 0.25, 1],\n", "[0.50, 0.50, 0.75, 1, 0.50, 0, 0.75]])\n", "\n", "weights = np.array([0.1, 0.1, 0.1, 0.15, 0.2, 0.25, 0.1])\n", "\n", "types = np.array([1, 1, 1, 1, 1, 1, 1])\n", "\n", "ahp = AHP(normalization_method=norms.linear_normalization)\n", "pref = ahp(matrix, weights, types)" ] }, { "cell_type": "code", "execution_count": 40, "id": "398a8a57", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.35 , 0.375 , 0.825 , 0.64166667])" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pref" ] }, { "cell_type": "code", "execution_count": 41, "id": "24f4def3", "metadata": {}, "outputs": [], "source": [ "rank = rank_preferences(pref, reverse = True)" ] }, { "cell_type": "code", "execution_count": 42, "id": "4146a303", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([4, 3, 1, 2])" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rank" ] }, { "cell_type": "code", "execution_count": null, "id": "f07f08ed", "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.5" } }, "nbformat": 4, "nbformat_minor": 5 }