from copy import copy
import numpy as np
import random
import matplotlib
from pylab import *
matplotlib.use('TkAgg')
from pylab import *
mpl.rcParams['font.sans-serif'] = ['SimHei']  # 指定預設字型
mpl.rcParams['axes.unicode_minus'] = False  # 解決儲存影象是負號'-'顯示為方塊的問題
from tqdm import tqdm  # 進度條設定
import random

 
class AOA(object):
    """
    個體的密度和體積都在向著全域性最優個體的密度和體積靠近。
    """
    def __init__(self, M, T, lb, ub, l, N):
        self.M = M  # 種群個數
        self.T = T  # 迭代次數
        self.lb = lb
        self.ub = ub
        self.L  = l
        self.N = N
        self.u =0.9
        self.ul = 0.1
        self.c1 
 
= 2
        self.c2 = 6
        self.c3 = 2
        self.c3 = 2
        self.c4 = 2

    def init_x(self):
        x = np.random.uniform(self.lb ,self.ub,(self.M,self.L,self.N))
        return x

    def init_den(self):
        den = np.random.uniform(0,1,(self.M,self.L,self.N))
        return  den
    
 
def init_vol(self):
        vol = np.random.uniform(0,1,(self.M,self.L,self.N))
        return vol
    def init_acc(self):
        acc = np.ones((self.M,self.L, self.N)) * self.lb
        acc += np.random.uniform(self.lb ,self.ub, (self.M,self.L, self.N))
        return acc

    def fitness(self,x):
        """
        (x1-50)**2+(x2-50)**2
        :param x:
        :return:
        """
        result =(x[0]-90) ** 2 + (x[1]-90) ** 2
        return result

    def best(self,x):
        l = []
        for m in range(self.M):
            for i in range(self.L):
                l.append(self.fitness(x[m,i]))
        return l.index(min(l)),l

    def up_den(self,den,den_best):
        den1 = den.copy()
        den_new = den+ np.random.uniform(0,1,(self.M,self.L,self.N))*(den_best - den)
        return den_new

    def up_vol(self,vol,vol_best):
        vol1 = vol.copy()
        vol_new = vol1+ np.random.uniform(0,1,(self.M,self.L,self.N))*(vol_best - vol1)
        return vol_new

    def up_acc_1(self,den,vol,acc):
        """
        TF<=0.5
        """
        acc1=acc.copy()
        for m in range(self.M):
            rand = np.random.randint(0, self.M)
            dva = den[rand]+vol[rand]*acc1[rand]
            acc[m] = (dva)/den[m]*vol[m]
        return acc

    def up_acc_2(self,den_best,vol_best,acc_best,den,vol):
        """
        TF>0.5
        """
        acc = (den_best + vol_best*acc_best)/(den*vol)
        return acc

    def normalize_acc(self,acc):
        if np.max(acc)-np.min(acc) == 0:
            acc_nor = self.ul
        else:
            acc_nor = self.u*((acc - np.min(acc))/(np.max(acc)-np.min(acc))) + self.ul
        return acc_nor


    def up_x_1(self,x,acc_nor,d):
        x1 = x.copy()
        x2 = x.copy()
        for m in range(self.M):
            rand = np.random.randint(0, self.M)
            x2[m] = x1[rand]
        x_new = x1+self.c1*np.random.uniform(0,1,(self.M,self.L,self.N))*acc_nor*d*(x2-x1)
        return x_new

    def up_x_2(self,x,x_best,acc_nor,d,TF):
        p = 2*np.random.rand()-self.c4
        if p>=0.5:
            F = 1
        else:
            F = -1
        x = x_best+F*self.c2*np.random.uniform(0,1,(self.M,self.L,self.N))*acc_nor*d*(self.c3 * TF * x_best-x)
        return x
    def main(self):
    #第一步初始化
        optimum_list = []
        x = self.init_x()
        den = self.init_den()
        vol = self.init_vol()
        acc = self.init_acc()
        # 求出x,den,vol,acc最優
        num ,l= self.best(x)
        optimum_list.append(min(l))
        x_best = x[num]
        den_best = den[num]
        vol_best = vol[num]
        acc_best = acc[num]
    #第二部更新den vol
    #第三部分轉移運算子和密度因子
        for i in range(self.T):
            den = self.up_den(den, den_best)
            vol = self.up_vol(vol, vol_best)
            TF = np.exp((i-self.T)/self.T)
            d = np.exp((self.T-i)/self.T)-(i/self.T)   #密度遞減因子，用於全域性搜尋
            x1 = x.copy()
            if TF<=0.5:
                acc = self.up_acc_1(den,vol,acc)
                acc_nor = self.normalize_acc(acc)
                x= self.up_x_1(x,acc_nor,d)
                x=np.clip(x, self.lb, self.ub)
            else :
                acc = self.up_acc_2(den_best,vol_best,acc_best,den,vol)
                acc_nor = self.normalize_acc(acc)
                print(acc_nor)
                x = self.up_x_2(x,x_best,acc_nor,d,TF)
                x=np.clip(x,self.lb,self.ub)

            num,l1= self.best(x)
            for i in range(len(l1)):
                if l1[i]>l[i]:
                    x[i]=x1[i]
                    l1[i] = l[i]
            num = l1.index(min(l1))
            x_best = x[num]
            optimum_list.append(min(l))
            den_best = den[num]
            vol_best = vol[num]
            acc_best = acc[num]
            l = l1
        print("最優解適應度",optimum_list[-1])
        print("最優位置",x_best)
        plt.plot(optimum_list, label='AOA')
        plt.xlabel('Iterations', size=13)
        plt.ylabel('Fitness', size=13)
        plt.legend()
        plt.show()


if __name__ == '__main__':
    #" M, T, lb, ub, l, N"
    A1 = AOA( 30, 100, -100, 100, 1, 2)
    A1.main()