6-shifted-Rastrigin/shifted_rastrigin_d500.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import math\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from numba import jit\n",
    "import pygmo as pg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "funcs = {\"sphere\": 0, \"schwefel\": 1, \"rosenbrock\": 2, \"rastrigin\": 3, \"griewank\": 4, \"ackley\": 5}\n",
    "funcs_dispname = {\"sphere\": \"F1 : Shifted Sphere Function\", \n",
    "                  \"schwefel\": \"F2 : Schwefel’s Problem 2.21\",\n",
    "                  \"rosenbrock\": \"F3 : Shifted Rosenbrock’s Function\",\n",
    "                  \"rastrigin\": \"F4 : Shifted Rastrigin’s Function\",\n",
    "                  \"griewank\": \"F5 : Shifted Griewank’s Function\",\n",
    "                  \"ackley\": \"F6 : Shifted Ackley’s Function\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_values(func):\n",
    "    val_path = os.path.join('../data/', func + '.csv')\n",
    "    bias_path = '../data/f_bias.csv'\n",
    "    ss_path = '../data/search_space.csv'\n",
    "    \n",
    "    func_df = pd.read_csv(val_path)\n",
    "    bias_df = pd.read_csv(bias_path)\n",
    "    searchspace_df = pd.read_csv(ss_path)\n",
    "\n",
    "    funcval = func_df.fvalue.values\n",
    "    funcbias = bias_df.fvalue.values[funcs[func]]\n",
    "    search_space = list(searchspace_df.iloc[funcs[func],])\n",
    "    return funcval, funcbias, search_space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function evaluation definitions\n",
    "\n",
    "@jit(nopython=True)\n",
    "def eval_cost(x, dim):\n",
    "    \n",
    "    if func_name == \"sphere\":\n",
    "        F = 0\n",
    "        for i in range(dim - 1):\n",
    "            z = x[i] - funcval[i]\n",
    "            F += z * z\n",
    "        result = F + funcbias\n",
    "    elif func_name == \"schwefel\":\n",
    "        F = abs(x[0]- funcval[0])\n",
    "        for i in range(1,dim - 1):\n",
    "            z = x[i] - funcval[i]\n",
    "            F = max(F, abs(z))\n",
    "        result = F + funcbias\n",
    "    elif func_name == \"rosenbrock\":\n",
    "        F = 0\n",
    "        y = np.empty(dim)\n",
    "        for i in range(dim - 1):\n",
    "            y[i] = x[i] - funcval[i] +1\n",
    "        for i in range(dim-2):\n",
    "            F += 100 * ((y[i]**2-y[i+1])**2) + (y[i]-1)**2\n",
    "        result = F + funcbias\n",
    "    elif func_name == \"rastrigin\":\n",
    "        F = 0\n",
    "        for i in range(dim - 1):\n",
    "            z = x[i] - funcval[i]\n",
    "            F += z ** 2 - 10 * math.cos(2 * math.pi * z) + 10\n",
    "        result = F + funcbias\n",
    "        \n",
    "    elif func_name == \"griewank\":\n",
    "        F1 = 0\n",
    "        F2 = 1\n",
    "        for i in range(dim - 1):\n",
    "            z = x[i] - funcval[i]\n",
    "            F1 += z ** 2 / 4000\n",
    "            F2 += math.cos(z / math.sqrt(i + 1))\n",
    "        result = F1 - F2 + 1 + funcbias\n",
    "    elif func_name == \"ackley\":\n",
    "        Sum1 = 0\n",
    "        Sum2 = 0\n",
    "        for i in range(dim - 1):\n",
    "            z = x[i] - funcval[i]\n",
    "            Sum1 += z ** 2\n",
    "            Sum2 += math.cos(2 * math.pi * z)\n",
    "        result = -20 * math.exp(-0.2 * math.sqrt(Sum1 / dim)) - math.exp(Sum2 / dim) + 20 + math.e + funcbias\n",
    "    else:\n",
    "        result = 0\n",
    "    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define UDP problem Class\n",
    "\n",
    "class My_problem:\n",
    "    def __init__(self, dim, bounds, glob_opt):\n",
    "        self.lower_bound = bounds[0]\n",
    "        self.upper_bound = bounds[1]\n",
    "        self.dimension = dim\n",
    "        self.fitness_per_eval = []\n",
    "        self.glob_opt = glob_opt\n",
    "\n",
    "    def fitness(self, x):\n",
    "        result = abs(eval_cost(x, self.dimension)-funcbias)\n",
    "        return [result]\n",
    "\n",
    "    def get_bounds(self):\n",
    "        x_min = self.lower_bound * np.ones(self.dimension)\n",
    "        x_max = self.upper_bound * np.ones(self.dimension)\n",
    "        return x_min, x_max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to run selected algorithm on defined problem\n",
    "\n",
    "def solve_pb(dim, my_algo, bounds, optim, popsize):\n",
    "    pop = None\n",
    "    prob = pg.problem(My_problem(dim, bounds, optim))\n",
    "    pop = pg.population(prob, popsize)\n",
    "\n",
    "    my_algo.set_verbosity(100)\n",
    "\n",
    "    t1 = time.time()\n",
    "    pop = my_algo.evolve(pop)\n",
    "    t2 = time.time()\n",
    "\n",
    "    time_diff = t2-t1\n",
    "    \n",
    "    if my_algo.get_name().split(\":\")[0] == \"PSO\":\n",
    "        extract_algo = my_algo.extract(pg.pso)\n",
    "    elif my_algo.get_name().split(\":\")[0] == \"GPSO\":\n",
    "        extract_algo = my_algo.extract(pg.pso_gen)\n",
    "    elif my_algo.get_name().split(\":\")[0] == \"DE\":\n",
    "        extract_algo = my_algo.extract(pg.de)\n",
    "    elif my_algo.get_name().split(\":\")[0] == \"saDE\":\n",
    "        extract_algo = my_algo.extract(pg.sade)\n",
    "    elif my_algo.get_name().split(\":\")[0] == \"sa-DE1220\":\n",
    "        extract_algo = my_algo.extract(pg.de1220)\n",
    "    elif my_algo.get_name().split(\":\")[0] == \"SGA\":\n",
    "        extract_algo = my_algo.extract(pg.sga)\n",
    "    elif my_algo.get_name().split(\":\")[0] == \"ABC\":\n",
    "        extract_algo = my_algo.extract(pg.bee_colony)\n",
    "    \n",
    "    log = extract_algo.get_log()\n",
    "    curve = [x[2] for x in log]\n",
    "    niter = log[-1][0]\n",
    "    \n",
    "    return pop, curve, niter, time_diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to make print report of function solving\n",
    "\n",
    "def print_solution(dimension, my_algo, pop_evolved, log, niter, duration):\n",
    "    algorithm_name = my_algo.get_name()\n",
    "    parameters = my_algo.get_extra_info()\n",
    "    solution_x = pop_evolved.champion_x\n",
    "    fitness = pop_evolved.champion_f[0]\n",
    "    n_evals = pop_evolved.problem.get_fevals()\n",
    "    print('-'*60)\n",
    "    print(\"Function: %s\" % funcs_dispname[func_name])\n",
    "    print(\"Problem dimension: %d\" % dimension)\n",
    "    print(\"Search Space : \", search_space)\n",
    "    print(\"Global Optimum: %.2f\" % funcbias)\n",
    "    print('-'*60)\n",
    "    print(\"Algorithm: %s\" % algorithm_name)\n",
    "    print(\"Parameters: \\n%s\" % parameters)\n",
    "    print('-'*60)\n",
    "    print(\"Fitness: %f\" % fitness)\n",
    "    print(\"Solution: \")\n",
    "    with pd.option_context('display.max_rows',8):\n",
    "        print(pd.DataFrame(solution_x, columns=['X']))\n",
    "    print('-'*60)\n",
    "    print(\"Nb of functions evaluations: %d\" % n_evals)\n",
    "    print(\"Stopping criterion: after %d iterations\" % niter)\n",
    "    print(\"computational time: %.3f seconds\" % duration)\n",
    "\n",
    "    plt.plot(log)\n",
    "    plt.xlabel(\"iterations (x100)\")\n",
    "    plt.ylabel(\"fitness: f(x)-f(x*)\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to choose: sphere, schwefel, rosenbrock, rastrigin, griewank, ackley\n",
    "func_name = 'griewank'\n",
    "funcval, funcbias, search_space = read_values(func_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define algorithm\n",
    "\n",
    "gen = 10000\n",
    "algo = pg.algorithm(pg.sade(gen=gen,\n",
    "                            variant=1,\n",
    "                            variant_adptv=1,\n",
    "                            ftol=1e-03,\n",
    "                            xtol=1e-03,\n",
    "                            memory=True,\n",
    "                            seed=37))\n",
    "\n",
    "pop_size = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------------------------------------\n",
      "Function: F5 : Shifted Griewank’s Function\n",
      "Problem dimension: 500\n",
      "Search Space :  [-600, 600]\n",
      "Global Optimum: -180.00\n",
      "------------------------------------------------------------\n",
      "Algorithm: saDE: Self-adaptive Differential Evolution\n",
      "Parameters: \n",
      "\tGenerations: 10000\n",
      "\tVariant: 1\n",
      "\tSelf adaptation variant: 1\n",
      "\tStopping xtol: 0.001\n",
      "\tStopping ftol: 0.001\n",
      "\tMemory: true\n",
      "\tVerbosity: 100\n",
      "\tSeed: 37\n",
      "------------------------------------------------------------\n",
      "Fitness: 0.000002\n",
      "Solution: \n",
      "              X\n",
      "0    558.662314\n",
      "1   -349.792180\n",
      "2     78.780892\n",
      "3     -5.403767\n",
      "..          ...\n",
      "496  326.948946\n",
      "497  190.405157\n",
      "498 -437.142800\n",
      "499 -118.258861\n",
      "\n",
      "[500 rows x 1 columns]\n",
      "------------------------------------------------------------\n",
      "Nb of functions evaluations: 555400\n",
      "Stopping criterion: after 5501 iterations\n",
      "computational time: 9.682 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEGCAYAAACkQqisAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deZxU1Z338c+3u+luoIFu6GZrNhfcMMoW3DKJK6KTDCajiZpEnDhDJqOJ8XGejGaeiTNmnEnGMZnsExNJdMbEGE0iSYiEIFmMUQF3QKRdaVBohJZ9a37PH3Uby7bppaC6uqq+79erXlX31L23fgfb+tU5555zFRGYmZlloiTXAZiZWf5yEjEzs4w5iZiZWcacRMzMLGNOImZmlrGyXAfQ02pra2PcuHG5DsPMLK8sXbp0Q0TUtS0vuiQybtw4lixZkuswzMzyiqSX2yt3d5aZmWXMScTMzDLmJGJmZhlzEjEzs4w5iZiZWcacRMzMLGNOImZmljEnkS66/aGX+PmTa3MdhplZr+Ik0kU/fPQV7nvCScTMLF3Wkoik0ZIWSVohaZmkq5Pyf5a0RtITyeP8tGOul9QgaaWkc9PKZyRlDZKuSys/TNIjklZJ+pGk8mzVp25ABa9v25Wt05uZ5aVstkT2AtdGxLHAycCVko5L3vtyRExMHvMAkvcuBiYAM4BvSiqVVAp8AzgPOA64JO08X0zONR7YBFyRrcoM6V/Ohq1OImZm6bKWRCLi1Yh4LHm9BVgB1HdwyEzgrojYFREvAg3AtOTREBEvRMRu4C5gpiQBZwL3JMffDlyQndpAbVUFG7bsztbpzczyUo+MiUgaB0wCHkmKrpL0lKQ5kmqSsnpgddphjUnZgcqHAM0RsbdNeXufP1vSEklLmpqaMqpD7YAKduxpYfvuvZ3vbGZWJLKeRCRVAfcCn46IzcC3gCOAicCrwC2tu7ZzeGRQ/vbCiFsjYmpETK2re9tKxl0ypH9quMWtETOzN2U1iUjqQyqB3BkRPwGIiHUR0RIR+4DvkOquglRLYnTa4aOAtR2UbwCqJZW1Kc+K2gEVAGzw4LqZ2X7ZvDpLwG3Aioj4Ulr5iLTd3g88k7yeC1wsqULSYcB44FFgMTA+uRKrnNTg+9yICGARcGFy/CzgvmzVp7Z/kkS2OImYmbXK5k2pTgM+Cjwt6Ymk7LOkrq6aSKrr6SXg4wARsUzS3cByUld2XRkRLQCSrgLmA6XAnIhYlpzvH4C7JP0r8DippJUVtQNS3Vmvb3N3lplZq6wlkYh4kPbHLeZ1cMxNwE3tlM9r77iIeIE3u8OyavD+MRG3RMzMWnnGehdVlJUysLLMLREzszROIt1QW1VBkyccmpnt5yTSDakJh04iZmatnES6YUhVubuzzMzSOIl0Q21VhdfPMjNL4yTSDUOqymnevoc9LftyHYqZWa/gJNINtVWpCYcb3aVlZgY4iXRLbVUyV8RdWmZmgJNIt7S2RDZsdUvEzAycRLqlNYm87paImRngJNItQ9ydZWb2Fk4i3VBVUUZFWYm7s8zMEk4i3SDJc0XMzNI4iXRTbVW5WyJmZgknkW4aUlXhgXUzs4STSDelWiJOImZm4CTSbamWyG5Sd+c1MytuTiLdVFtVwd59wRs79uQ6FDOznHMS6aY3lz7x4LqZmZNIN7259InHRczMnES6ybPWzcze5CTSTW+un+XuLDMzJ5FuqulXToncEjEzAyeRbistEYP7e9a6mRk4iWTE62eZmaU4iWRgSFW5lz4xM8NJJCOploi7s8zMnEQyMKS/F2E0MwMnkYzUDihn2+4WduxuyXUoZmY5lbUkImm0pEWSVkhaJunqpHywpAWSViXPNUm5JH1VUoOkpyRNTjvXrGT/VZJmpZVPkfR0csxXJSlb9UlX29+z1s3MILstkb3AtRFxLHAycKWk44DrgIURMR5YmGwDnAeMTx6zgW9BKukANwAnAdOAG1oTT7LP7LTjZmSxPvvVDvCsdTMzyGISiYhXI+Kx5PUWYAVQD8wEbk92ux24IHk9E7gjUh4GqiWNAM4FFkTExojYBCwAZiTvDYyIP0VqXfY70s6VVUP2t0Q8uG5mxa1HxkQkjQMmAY8AwyLiVUglGmBosls9sDrtsMakrKPyxnbKs652QOvSJ26JmFlxy3oSkVQF3At8OiI2d7RrO2WRQXl7McyWtETSkqamps5C7tSQ/u7OMjODLCcRSX1IJZA7I+InSfG6pCuK5Hl9Ut4IjE47fBSwtpPyUe2Uv01E3BoRUyNial1d3cFVCqjsU8qAijJ3Z5lZ0cvm1VkCbgNWRMSX0t6aC7ReYTULuC+t/LLkKq2TgTeS7q75wHRJNcmA+nRgfvLeFkknJ591Wdq5sm6I77VuZkZZFs99GvBR4GlJTyRlnwW+ANwt6QrgFeCi5L15wPlAA7Ad+CuAiNgo6fPA4mS/GyNiY/L6E8D3gb7Ar5JHj6hN7rVuZlbMspZEIuJB2h+3ADirnf0DuPIA55oDzGmnfAlw/EGEmbHaqgqeb9qai482M+s1PGM9Q+7OMjNzEslYbVUFm7bvYW/LvlyHYmaWM04iGapN7rW+cZvHRcyseDmJZKj1Xuu+zNfMipmTSIaGVHkRRjMzJ5EMtXZnvb7NScTMipeTSIb2t0S2uDvLzIqXk0iGBlaWUV5awga3RMysiDmJZEhSaq6IWyJmVsScRA5CbVWFB9bNrKg5iRyEIVXlHlg3s6LWrSQiqb+k0mwFk29qqyrcnWVmRa3DJCKpRNKlkn4paT3wLPCqpGWSbpY0vmfC7J1qqyp4fdsuUmtHmpkVn85aIouAI4DrgeERMToihgJ/BjwMfEHSR7IcY69VW1XOnpZg8469uQ7FzCwnOlsK/uyI2NO2MLmfx73AvcndC4tS69InTVt3Mahf0f4zmFkR67AlEhF7JF0KIOniA+2TjcDywejB/QBoWO/7iphZcerKwHq9pA/y1vuZG3B8/UDKy0pY+vLGznc2MytAnQ2s3wAMBn4ADJb0uR6JKk9UlJVyQv0glr68KdehmJnlRGfdWf8CbAQ+AmyMiBt7JKo8MmVcDc+s2czOPS25DsXMrMd1pTtrbUTcBazJdjD5aMqYGna37OPpNW/kOhQzsx7XaRKJiDslnR0RP0wvlzQre2HljyljawDcpWVmRamrM9Y/J+lbyYz1YZJ+Drwvm4HliyFVFRxe258lLzmJmFnx6WoSeQ/wPPAE8CDwg4i4MGtR5ZnJY2t47JVNnrluZkWnq0mkBjiJVCLZBYyVpKxFlWemjq1h47bdvLhhW65DMTPrUV1NIg8Dv4qIGcA7gZHAH7MWVZ5pHRdZ4nERMysyXU0iZ0fEHICI2BERnwKuy15Y+eWIuioG9e3DUo+LmFmR6Wyy4TiAiHil7XsR8XulFP1M9pISMWVsDUtfcRIxs+LS2QKMN0sqAe4DlgJNQCVwJHAGcBZwA9CYzSDzwZSxNTzw7Hqat++mul95rsMxM+sRHSaRiLhI0nHAh4GPASOA7cAKYB5wU0TszHqUeSB9vshZxw7LcTRmZj2jwyQi6aKI+LGk70bEP/ZUUPnoxFHVlJXIScTMikpnA+vXJ8/3dvfEkuZIWi/pmbSyf5a0RtITyeP8tPeul9QgaaWkc9PKZyRlDZKuSys/TNIjklZJ+pGknPYh9S0vZcLIgb5Cy8yKSmdJ5HVJi4DDJM1t++jk2O8DM9op/3JETEwe8wCSLrOLgQnJMd+UVJrcz/0bwHnAccAlyb4AX0zONR7YBFzReXWza8rYwTy5upk9LftyHYqZWY/obGD9z4HJwP8At3TnxMnVW+O6uPtM4K6I2AW8KKkBmJa81xARLwBIuguYKWkFcCZwabLP7cA/A9/qToyH2pSxNcz544ssW7uZiaOrcxmKmVmP6Gwp+N0R8TBwakT8LiJ+B6xMe52JqyQ9lXR31SRl9cDqtH0ak7IDlQ8BmiNib5vydkmaLWmJpCVNTU0Zht25qeOSSYcv+SZVZlYcujTZMCLSv3nnHcTnfQs4ApgIvMqbrZv2llCJDMrbFRG3RsTUiJhaV1fXvYi7YdjASkbV9OUxzxcxsyLR1Rnr6TJeMysi1kVES0TsA77Dm11WjcDotF1HAWs7KN8AVEsqa1Oec1PG1rDkJS/GaGbFIZMk8p1MP0zSiLTN9wOtV27NBS6WVCHpMGA88CiwGBifXIlVTmrwfW6kvqEXAa0rCc8iNSEy56aOrWH9ll00btqR61DMzLKus4H1/ZLxi5HA/ZJKktZER/v/EDgdqJXUSGpm++mSJpLqenoJ+DhARCyTdDewHNgLXBkRLcl5rgLmA6XAnIhYlnzEPwB3SfpX4HHgtq7WJZsmp006HD24X46jMTPLrs4mGw4CrgQuAcp5c9mTYZIeBr4ZEYvaOzYiLmmn+IBf9BFxE3BTO+XzaGccJrlia1rb8lw7ZvhAqirKWPLyRi6YdMCxfjOzgtBZS+Qe4A7gzyKiOf0NSVOAj0o6PCJ6RSugNygtERNHV7P05ebOdzYzy3OdrZ11TgfvLSW1KKO1MWlMNd9Y1MD23XvpV97lHkMzs7zTpYF1SVe02S6VdEN2Qsp/E0dXsy/g6cY3ch2KmVlWdfXqrLMkzZM0QtLxpO50OCCLceW11tnqT6x2l5aZFbYu9bVExKWSPgQ8TWop+EsiwrfHPYAhVRWMGdyPx19xEjGzwtbV7qzxwNWkVvN9idSAuq9f7cDE0dVuiZhZwetqd9bPgX+KiI8D7wFWkZoIaAcwcXQ1r23eyatveNKhmRWuriaRaRGxECBSbgEuyF5Y+W/SmGRcxF1aZlbAOkwikt4FEBGb274XEaskDUwG2q2N40YOpLy0xF1aZlbQOhtY/0tJ/wHcT2pOSOuM9SOBM4CxwLVZjTBPVZSVcuzIgTzuJGJmBayzyYbXJGtmXQhcBIwAdgArgG9HxIPZDzF/TRpdzY8Wr2Zvyz7KSjNZ69LMrHfrrDvr6ojYBCyPiMsj4tyIuCAirncC6dykMdXs2NPCynVbch2KmVlWdPbz+K+S569lO5BC5EmHZlboOksiKyS9BByd3NK29fG0pKd6IL68NmZwPwb3L/ekQzMrWJ2NiVwiaTip+3n8Rc+EVDgkedKhmRW0Tpc9iYjXgBN7IJaCNHF0NQ88u543duxhUN8+uQ7HzOyQ8iVDWdY66fCpRrdGzKzwOIlk2QmjPHPdzAqXk0iWDerbhyPq+ntcxMwKUpeTiKTZHW3bgU0aU8Pjq5uJiFyHYmZ2SHWnJaJOtu0AJo6uZuO23aze6BV9zaywdDmJRMS3O9q2A2uddPj46k05jsTM7NDq6k2prk5W7JWk2yQ9Jml6toMrFMcMH0BlnxJPOjSzgtPVlsjHkuXgpwN1pJZD+ULWoiowZaUlnFDvSYdmVni6mkRaxz/OB74XEU/iMZFumTimmuVrN7Nrb0uuQzEzO2S6mkSWSvo1qSQyX9IAYF/2wio8k0ZXs7tlH8+sedv9vczM8lZXk8gVwHXAOyNiO9CHN1f4tS44+fAhlJaIRc+uz3UoZmaHTFeTyCnAyoholvQR4P8Bb2QvrMJT07+caeMGc/+y13IdipnZIdPVJPItYLukE4HPAC8Dd2QtqgI14/jhNKzfSsP6rbkOxczskOhqEtkbqenWM4GvRMRXgAHZC6swTZ8wDID5bo2YWYHoahLZIul64KPALyWVkhoXOSBJcyStl/RMWtlgSQskrUqea5JySfqqpIbkpleT046Zley/StKstPIpyc2xGpJje/3VYiMG9eXE0dX82knEzApEV5PIh4BdpOaLvAbUAzd3csz3gRltyq4DFkbEeGBhsg1wHjA+ecwm1X2GpMHADcBJwDTghtbEk+wzO+24tp/VK507YRhPNr7B2mYvgWJm+a9LSSRJHPcCFUnRBuCnnRzze2Bjm+KZwO3J69uBC9LK74iUh4FqSSOAc4EFEbExIjYBC4AZyXsDI+JPSTfbHWnn6tVmTBgO4NaImRWEri578jfAPUDreln1wM8y+LxhEfEqQPI8NO18q9P2a0zKOipvbKf8QPHPlrRE0pKmpqYMwj50Dq+rYvzQKl+lZWYFoavdWVcCpwGbASJiFW8mgEOhvfGMyKC8XRFxa0RMjYipdXV1GYZ46Mw4fjiPvriRjdt25zoUM7OD0tUksisi9n/jSSqjgy/tDqxLuqJInltn3jUCo9P2GwWs7aR8VDvleeHcCcPZF/Cb5etyHYqZ2UHpahL5naTPAn0lnQP8GPh5Bp83F2i9wmoWcF9a+WXJVVonA28k3V3zgemSapIB9enA/OS9LZJOTq7KuiztXL3ehJEDqa/u60t9zSzvdTWJXAc0AU8DHwfmkZq1fkCSfgj8CThaUqOkK0it/HuOpFXAOby5EvA84AWgAfgO8HcAEbER+DywOHncmJQBfAL4bnLM88CvuliXnJPEuROG84dVG9i6a2+uwzEzy5iK7ZatU6dOjSVLluQ6DB59cSMf/Paf+Pqlk3jvCSNzHY6ZWYckLY2IqW3Lu3p11mnJ5MDnJL0g6UVJLxz6MIvHlLE1DOlfzv3PuEvLzPJXWRf3uw24BlgK+IYYh0BpiZg+YRhzn1jLzj0tVPYpzXVIZmbd1tUxkTci4lcRsT4iXm99ZDWyIjB9wnC27W7hoec35DoUM7OMdDWJLJJ0s6RTJE1ufWQ1siJw6hFDGFBR5i4tM8tbXe3OOil5Th9UCeDMQxtOcakoK+X8d4zgJ483ctkp4zi+flCuQzIz65Yu39kwIs5IfwB/nc3AisV15x3D4P7lXH3X4+zY7eEmM8svXU0i97RT9uNDGUixqulfzi0XTeT5pm3827wVuQ7HzKxbOuzOknQMMAEYJOkDaW8NBCqzGVgxedf4Wq5412Hc9uCLnHFMHWceMyzXIZmZdUlnLZGjgfcC1cD70h6Tgb/JbmjF5f+eezTHDB/AZ+55ig1bd+U6HDOzLunSjHVJp0TEn3ognqzrLTPW27PytS287+sP8q4ja7lt1lTy4GaNZlYkMpqxLukzyctLk1vQvuWRlUiL2NHDB3DdjGN44Nn1/O8jr+Q6HDOzTnV2ie/y5Ll3/nQvQJefOo5FK9dz0y+Xc9oRQzi8rirXIZmZHVBnYyIfSp6rI+L2to9sB1eMSkrELRedSJ+SEj7/i+WdH2BmlkOdJZEpksYCH0vu6TE4/dETARajoQMr+eRZR7JoZRO/Xbm+8wPMzHKksyTy38D9wDGkFl9Mf7iLK4suP/Uwxg3px+d/sZw9LftyHY6ZWbs6TCIR8dWIOBaYExGHR8RhaY/DeyjGolReVsI//vlxPN+0jTsffjnX4ZiZtatLM9Yj4hPZDsTe7uxjh3LakUP48m9WsWnb7s4PMDPrYV1d9sRyQBL/9N7j2LJzD//1m+dyHY6Z2ds4ifRyxwwfyKUnjeF/H3mFVeu25DocM7O3cBLJA9ecfRT9ykv5/C9X0JUVBszMeoqTSB4YUlXB1WeN5/fPNbHIl/yaWS/iJJInLjtlHIfX9uemX66gZZ9bI2bWOziJ5InyshKunX40zzdtY97Tr+Y6HDMzwEkkr5x3/HCOHFrF1x9oYJ9bI2bWCziJ5JGSEnHVGUeyct0Wfr18Xa7DMTNzEsk37z1hBGOH9ONrD6zylVpmlnNOInmmrLSEK08/kmVrN/tKLTPLOSeRPPT+yfXUV/flqwsb3Boxs5xyEslDfUpL+MTpR/DE6mYebNiQ63DMrIg5ieSpi6aOYvjASr62sCHXoZhZEctJEpH0kqSnJT0haUlSNljSAkmrkueapFzJPd0bJD0laXLaeWYl+6+SNCsXdcmVirJSPv6ew3n0pY088sLruQ7HzIpULlsiZ0TExIiYmmxfByyMiPHAwmQb4DxgfPKYDXwLUkkHuAE4CZgG3NCaeIrFJdPGUFtVwdcecGvEzHKjN3VnzQRa79t+O3BBWvkdkfIwUC1pBHAusCAiNkbEJmABMKOng86lyj6lzH73YTzYsMG30TWznMhVEgng15KWSpqdlA2LiFcBkuehSXk9sDrt2Mak7EDlbyNptqQlkpY0NTUdwmrk3odPGsuRQ6uYfcdSfvb4mlyHY2ZFJldJ5LSImEyqq+pKSe/uYF+1UxYdlL+9MOLWiJgaEVPr6uq6H20v1r+ijHv/9lQmj63m0z96gq8u9CREM+s5OUkiEbE2eV4P/JTUmMa6pJuK5Lm1f6YRGJ12+ChgbQflRWdQvz7c8bGT+MDker604Dmu/fGT7N67L9dhmVkR6PEkIqm/pAGtr4HpwDPAXKD1CqtZwH3J67nAZclVWicDbyTdXfOB6ZJqkgH16UlZUSovK+GWi07k/5xzFD95bA2XzXmEN7bvyXVYZlbgynLwmcOAn0pq/fwfRMT9khYDd0u6AngFuCjZfx5wPtAAbAf+CiAiNkr6PLA42e/GiNjYc9XofSTxqbPGM2ZwPz5zz1Nc+N8P8eO/PYXqfuW5Ds3MCpSKrf986tSpsWTJklyHkXUPNWzg8u8tZtKYau64YhoVZaW5DsnM8pikpWlTMvbrTZf42iF06pG13HzRCTzy4kY+c89THmw3s6zIRXeW9ZCZE+tp3LSDm+evZHRNP/7+3KNzHZKZFRgnkQL3d6cfQeOm7Xx9UQOjavpy8bQxuQ7JzAqIk0iBk8SNM49nTfNO/vFnzzCyui/vPqqw5sqYWe54TKQI9Ckt4ZsfnsxRwwbwd3c+xvK1m3MdkpkVCCeRIlFVUcb3Ln8nAyrLmPW9R3nl9e25DsnMCoCTSBEZPqiS/7liGnta9vGR2x5h/ZaduQ7JzPKck0iROXLoAL53+TvZsHUXl932KG/s8Kx2M8uck0gRmjSmhv/+yBSeb9rKX9++mB27W3IdkpnlKSeRIvXuo+r48ocmsuTlTVz1g8fY0+IFG82s+5xEith7TxjJjTOPZ+Gz6/mHe55i3z7Pajez7vE8kSL30ZPH0rxtN7cseI6SEvHFvzyB0pL2btViZvZ2TiLGJ88az959wVcWriIC/uNCJxIz6xonEQPgmnOOQoL/+s0qguDmC090IjGzTjmJ2H6fPvsoSiS+tOA5IuA/L3IiMbOOOYnYW3zqrPEIuGXBc0QEt3xwohOJmR2Qk4i9zSfPGk9Jibh5/kqefW0Ll586jpkT6+lb7htbmdlb+RJfa9eVZxzJVy6eiCSu+8nTnPzvC/n3eStYvdFrbpnZm3x7XOtQRLD4pU18/6EXmb9sHRHBWccO44NTR3P60XX0KfXvELNicKDb47o7yzokiWmHDWbaYYNZ27yD/334Ze5espoFy9dRW1XOzIn1XDhlFMeOGJjrUM0sB9wSsW7b07KP361s4p6ljSx8dh17WoIJIwdyybQxfGByPf3K/dvErNAcqCXiJGIHZeO23fz8ybXcvWQ1y9ZuZlDfPlwybQyzTh3LiEF9cx2emR0iTiIJJ5HsiAiWvryJ2x58kfnLXkMS579jBJefOpZJo2so8WXCZnnNYyKWVZKYOm4wU8cNZvXG7dzxp5e469HV/PzJtdRWVfCeo+p4z9F1vHt8LdX9ynMdrpkdIm6JWNZs3bWX+c+8xm+fa+IPq5po3r6HEsHE0dWcecxQpk8YzvihVUhupZj1du7OSjiJ5EbLvuDJxmZ+u7KJ361cz5ONbwAwbkg/zjluGNMnDGfymBrPjjfrpZxEEk4ivcO6zTv5zYp1/HrZOh56fgN7WoLB/cuZOraGKcnj+PpBVPbxLHmz3sBJJOEk0vts2bmH365sYtHK9Tz28iZeej01K75PqZgwchDvqB/EEXX9ObyuiiOGVjFiYKUH6s16mAfWrdcaUNmH9504kvedOBKADVt38djLm3jslWYee3kTP3t8DVt27d2/f98+pRxe158j6qr2P7e+dsvFrGe5JWK9XkTQtHUXz6/fxvNNW3mhaRsNTVt5oWkra5p30PonLMGIgZWMGtyPUTV9GV2TPA/uR311X4YPqvQyLWYZKtiWiKQZwFeAUuC7EfGFHIdkh5gkhg6oZOiASk45Yshb3tu5p4UXN6SSy/Prt/Hy69to3LSDPz3/Oj/dvIb030gSDBtQSX1NX0ZW92VkdSWjqvvu366v7suAyj49XDuz/JbXSURSKfAN4BygEVgsaW5ELM9tZNZTKvuUcuyIge2u3bV77z7WNu9g9abtrG3ewZrmnazZtIO1zTt4qrGZ+5/ZwZ6Wt7bEB1aWUV/Tj/rqSuqrW5NNqhVT06+cmn59GNS3D2Vu0ZgBeZ5EgGlAQ0S8ACDpLmAm4CRilJeVMK62P+Nq+7f7/r59qW6yNc07WLNpx/7ntc07aNy0g0df3MjmnXvbPXZgZRk1/csP2D3mYX/rjX7xqXdRUXZoxw3zPYnUA6vTthuBk9ruJGk2MBtgzJgxPROZ9XolJWLYwEqGDaxk8piadvfZsnMPa5t3sm7zTjZt303z9j1s3Lab5u272bR9Dy373j6mGBTXOKPlD2Xh502+J5H2/kXe9n9wRNwK3AqpgfVsB2WFY0BlH44e3oejhw/IdShmvVK+d+w2AqPTtkcBa3MUi5lZ0cn3JLIYGC/pMEnlwMXA3BzHZGZWNPK6Oysi9kq6CphP6hLfORGxLMdhmZkVjbxOIgARMQ+Yl+s4zMyKUb53Z5mZWQ45iZiZWcacRMzMLGNOImZmlrGiW8VXUhPwcoaH1wIbDmE4vUkh1w0Ku36uW/7Kp/qNjYi6toVFl0QOhqQl7S2FXAgKuW5Q2PVz3fJXIdTP3VlmZpYxJxEzM8uYk0j33JrrALKokOsGhV0/1y1/5X39PCZiZmYZc0vEzMwy5iRiZmYZcxLpAkkzJK2U1CDpulzHc7AkzZG0XtIzaWWDJS2QtCp5bv9Wf72cpNGSFklaIWmZpKuT8ryvn6RKSY9KejKp278k5YdJeiSp24+S2yLkJUmlkh6X9Itku5Dq9pKkpyU9IWlJUpb3f5dOIp2QVAp8AzgPOA64RNJxuY3qoH0fmNGm7DpgYUSMBxYm2/loL3BtRBwLnAxcmfz3KoT67QLOjIgTgYnADEknA18EvpzUbRNwRQ5jPFhXAyvStgupbgBnRMMjA9kAAAX8SURBVMTEtLkhef936STSuWlAQ0S8EBG7gbuAmTmO6aBExO+BjW2KZwK3J69vBy7o0aAOkYh4NSIeS15vIfWFVE8B1C9StiabfZJHAGcC9yTleVk3AEmjgD8HvptsiwKpWwfy/u/SSaRz9cDqtO3GpKzQDIuIVyH1RQwMzXE8B03SOGAS8AgFUr+ku+cJYD2wAHgeaI6Ivcku+fz3+V/AZ4B9yfYQCqdukEr4v5a0VNLspCzv/y7z/qZUPUDtlPm66F5OUhVwL/DpiNic+lGb/yKiBZgoqRr4KXBse7v1bFQHT9J7gfURsVTS6a3F7eyad3VLc1pErJU0FFgg6dlcB3QouCXSuUZgdNr2KGBtjmLJpnWSRgAkz+tzHE/GJPUhlUDujIifJMUFUz+AiGgGfktq3KdaUusPwnz9+zwN+AtJL5HqMj6TVMukEOoGQESsTZ7Xk/oBMI0C+Lt0EuncYmB8cpVIOXAxMDfHMWXDXGBW8noWcF8OY8lY0o9+G7AiIr6U9lbe109SXdICQVJf4GxSYz6LgAuT3fKybhFxfUSMiohxpP4feyAiPkwB1A1AUn9JA1pfA9OBZyiEv0vPWO+cpPNJ/SoqBeZExE05DumgSPohcDqpZajXATcAPwPuBsYArwAXRUTbwfdeT9K7gD8AT/Nm3/pnSY2L5HX9JJ1AavC1lNQPwLsj4kZJh5P69T4YeBz4SETsyl2kByfpzvr7iHhvodQtqcdPk80y4AcRcZOkIeT736WTiJmZZcrdWWZmljEnETMzy5iTiJmZZcxJxMzMMuYkYmZmGXMSsaIh6aHkeZykSw/xuT/b3mdli6QLJH2uk30uSlb73Sdpapv3rk9WpV4p6dy08nZXrJZ0l6Txh74mlu98ia8VnfR5CN04pjRZcuRA72+NiKpDEV8X43kI+IuI2NDBPseSmivzbVL1bV1+/Djgh6RmTI8EfgMclRz2HHAOqZUaFgOXRMRySe8hNUfjb7JUJctTbolY0ZDUugLuF4A/S+7rcE2yqOHNkhZLekrSx5P9T0/uTfIDUpMXkfSzZAG9Za2L6En6AtA3Od+d6Z+llJslPZPcS+JDaef+raR7JD0r6c5ktj2SviBpeRLLf7ZTj6OAXa0JRNJ9ki5LXn+8NYaIWBERK9v5p5gJ3BURuyLiRaCBVELpaMXqPwBnpy1BYgZ4AUYrTteR1hJJksEbEfFOSRXAHyX9Otl3GnB88mUL8LGI2JgsO7JY0r0RcZ2kqyJiYjuf9QFS9/44kdQKAYsl/T55bxIwgdR6UH8ETpO0HHg/cExEROsyJ22cBjyWtj07iflF4FpS62l1pB54OG07fXXctitWnwQQEfskNST1WNrJ+a2IuCVillrH6LJkifVHSC1B3tr//2haAgH4lKQnSX0Jj07b70DeBfwwIloiYh3wO+CdaedujIh9wBPAOGAzsBP4rqQPANvbOecIoKl1Iznv50itM3VtF5bNONDquJ2tmrueVPeX2X5uiZilvjw/GRHz31KYGjvZ1mb7bOCUiNgu6bdAZRfOfSDpa0C1AGURsVfSNOAsUgsRXkVqRdt0O4BBbcreAbxO177kO1qZuqMVqyuTzzbbzy0RK0ZbgAFp2/OBTyRLyCPpqGSl1bYGAZuSBHIMb+022tN6fBu/Bz6UjLvUAe8GHj1QYErdB2VQRMwDPk2qK6ytFcCRacdMI3X75knA30s67EDnT8wFLpZUkew7PompsxWrjwKWdXJuKzJOIlaMngL2SnpS0jWkbse6HHhM0jOkrmZqr5V+P1Am6Sng87x1XOFW4KnWQe00P00+70ngAeAzEfFaB7ENAH6RfMbvgGva2ef3wKRk0L4C+A6psZq1pMZE5iTvvV9SI3AK8EtJ8wEiYhmplWOXJ3W6Mulu20uq5TOfVKK6O9kXScOAHa134TNr5Ut8zfKQpK8AP4+I3/TQ510DbI6I23ri8yx/uCVilp/+DejXg5/XTOpeJmZv4ZaImZllzC0RMzPLmJOImZllzEnEzMwy5iRiZmYZcxIxM7OM/X+Ie/J+3D3ASQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# run algorithm and print solution\n",
    "DIM = 500\n",
    "\n",
    "pop_evolv, logs, nit, compute_time = solve_pb(dim=DIM, \n",
    "                                              my_algo=algo, \n",
    "                                              bounds=search_space, \n",
    "                                              optim=funcbias, \n",
    "                                              popsize=pop_size\n",
    "                                             )\n",
    "\n",
    "print_solution(dimension=DIM, \n",
    "               my_algo=algo, \n",
    "               pop_evolved=pop_evolv, \n",
    "               log=logs, \n",
    "               niter=nit, \n",
    "               duration=compute_time\n",
    "              )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "meta",
   "language": "python",
   "name": "meta"
  },
  "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}