THSPSO and THSPSO-19.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hierachy Simple PSO Algorithm (THSPSO and PHSPSO)\n",
    "This Algorithm is from the research paper\n",
    "* Hao-Ran Liu, Jing-Chuang Cui, Ze-Dan Lu, Da-Yan Liu, Yu-Jing Deng, A hierarchical simple particle swarm optimization with mean dimensional information Applied Soft Computing Journal 76 (2019) 712–725\n",
    "* In the algorithms, the velocity is eliminated and position update is done at any time using one of the following equations depending on the strategy employed.\n",
    "* *1. $ X_{id}(t+1) = wX_{id}(t) + c_1*r_1( P_{id}(t)-X_{id}(t) )  $\n",
    "* *2. $ X_{id}(t+1) = wX_{id}(t)  + c_2*r_2( P_{gd}(t)-X_{id}(t) ) $\n",
    "* *3. $ X_{id}(t+1) = wX_{id}(t) +  c_3*r_3( P_{ad}(t)-X_{id}(t) ) $\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "#------------------------------------------------------------------------------+\n",
    "#   CHIA E TUNGOM (Chemago) {chemago99@yahoo.com}\n",
    "#   Simpler Particle Swarm Optimization (PSO) Algorithm in Python\n",
    "#   Feb, 2020\n",
    "#   [Ref Paper] Hao-Ran Liu, Jing-Chuang Cui, Ze-Dan Lu, Da-Yan Liu, Yu-Jing Deng, A hierarchical simple \n",
    "#   particle swarm optimization with mean dimensional information Applied Soft Computing Journal 76 (2019) 712–725\n",
    "#------------------------------------------------------------------------------+"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import dependensies\n",
    "\n",
    "import random\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [],
   "source": [
    "# optimization function\n",
    "def sphere(x):\n",
    "    ans = 0\n",
    "    for i in range(len(x)):\n",
    "        ans += x[i]**2\n",
    "        \n",
    "    return ans\n",
    "\n",
    "# Population Initialization\n",
    "def InitializeX(population, dimensions, boundary = (-10, 10)):\n",
    "    \n",
    "    bounds = [boundary for i in range(dimensions)]\n",
    "    return [[random.uniform(bounds[i][0], bounds[i][1]) for i in range(dimensions)] for i in range(population)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate global best\n",
    "def Gbest(f, X):\n",
    "    \n",
    "    fX = [f(i) for i in X]\n",
    "    ind = fX.index(min(fX))\n",
    "    gbest = X[ind]\n",
    "\n",
    "    return gbest\n",
    "\n",
    "# calculate personal Best\n",
    "def Pbest(f, X, XP): \n",
    "    \n",
    "    \"\"\" XP : previous X\n",
    "        X  : current X  \"\"\"\n",
    "    \n",
    "    fX = [f(i) for i in X]\n",
    "    fP = [f(i) for i in XP]\n",
    "    pbest = []\n",
    "    \n",
    "    for i in range(len(X)):\n",
    "        \n",
    "        if fX[i] < fP[i]: \n",
    "            pbest.append(X[i])\n",
    "        else:\n",
    "            pbest.append(XP[i])\n",
    "    \n",
    "    return pbest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cognitive only update \n",
    "def COupdateX(X, pbest, bound, w = 0.6, c1 = 2.0):\n",
    "    \n",
    "    \"\"\"pbest: personal best X \"\"\"\n",
    "    \n",
    "    NewX = []\n",
    "    \n",
    "    for i in range(len(X)):\n",
    "        NewX.append([])\n",
    "        \n",
    "        for j in range(len(X[0])):\n",
    "            \n",
    "            r1 = random.random()\n",
    "            # Update position\n",
    "            NewX[i].append( (w*X[i][j]) + (c1 * r1*(pbest[i][j] - X[i][j])) )\n",
    "            \n",
    "            # contain particles in bound\n",
    "            if NewX[i][j] < bound[j][0] or NewX[i][j] > bound[j][1]:\n",
    "                NewX[i][j] = random.uniform(bound[j][0],bound[j][1])\n",
    "    return NewX\n",
    "\n",
    "# Social Only update\n",
    "def SOupdateX(X, gbest, bound, w = 0.6, c2 = 2.0):\n",
    "    \n",
    "    \"\"\" gbest: global best \"\"\"\n",
    "    \n",
    "    NewX = []\n",
    "    \n",
    "    for i in range(len(X)):\n",
    "        NewX.append([])\n",
    "        \n",
    "        for j in range(len(X[0])):\n",
    "            \n",
    "            r2 = random.random()\n",
    "            # Update position\n",
    "            NewX[i].append( (w*X[i][j]) + (c2* r2* (gbest[j] - X[i][j])) )\n",
    "            \n",
    "            # contain particles in bound\n",
    "            if NewX[i][j] < bound[j][0] or NewX[i][j] > bound[j][1]:\n",
    "                NewX[i][j] = random.uniform(bound[j][0],bound[j][1])\n",
    "    return NewX\n",
    "\n",
    "# Mean Dimensional update \n",
    "def MDupdateX(X, bound, w = 0.6, c3 = 2.0):\n",
    "    \n",
    "    # use X to calculate the mead diension\n",
    "    Md = []\n",
    "    for i in range(len(X[0])): #dimension length\n",
    "        #for j in range(len(X)): # population\n",
    "        Md.append(sum([X[j][i] for j in range(len(X))])/len(X))\n",
    "\n",
    "    NewX = []\n",
    "    \n",
    "    for i in range(len(X)):\n",
    "        NewX.append([])\n",
    "        \n",
    "        for j in range(len(X[0])):\n",
    "            \n",
    "            r3 = random.random()\n",
    "            # Update position\n",
    "            NewX[i].append( (w*X[i][j]) + (c3* r3* (Md[j] - X[i][j])) )\n",
    "            \n",
    "            # contain particles in bound\n",
    "            if NewX[i][j] < bound[j][0] or NewX[i][j] > bound[j][1]:\n",
    "                NewX[i][j] = random.uniform(bound[j][0],bound[j][1])\n",
    "    return NewX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write the PSO Loop\n",
    "# input: dim, pop, bounds, function\n",
    "dim = 3                                                 # dimension of vector\n",
    "pop = 5\n",
    "bound = (-10, 10)                                       # (lower, upper) bound for one dimensional vector\n",
    "#bounds = [(-10, 10) for i in range(dim)]               # for a 3 dimensionsal vector\n",
    "\n",
    "def SPSO(dim, bound, function, pop = 10, runs = 20):\n",
    "    \n",
    "    X = InitializeX(pop, dim, bound)\n",
    "    bounds = [bound for i in range(dim)]\n",
    "    c1 = 2.0\n",
    "    c2 = 2.0\n",
    "    c3 = 2.0\n",
    "    w = 0.9\n",
    "    \n",
    "    i = 0\n",
    "    while i < runs :\n",
    "        \n",
    "        gbest = Gbest(function, X)\n",
    "        if i == 0:\n",
    "            pbest = X\n",
    "        else:\n",
    "            pbest = Pbest(function, X, XP)\n",
    "            \n",
    "        XP = X.copy()    \n",
    "        X = COupdateX(X, pbest, bounds, w, c1) \n",
    "        #X = SOupdateX(X, gbest, bounds, w, c2)\n",
    "        #X = MDupdateX(X, bounds, w, c3)\n",
    "        \n",
    "        i += 1\n",
    "        \n",
    "        #print(min ([function(i) for i in X]))\n",
    "    lo = [function(i) for i in X]\n",
    "    o = min(lo)\n",
    "    ind = lo.index(o)\n",
    "    #print(X[ind])\n",
    "    return min([function(i) for i in X])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03550842886973861"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 50\n",
    "bound = (-10,10)\n",
    "\n",
    "SPSO(dimensions, bound, sphere, pop = 20, runs= 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.999999999999998"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def F1(x):\n",
    "    \"\"\" x is a vector of dimension d \n",
    "        e.g if x = [1,2,3] , d = 3 or len(x)\"\"\"\n",
    "    \n",
    "    a = 0\n",
    "    for i in range(len(x)):\n",
    "        a += ( (i+1) * ( ( ((2*x[i]) ** 2) - x[i] - 1) **2) )\n",
    "        \n",
    "    return ((x[0]+1)**2) + a \n",
    "\n",
    "dimensions = 5\n",
    "bound = (-10,10)\n",
    "\n",
    "SPSO(dimensions, bound, F1, pop = 50, runs= 1000)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.440892098500626e-16"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def F6(x):\n",
    "    \n",
    "    a = math.sqrt( ((len(x))**-1) * sum([i**2 for i in x]) )\n",
    "    b = math.e ** ( ((len(x))**-1) * sum([math.cos(2*math.pi*i) for i in x]) )\n",
    "            \n",
    "    ans  = (-20*( math.e ** (-0.02 * a) ) ) - b + 20 + math.e\n",
    "    \n",
    "    return ans\n",
    "\n",
    "dimensions = 5\n",
    "bound = (-32,32)\n",
    "\n",
    "SPSO(dimensions, bound, F6, pop = 50, runs= 1000)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Time Hierachy Strategy (THSPSO)\n",
    "\n",
    "In this Strategy, the Social Model is used in stage 1, Cognitive model in stage 2 and MD model in stage 3. Recommended values for t1 and t2 are 1/5 and 4/5 respectively based on the research paper which correspond to the times in which a model is used. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "def THSPSO(dim, bound, function, pop = 10, runs = 20):\n",
    "    \n",
    "    X = InitializeX(pop, dim, bound)\n",
    "    bounds = [bound for i in range(dim)]\n",
    "    c1 = 2.0\n",
    "    c2 = 2.0\n",
    "    c3 = 2.0\n",
    "    w = 0.9\n",
    "    \n",
    "    # Time hierachy variables\n",
    "    t1 = 1/5\n",
    "    t2 = 4/5\n",
    "    \n",
    "    i = 0\n",
    "    while i < runs :\n",
    "        \n",
    "        gbest = Gbest(function, X)\n",
    "        if i == 0:\n",
    "            pbest = X\n",
    "        else:\n",
    "            pbest = Pbest(function, X, XP)\n",
    "            \n",
    "        XP = X.copy()\n",
    "        \n",
    "        # Time hierachy loop\n",
    "        if i/runs < t1:\n",
    "            X = SOupdateX(X, gbest, bounds, w, c2)\n",
    "        elif i/runs > t1 and i/runs < t2:\n",
    "            X = COupdateX(X, pbest, bounds, w, c1)\n",
    "        else:\n",
    "            X = MDupdateX(X, bounds, w, c3)\n",
    "        \n",
    "        i += 1\n",
    "        \n",
    "        #print(min ([function(i) for i in X]))\n",
    "        \n",
    "    return min([function(i) for i in X])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.01999992844264397"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 50\n",
    "bound = (-10,10)\n",
    "\n",
    "THSPSO(dimensions, bound, sphere, pop = 20, runs= 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30.0"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def F1(x):\n",
    "    \"\"\" x is a vector of dimension d \n",
    "        e.g if x = [1,2,3] , d = 3 or len(x)\"\"\"\n",
    "    \n",
    "    a = 0\n",
    "    for i in range(len(x)):\n",
    "        a += ( i * ( ((2*x[i]) ** 2) - x[i] - 1) )**2\n",
    "        \n",
    "    return (x[0]**2) + a \n",
    "\n",
    "dimensions = 5\n",
    "bound = (-10,10)\n",
    "\n",
    "THSPSO(dimensions, bound, F1, pop = 50, runs= 1000)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.440892098500626e-16"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def F6(x):\n",
    "    \n",
    "    a = math.sqrt( ((len(x))**-1) * sum([i**2 for i in x]) )\n",
    "    b = math.e ** ( ((len(x))**-1) * sum([math.cos(2*math.pi*i) for i in x]) )\n",
    "            \n",
    "    ans  = (-20*( math.e ** (-0.02 * a) ) ) - b + 20 + math.e\n",
    "    \n",
    "    return ans\n",
    "\n",
    "dimensions = 5\n",
    "bound = (-32,32)\n",
    "\n",
    "THSPSO(dimensions, bound, F6, pop = 50, runs= 1000)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Probability Hierachy Strategy (PHSPSO)\n",
    "In this strategy, 2 constants pc1 and pc2 in the range 0 and 1 are set. A random uniform number r in the range 0 and 1 is generated. these three variables are then used to chose between CO, SO and MD model during the search. Recommended values for pc1 and pc2 are 0.6 and 0.9 respectively based on the research paper. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [],
   "source": [
    "def PHSPSO(dim, bound, function, pop = 10, runs = 20):\n",
    "    \n",
    "    X = InitializeX(pop, dim, bound)\n",
    "    bounds = [bound for i in range(dim)]\n",
    "    c1 = 2.0\n",
    "    c2 = 2.0\n",
    "    c3 = 2.0\n",
    "    w = 0.9\n",
    "    \n",
    "    # set probability hierachy variables\n",
    "    pc1 = 0.6\n",
    "    pc2 = 0.9\n",
    "    \n",
    "    i = 0\n",
    "    while i < runs :\n",
    "        \n",
    "        gbest = Gbest(function, X)\n",
    "        if i == 0:\n",
    "            pbest = X\n",
    "        else:\n",
    "            pbest = Pbest(function, X, XP)\n",
    "            \n",
    "        XP = X.copy()\n",
    "        \n",
    "        # Probability hierachy loop\n",
    "        \n",
    "        r = random.random()\n",
    "        if r < pc1:\n",
    "            X = SOupdateX(X, gbest, bounds, w, c2)\n",
    "        elif r > pc1 and r < pc2:\n",
    "            X = COupdateX(X, pbest, bounds, w, c1)\n",
    "        else:\n",
    "            X = MDupdateX(X, bounds, w, c3)\n",
    "        \n",
    "        i += 1\n",
    "        \n",
    "        #print(min ([function(i) for i in X]))\n",
    "        \n",
    "    return min([function(i) for i in X])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.008682526235787993"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 50\n",
    "bound = (-10,10)\n",
    "\n",
    "PHSPSO(dimensions, bound, sphere, pop = 20, runs= 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14.035538691430139"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def F1(x):\n",
    "    \"\"\" x is a vector of dimension d \n",
    "        e.g if x = [1,2,3] , d = 3 or len(x)\"\"\"\n",
    "    \n",
    "    a = 0\n",
    "    for i in range(len(x)):\n",
    "        a += ( i * ( ((2*x[i]) ** 2) - x[i] - 1) )**2\n",
    "        \n",
    "    return (x[0]**2) + a \n",
    "\n",
    "dimensions = 5\n",
    "bound = (-10,10)\n",
    "\n",
    "PHSPSO(dimensions, bound, F1, pop = 50, runs= 1000)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.440892098500626e-16"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def F6(x):\n",
    "    \n",
    "    a = math.sqrt( ((len(x))**-1) * sum([i**2 for i in x]) )\n",
    "    b = math.e ** ( ((len(x))**-1) * sum([math.cos(2*math.pi*i) for i in x]) )\n",
    "            \n",
    "    ans  = (-20*( math.e ** (-0.02 * a) ) ) - b + 20 + math.e\n",
    "    \n",
    "    return ans\n",
    "\n",
    "dimensions = 5\n",
    "bound = (-32,32)\n",
    "\n",
    "PHSPSO(dimensions, bound, F6, pop = 50, runs= 1000)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test On BenchMark Functions \n",
    "Test dimesion is set to 30D, with population size of 40 and maximum of 1000 iterations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def schewefels(x, n = 4):\n",
    "    ans = 0\n",
    "    for i in range(n):\n",
    "        sphere(x)\n",
    "        ans += ans \n",
    "    return ans \n",
    "\n",
    "def rosenbrock(x):\n",
    "    ans  = 0\n",
    "    for i in range(len(x)-1):\n",
    "        ans +=( 100 * (( x[i+1] - (x[i]**2) )**2) + ((x[i]-1)**2) )\n",
    "    return ans\n",
    "        \n",
    "def rastrigen(x):\n",
    "    ans  = 0\n",
    "    for i in range (len(x)):\n",
    "        ans += x[i]**2 - 10*( math.cos(2*math.pi*x[i]) ) + 10\n",
    "    return ans   \n",
    "\n",
    "def griewank(x):\n",
    "    ans = 0\n",
    "    a = 0\n",
    "    b = 1\n",
    "    for i in range(len(x)):\n",
    "        a += x[i]**2\n",
    "        b *= ( math.cos( x[i]) / (math.sqrt(i+1) ) )\n",
    "    ans = ( (1/4000)*a ) + b + 1\n",
    "    return ans \n",
    "\n",
    "def aukley(x):\n",
    "    a = 0\n",
    "    b = 0\n",
    "    ans = 0\n",
    "    for i in range(len(x)):\n",
    "        a += x[i]**2\n",
    "        b += math.cos( 2*math.pi*x[i])\n",
    "    ans = (-20*math.exp((-0.2)*(math.sqrt( (1/len(x)) *a)) ) )- math.exp( (1/len(x)) * b ) + 20 + math.e\n",
    "    return ans\n",
    "\n",
    "\n",
    "def schewefels2(x):\n",
    "    ans = 0\n",
    "    a = 0\n",
    "    b = 1\n",
    "    for i in range(len(x)):\n",
    "        a += x[i]\n",
    "        b *= x[i]\n",
    "    ans = a + b \n",
    "    return ans "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4.144844476155799e-94, 2.1950016769749666e-92)"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 10\n",
    "bound = (-100, 100)\n",
    "\n",
    "PHSPSO(dimensions, bound, sphere, pop = 40, runs= 1000), THSPSO(dimensions, bound, sphere, pop = 40, runs= 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 0)"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 10\n",
    "bound = (-100, 100)\n",
    "\n",
    "PHSPSO(dimensions, bound, schewefels, pop = 40, runs= 1000), THSPSO(dimensions, bound, schewefels, pop = 40, runs= 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.77111090273173, 9.0)"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 10\n",
    "bound = (-100, 100)\n",
    "\n",
    "PHSPSO(dimensions, bound, rosenbrock, pop = 40, runs= 1000), THSPSO(dimensions, bound, rosenbrock, pop = 40, runs= 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 0.0)"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 10\n",
    "bound = (-100, 100)\n",
    "\n",
    "PHSPSO(dimensions, bound, rastrigen, pop = 40, runs= 1000), THSPSO(dimensions, bound, rastrigen, pop = 40, runs= 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 1.0)"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 50\n",
    "bound = (-100, 100)\n",
    "\n",
    "PHSPSO(dimensions, bound, griewank, pop = 40, runs= 1000), THSPSO(dimensions, bound, griewank, pop = 40, runs= 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4.440892098500626e-16, 4.440892098500626e-16)"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 50\n",
    "bound = (-100, 100)\n",
    "\n",
    "PHSPSO(dimensions, bound, aukley, pop = 40, runs= 1000), THSPSO(dimensions, bound, aukley, pop = 40, runs= 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-99.60348471032269, -2.742772913230144e-19)"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 50\n",
    "bound = (-100, 100)\n",
    "\n",
    "PHSPSO(dimensions, bound, schewefels2, pop = 40, runs= 1000), THSPSO(dimensions, bound, schewefels2, pop = 40, runs= 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}