Python code for COOT Optimization

import from numpy import random

import time

import numpy as np

rng = np.random.default_rng()

import math

import sys

from numpy import linalg as LA

import numpy as np

import math

from numpy import inf

Supporting functions

def fun(X):

    output = sum(np.square(X))

    return output

# This function is to initialize the Vulture population.

def initial(pop, dim, ub, lb):

    X = np.zeros([pop, dim])

    for i in range(pop):

        for j in range(dim):

            X[i, j] = random.random()*(ub[j] - lb[j]) + lb[j]

    return X

# Calculate fitness values for each Vulture

def CaculateFitness1(X,fun):

    fitness = fun(X)

    return fitness

# Boundary detection function.

def BorderCheck1(X,lb,ub,dim):

        for j in range(dim):

            #print(X)

            if X[j]<lb[j]:

                X[j] = ub[j]

            elif X[j]>ub[j]:

                X[j] = lb[j]

        return X

COOT Algorithm

def COOT(N,dim,lb,ub,Max_iter,fun):

    NLeader=math.ceil(0.1*N)

    Ncoot=N-NLeader

    Convergence_curve = np.zeros([300,1])

    fitness = np.zeros([pop, 1])

    gBest=np.zeros([1,dim])

    temp  = np.zeros([1,dim])

    gBestScore=inf    

    CootPos=initial(Ncoot, dim, lb,ub)

    CootFitness=np.zeros([1,Ncoot])

#Initialize the locations of Leaders

    LeaderPos=initial(NLeader, dim, lb,ub)

    LeaderFit=np.zeros([1,NLeader])

    for i in range(Ncoot):

      CootFitness[0,i] = CaculateFitness1(CootPos[i, :], fun)

      if gBestScore > CootFitness[0,i]:

        gBestScore = CootFitness[0,i]

        gBest = CootPos[i, :]

    for i in range(NLeader):

      LeaderFit[0,i] = CaculateFitness1(LeaderPos[i, :], fun)

      if gBestScore > LeaderFit[0,i]:

        gBestScore = LeaderFit[0,i]

        gBest = LeaderPos[i, :]

    Convergence_curve[0] =  gBestScore

    for t in range(Max_iter):

        B=2-t*(1/Max_iter)

        A=1-t*(1/Max_iter)

        for i in range(Ncoot):

          if random.rand()<0.5:

            R=-1+2*random.rand()

            R1=random.rand()

          else:  

            R=-1+2*random.rand(1,dim)

            R1=random.rand(1,dim)

          k=math.fmod(i,NLeader)

          k=math.floor(k)

          if random.rand()<0.5:

            r1=2*np.multiply(R1,np.cos(2*math.pi*R))           #|| i==1

            CootPos[i,:]=np.multiply(r1,(LeaderPos[k,:]-CootPos[i,:]))+LeaderPos[k,:]

            CootPos[i,:] = BorderCheck1(CootPos[i,:], lb, ub, dim)

          else:

            if random.rand()<0.5 and not i==1:

              CootPos[i,:]=(CootPos[i,:]+CootPos[i-1,:])/2

              CootPos[i,:] = BorderCheck1(CootPos[i,:], lb, ub, dim)

            else:

              Q=(random.rand(1,dim)*(ub-lb))+lb

              CootPos[i,:]=CootPos[i,:]+A*np.multiply(R1,(Q[1,:]-CootPos[i,:])) 

              CootPos[i,:] = BorderCheck1(CootPos[i,:], lb, ub, dim)

        for i1 in range(Ncoot):

            CootFitness[0,i1] = CaculateFitness1(CootPos[i1, :], fun)

            k=math.fmod(i,NLeader)

            k=math.floor(k)

            if CootFitness[0,i1] < LeaderFit[0,k]:

                temp =  LeaderPos[k, :]

                tempfit =LeaderFit[0,k]

                LeaderPos[k, :] = CootPos[i1, :]

                LeaderFit[0,k] = CootFitness[0,i1]

                CootPos[i1, :] = temp

                CootFitness[0,i1] = tempfit

        for i2 in range(NLeader):

          if random.rand()<0.5:

            R=-1+2*random.rand()

            R3=random.rand()

          else:  

              R=-1+2*random.rand(1,dim)

              R3=random.rand(1,dim)

          if random.rand()<0.5:

            r2=B*np.multiply(R3,np.cos(2*math.pi*R))           

            temp1=np.multiply(r2,(gBest-LeaderPos[i2,:]))+gBest

            #print('temp1',temp)

          else:

            r2=B*np.multiply(R3,np.cos(2*math.pi*R))           

            temp1=np.multiply(r2,(gBest-LeaderPos[i2,:]))-gBest         

          temp2 = temp1[0]

          if  temp2.size == 1:

              temp =  temp1

          else:

              temp =  temp2

          temp = BorderCheck1(temp, lb, ub, dim)

          tempfit = CaculateFitness1(temp, fun)

          if gBestScore > tempfit:

              LeaderFit[0,i2] = gBestScore

              LeaderPos[i2,:] = gBest

              gBestScore = tempfit

              gBest = temp

        #print('t',t)

        

        Convergence_curve[t] =  gBestScore

        #print('Convergence_curve',Convergence_curve[t])  

    return Convergence_curve,gBestScore,gBest

Main code

rng = np.random.default_rng()

time_start = time.time()

pop = 20                    # Population size n

MaxIter = 300               # Maximum number of iterations.

dim = 10                    # The dimension.

fl=-100                     # The lower bound of the search interval.

ul=100                      # The upper bound of the search interval.

lb = fl*np.ones([dim, 1])

ub = ul*np.ones([dim, 1])

Convergence_curve,gBestScore,gBest = COOT(pop, dim, lb, ub, MaxIter, fun) 

print('gBestScore',gBestScore)

View convergence curve

import matplotlib.pyplot as plt

fig, ax = plt.subplots()

ax.plot( Convergence_curve,color='dodgerblue', marker='o', markeredgecolor='dodgerblue', markerfacecolor='dodgerblue')

ax.set_xlabel('Number of Iterations',fontsize=15)

ax.set_ylabel('Fitness',fontsize=15)

ax.set_title('COOT Optimization')

plt.savefig('image.jpg', format='jpg')

plt.show()