Lyapunov-Gate-Hadamard-Genetico-300-1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c281fb25-0d6a-4709-8371-84fe30138a59",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bibliotecas necessárias para o experimento\n",
    "\n",
    "import numpy as np, numpy.random\n",
    "import matplotlib.pyplot as plt\n",
    "from random import randint\n",
    "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n",
    "\n",
    "from random import randint, uniform, random\n",
    "from scipy.linalg import sqrtm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "831362ff-e7d3-432c-a57b-fa804626496e",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CONSTANTES PARA O ALGORITMO GENÉTICO\n",
    "\n",
    "ELITISMO = True\n",
    "PORCENTAGEM_ELITISMO = 0.20\n",
    "\n",
    "TAMANHO_POP = 50\n",
    "TAXA_MUTACAO = 0.10\n",
    "TAXA_CRUZAMENTO = 0.70\n",
    "GERACOES = 100\n",
    "\n",
    "# Valores mínimos e máximos para gerar uma população\n",
    "MIN = 0\n",
    "MAX = 300\n",
    " # 115, 150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7bae10e9-e05a-4d8a-a271-5f11a724e9a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def S(Ut, Uf, X):\n",
    "    W = np.dot(np.transpose(Uf), Ut)\n",
    "    T = np.transpose(W)\n",
    "    A = np.dot(np.transpose(Ut), np.transpose(X))\n",
    "    C = np.dot(A, Uf)\n",
    "    L = W - np.identity(3) - 1/2*(W - np.identity(3))**2\n",
    "    S = 2*np.trace(np.dot((-np.dot(T, C) + 2*C),L))\n",
    "    #S = 2*np.trace(np.dot((-1/2*np.dot(C, T) - 1/2*np.dot(T, C) + 2*C),L))\n",
    "    return S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a74d139d-10c7-4292-91fc-fd488e6c47c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def field(Ut, Uf, a, h, A, B):\n",
    "    SA = S(Ut, Uf, A)\n",
    "    SB = S(Ut, Uf, B)\n",
    "    f = -a*SA-h*(SB/SA)\n",
    "    return f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "36393204-3d86-4d66-848d-307116ef1180",
   "metadata": {},
   "outputs": [],
   "source": [
    "def lind(u, Ut, Uf, t, lbda):\n",
    "    n = 0.5005\n",
    "    Ax = [[0, 0, 0],[0, 0, -1], [0, 1, 0]]\n",
    "    Ay = [[0, 0, 1],[0, 0, 0], [-1, 0, 0]]\n",
    "    Az = [[0, -1, 0],[1, 0, 0], [0, 0, 0]]\n",
    "    B = [[(1-n*2)*lbda, 0, 0],[0, (1-n*2)*lbda, 0], [0, 0, (-n*2)*lbda]] # Amplitude Damping\n",
    "    #B = [[-1.01*lbda, 0, 0],[0, -1.01*lbda, 0], [0, 0, -0.01*lbda]] # Phase Damping\n",
    "    if t == 0:\n",
    "        fx = u[0]\n",
    "        fy = u[1]\n",
    "        fz = u[2]\n",
    "        F=np.dot(u[0],Ax)+np.dot(u[1],Ay)+np.dot(u[2],Az)+B\n",
    "    else:\n",
    "        fx=field(Ut, Uf, u[0], 0.35, Ax, B)\n",
    "        fy=field(Ut, Uf, u[1], 0.31, Ay, B)\n",
    "        fz=field(Ut, Uf, u[2], 0.34, Az, B)\n",
    "        P=400\n",
    "\n",
    "        if abs(fx) > P:\n",
    "            if fx < 0:\n",
    "                fx = -P\n",
    "            else:\n",
    "                fx = P\n",
    "        if abs(fy) > P:\n",
    "            if fy < 0:\n",
    "                fy = -P\n",
    "            else:\n",
    "                fy = P\n",
    "        if abs(fz) > P:\n",
    "            if fz < 0:\n",
    "                fz = -P\n",
    "            else:\n",
    "                fz = P\n",
    "\n",
    "        F=np.dot(fx,Ax)+np.dot(fy,Ay)+np.dot(fz,Az)+B\n",
    "        \t\n",
    "    return fx,fy,fz,F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ea216581-4d46-45e5-9de9-33fe47444a23",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rungeKutta(u, Ut, Uf, h, t, lbda):\n",
    "\n",
    "    if t == 0:\n",
    "        \n",
    "        fx,fy,fz,k1 = lind(u, Ut, Uf, t, lbda)\n",
    "        k1 = np.dot(k1,Ut)\n",
    "        fx,fy,fz,k2 = lind(u, (Ut+h/2*k1), Uf, t, lbda)\n",
    "        k2 = np.dot(k2,(Ut+h/2*k1))\n",
    "        fx,fy,fz,k3 = lind(u, (Ut+h/2*k2), Uf, t, lbda)\n",
    "        k3 = np.dot(k3,(Ut+h/2*k2))\n",
    "        fx,fy,fz,k4 = lind(u, (Ut+h*k3), Uf, t, lbda)\n",
    "        k4 = np.dot(k4,(Ut+h*k3))\n",
    "        a = fx;\n",
    "        b = fy;\n",
    "        c = fz;\n",
    "\n",
    "    else:\n",
    "\n",
    "        fx,fy,fz,k1 = lind(u, Ut, Uf, t, lbda)\n",
    "        k1 = np.dot(k1,Ut)\n",
    "        fx,fy,fz,k2 = lind(u, (Ut+h/2*k1), Uf, t+h/2, lbda)\n",
    "        k2 = np.dot(k2,(Ut+h/2*k1))\n",
    "        fx,fy,fz,k3 = lind(u, (Ut+h/2*k2), Uf, t+h/2, lbda)\n",
    "        k3 = np.dot(k3,(Ut+h/2*k2))\n",
    "        fx,fy,fz,k4 = lind(u, (Ut+h*k3), Uf, t+h, lbda)\n",
    "        k4 = np.dot(k4,(Ut+h*k3))\n",
    "        a = fx;\n",
    "        b = fy;\n",
    "        c = fz;\n",
    "\n",
    "    \n",
    "    result = Ut+(h/6)*(k1+2*k2+2*k3+k4);\n",
    "    return a,b,c,result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "aaef928c-c1b8-4841-a1d9-2626a9d13933",
   "metadata": {},
   "outputs": [],
   "source": [
    "def func_objetivo(u, Ut, Uf, h, tempo, lbda):\n",
    "    a, b, c, Ut1 = rungeKutta(u, Ut, Uf, h, tempo, lbda)\n",
    "    return (np.linalg.norm(Ut1-Uf))**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "14d34807-6f7a-49b9-b471-0a0f315d9bd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gerar_populacao():\n",
    "    populacao = np.zeros((TAMANHO_POP,3))\n",
    "    for individuo in range(TAMANHO_POP):\n",
    "        for genes in range(3):\n",
    "            populacao[individuo,genes] = uniform(MIN, MAX)\n",
    "    return populacao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1e415da2-51bb-45ab-9c26-cb7c73698aea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcular_func(populacao, Ut, Uf, h, tempo, TAMANHO_POP, lbda):\n",
    "    valor_func = np.zeros(TAMANHO_POP)\n",
    "    for individuo in range(TAMANHO_POP):\n",
    "        valor_func[individuo] = func_objetivo(populacao[individuo,:], Ut, Uf, h, tempo, lbda)\n",
    "    return valor_func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4fa7e339-64bf-4566-acdd-74b195efb7f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def selecao(valor_fitness):\n",
    "    pos = np.random.choice(range(TAMANHO_POP), 2, replace=False)\n",
    "    valor = valor_fitness[pos[0]] < valor_fitness[pos[1]]\n",
    "    if valor == True:\n",
    "        return pos[0]\n",
    "    else:\n",
    "        return pos[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dc674115-38e7-491f-8622-6dc456dbff3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def divisao_fitness(valor_funcao_objetivo):\n",
    "    divisao = 0\n",
    "    for i in range(len(valor_funcao_objetivo)):\n",
    "        divisao += valor_funcao_objetivo[i]\n",
    "    return divisao\n",
    "\n",
    "def fitness(valor_funca_objetivo):\n",
    "    return valor_funca_objetivo/divisao_fitness(valor_funca_objetivo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "407419cf-49a3-4032-b401-8978fdf32118",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cruzamento(pai1, pai2):\n",
    "    x = random()\n",
    "    filho1 = x*pai1+(1-x)*pai2\n",
    "    filho2 = (1-x)*pai1+x*pai2\n",
    "    return filho1, filho2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "edeb49da-4638-4cdf-b609-35302b0306cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mutacao(individuo, horizonte):\n",
    "    \n",
    "    # Gaussian function\n",
    "    for i in range (0, horizonte):\n",
    "        if random() < TAXA_MUTACAO:\n",
    "            individuo[i] = (1/np.sqrt(2*np.pi))*np.exp((-1/2*(uniform(MIN, MAX)-2)**2))\n",
    "    \n",
    "    return individuo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "37f841b8-c606-4378-8812-e5b8e5dffc74",
   "metadata": {},
   "outputs": [],
   "source": [
    "def genetico(Ut, Uf, h, tempo, TAMANHO_POP, lbda):\n",
    "    \n",
    "    horizonte = 3\n",
    "    pop = gerar_populacao()\n",
    "    fo = calcular_func(pop, Ut, Uf, h, tempo, TAMANHO_POP, lbda)\n",
    "    fit = fitness(fo)\n",
    "    fit_edit = fit\n",
    "    min_fit = min(fit)\n",
    "            \n",
    "    melhor_fo = np.zeros(GERACOES)\n",
    "    for geracao in range(GERACOES):\n",
    "        new_pop = np.empty((0, horizonte))\n",
    "        for i in range(round((TAMANHO_POP)/2)):\n",
    "            pai1 = 0\n",
    "            pai2 = 0\n",
    "            while pai1 == pai2:\n",
    "                pai1 = selecao(fit)\n",
    "                pai2 = selecao(fit)\n",
    "            if random() < TAXA_CRUZAMENTO:\n",
    "                filho1, filho2 = cruzamento(pop[pai1, :], pop[pai2, :])\n",
    "                filho1 = mutacao(filho1, horizonte)\n",
    "                filho2 = mutacao(filho2, horizonte)\n",
    "                new_pop = np.vstack([new_pop, filho1, filho2])\n",
    "            else:\n",
    "                pais = np.vstack([mutacao(pop[pai1, :], horizonte), mutacao(pop[pai2, :], horizonte)])\n",
    "                new_pop = np.vstack([new_pop, pais])\n",
    "                \n",
    "        fo = calcular_func(pop, Ut, Uf, h, tempo, TAMANHO_POP, lbda)\n",
    "        fit = fitness(fo)\n",
    "        min_fo = min(fo)\n",
    "        melhor_fo[geracao] = min_fo\n",
    "        pos_min_fo = np.where(fo == min_fo)\n",
    "                \n",
    "    return pop[pos_min_fo,:][0,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "25912f07-5ea9-471e-83a5-2b92044ec127",
   "metadata": {},
   "outputs": [],
   "source": [
    "def leis_controle(fx, fy, fz, quant_pontos, lbda):\n",
    "    ts = np.linspace(0, 0.1, quant_pontos)\n",
    "\n",
    "    plt.ylabel(\"Valores das leis de controle\") \n",
    "    plt.xlabel('Tempo (u. a.)') \n",
    "    plt.plot(ts, fx, color='g', marker='o', linewidth=1, markersize=1, label=\"$f_x(t)$\")\n",
    "    plt.plot(ts, fy, color='b', marker='_', linewidth=1, markersize=1, label=\"$f_y(t)$\")\n",
    "    plt.plot(ts, fz, color='r', marker='.', linewidth=1, markersize=1, label=\"$f_z(t)$\")\n",
    "    plt.legend(loc=\"upper right\")\n",
    "    plt.title(fr\"Leis de controle para $\\gamma = {lbda}$\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "25a8f695-a131-41ef-b17c-88da84c48ade",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fidelidade(fid, quant_pontos, lbda):\n",
    "    ts = np.linspace(0, 0.1, quant_pontos)\n",
    "\n",
    "    fig, ax = plt.subplots()\n",
    "\n",
    "    ax.set_ylabel(\"Valores de fidelidade\") \n",
    "    ax.set_xlabel('Tempo (u. a.)') \n",
    "    ax.plot(ts, np.abs(fid), color='g', marker='*', linewidth=1, markersize=1, label=fr\"$\\gamma = {lbda}$\")\n",
    "    ax.legend(loc=\"center right\")\n",
    "    ax.set_title(fr\"Fidelidade com $\\gamma = {lbda}$\")\n",
    "\n",
    "    x1, x2, y1, y2 = 2.5, 4, 0, max(np.abs(fid))\n",
    "    axins = inset_axes(ax, width=\"30%\", height=\"30%\", loc='upper center', borderpad=3)\n",
    "    axins.set_xlim(0.009, 0.020)\n",
    "    axins.set_ylim(0.98, 1)\n",
    "\n",
    "    axins.plot(ts, np.abs(fid), color='g', marker='*', linewidth=1, markersize=1, label=fr\"$\\gamma = {lbda}$\")\n",
    "    ax.indicate_inset_zoom(axins)\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "fb93a47b-e5ed-4861-9d8c-b571f12c0317",
   "metadata": {},
   "outputs": [],
   "source": [
    "def distance(fid, quant_pontos, lbda):\n",
    "    ts = np.linspace(0, 0.1, quant_pontos)\n",
    "\n",
    "    fig, ax = plt.subplots()\n",
    "\n",
    "    ax.set_ylabel(\"Valores de distância\") \n",
    "    ax.set_xlabel('Tempo (u. a.)') \n",
    "    ax.plot(ts, np.abs(fid), color='g', marker='*', linewidth=1, markersize=1, label=fr\"$\\gamma = {lbda}$\")\n",
    "    ax.legend(loc=\"center right\")\n",
    "    ax.set_title(fr\"Distância entre os operadores de evolução com $\\gamma = {lbda}$\")\n",
    "\n",
    "    #x1, x2, y1, y2 = 2.5, 4, 0, max(np.abs(fid))\n",
    "    #axins = inset_axes(ax, width=\"30%\", height=\"30%\", loc='upper center', borderpad=3)\n",
    "    #axins.set_xlim(0.009, 0.020)\n",
    "    #axins.set_ylim(0.98, 1)\n",
    "\n",
    "    #axins.plot(ts, np.abs(fid), color='g', marker='*', linewidth=1, markersize=1, label=fr\"$\\gamma = {lbda}$\")\n",
    "    #ax.indicate_inset_zoom(axins)\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "88260532-c848-4882-87e3-c2924a219ff0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def densidade(rho, quant_pontos, lbda):\n",
    "    ts = np.linspace(0, 0.1, quant_pontos)\n",
    "\n",
    "    fig, ax = plt.subplots()\n",
    "\n",
    "    ax.set_ylabel('Valores da matriz de densidade') \n",
    "    ax.set_xlabel('Tempo (u. a.)') \n",
    "    ax.plot(ts, abs(rho[0]), color='g', marker='o', linewidth=1, markersize=1, label=r\"$\\rho_{00}$\")\n",
    "    ax.plot(ts, abs(rho[1]), color='b', marker='8', linewidth=1, markersize=1, label=r\"$\\rho_{01}$\")\n",
    "    ax.plot(ts, abs(rho[2]), color='r', marker='.', linewidth=1, markersize=1, label=r\"$\\rho_{10}$\")\n",
    "    ax.plot(ts, abs(rho[3]), color='y', marker='*', linewidth=1, markersize=1, label=r\"$\\rho_{11}$\")\n",
    "    ax.legend(loc=\"center right\")\n",
    "    ax.set_title(fr\"Evolução da matriz de densidade $\\gamma = {lbda}$\")\n",
    "\n",
    "    x1, x2, y1, y2 = 2.5, 4, 0, max(max(abs(rho[0])), max(abs(rho[1])), max(abs(rho[2])), max(abs(rho[3])))\n",
    "    axins = inset_axes(ax, width=\"30%\", height=\"30%\", loc='upper center', borderpad=3)\n",
    "    axins.set_xlim(0.009, 0.020)\n",
    "    axins.set_ylim(0.98, 1)\n",
    "\n",
    "    axins.plot(ts, abs(rho[0]), color='g', marker='o', linewidth=1, markersize=1, label=r\"$\\rho_{00}$\")\n",
    "    axins.plot(ts, abs(rho[1]), color='b', marker='8', linewidth=1, markersize=1, label=r\"$\\rho_{01}$\")\n",
    "    axins.plot(ts, abs(rho[2]), color='r', marker='.', linewidth=1, markersize=1, label=r\"$\\rho_{10}$\")\n",
    "    axins.plot(ts, abs(rho[3]), color='y', marker='*', linewidth=1, markersize=1, label=r\"$\\rho_{11}$\")\n",
    "\n",
    "    ax.indicate_inset_zoom(axins)\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "29ff5391-7eea-4c95-936e-2a4220591a25",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    u = [70, 106, 66, 0.35, 0.31, 0.34] # Hadamard\n",
    "    \n",
    "    Ut = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]\n",
    "    Uf = [[0, 0, 1], [0, -1, 0], [1, 0, 0]] # Hadamard\n",
    "    \n",
    "    r0 = [[1], [0], [0]]\n",
    "    rf = np.dot(Uf, r0)\n",
    "    pf = [[1/2*(1+rf[2][0]), 1/2*(rf[0][0]-1j*rf[1][0])], [1/2*(rf[0][0]+1j*rf[1][0]), 1/2*(1-rf[2][0])]]\n",
    "    \n",
    "    h=0.001\n",
    "    t=0\n",
    "    i=0\n",
    "    lbda=0.01\n",
    "    # Proposta do algoritmo genético\n",
    "    resultado_algoritmo_genetico = genetico(Ut, Uf, h, t, TAMANHO_POP, lbda) \n",
    "    u[0] = resultado_algoritmo_genetico[0]\n",
    "    u[1] = resultado_algoritmo_genetico[1]\n",
    "    u[2] = resultado_algoritmo_genetico[2]\n",
    "    distance_vector = []\n",
    "    fx_vector = []\n",
    "    fy_vector = []\n",
    "    fz_vector = []\n",
    "    rho_vector = np.zeros((4,100),dtype=np.complex128)\n",
    "    fid_vector = []\n",
    "    fid_autores = []\n",
    "       \n",
    "    while t < 100:\n",
    "        a,b,c,Ut = rungeKutta(u, Ut, Uf, h, t, lbda)\n",
    "        D = np.linalg.norm(Ut-Uf)**2\n",
    "        distance_vector.append(D)\n",
    "        fx_vector.append(a)\n",
    "        fy_vector.append(b)\n",
    "        fz_vector.append(c)\n",
    "        rt = np.dot(Ut, r0)\n",
    "        pt = [[1/2*(1+rt[2][0]), 1/2*(rt[0][0]-1j*rt[1][0])], [1/2*(rt[0][0]+1j*rt[1][0]), 1/2*(1-rt[2][0])]]\n",
    "        rho_vector[0][t] = pt[0][0]\n",
    "        rho_vector[1][t] = pt[0][1]\n",
    "        rho_vector[2][t] = pt[1][0]\n",
    "        rho_vector[3][t] = pt[1][1]\n",
    "        fid_vector.append((np.trace(sqrtm(sqrtm(pt) @ pf @ sqrtm(pt))))**2)\n",
    "        fid_autores.append((np.trace(np.dot(Ut, np.transpose(Ut)))+np.abs(np.trace(np.dot(np.transpose(Uf), Ut)))**2)/(3*(3+1)))\n",
    "        resultado_algoritmo_genetico = genetico(Ut, Uf, h, t, TAMANHO_POP, lbda) \n",
    "        u[0] = resultado_algoritmo_genetico[0]\n",
    "        u[1] = resultado_algoritmo_genetico[1]\n",
    "        u[2] = resultado_algoritmo_genetico[2]\n",
    "        t += 1\n",
    "    \n",
    "    rt = np.dot(Ut, r0)\n",
    "    pt = [[1/2*(1+rt[2][0]), 1/2*(rt[0][0]-1j*rt[1][0])], [1/2*(rt[0][0]+1j*rt[1][0]), 1/2*(1-rt[2][0])]]\n",
    "    \n",
    "    #leis_controle(fx_vector,fy_vector,fz_vector,t,lbda)\n",
    "    #densidade(rho_vector,t,lbda)\n",
    "    #fidelidade(fid_vector,t,lbda)\n",
    "    #fidelidade(fid_autores,t,lbda)\n",
    "    #distance(distance_vector,t,lbda)\n",
    "\n",
    "    return fid_vector, fid_autores, rho_vector, distance_vector, fx_vector, fy_vector, fz_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e1f25c52-1dd2-4e99-ba59-fda1c3a9c6dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valores de média na iteração 1:\n",
      "Portas: 1.0017129880580555\n",
      "Estados: (1.000285999696822-1.281492799730282e-07j)\n",
      "Distância: 2.1155226410232688e-05\n",
      " \n",
      "Valores de média na iteração 2:\n",
      "Portas: 1.0042212797019827\n",
      "Estados: (1.0005192647897534-2.3191040845817186e-07j)\n",
      "Distância: 3.931637569651282e-05\n",
      " \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_144248/116918231.py:4: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  f = -a*SA-h*(SB/SA)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valores de média na iteração 3:\n",
      "Portas: 1.011507357377332\n",
      "Estados: (1.0031513402896668-1.2256610428642966e-07j)\n",
      "Distância: 0.0002674201092937129\n",
      " \n",
      "Valores de média na iteração 4:\n",
      "Portas: 1.0090815814879415\n",
      "Estados: (1.002416512999754-3.749983449943347e-07j)\n",
      "Distância: 0.00020268783906123277\n",
      " \n",
      "Valores de média na iteração 5:\n",
      "Portas: 1.0072477564379243\n",
      "Estados: (1.001998022207219-3.0296998213309546e-07j)\n",
      "Distância: 0.0001640762754337133\n",
      " \n",
      "Valores de média na iteração 6:\n",
      "Portas: 1.0113048752963374\n",
      "Estados: (1.0033553497495016-2.720841398664234e-07j)\n",
      "Distância: 0.00029510471816750097\n",
      " \n",
      "Valores de média na iteração 7:\n",
      "Portas: 1.0087505368036922\n",
      "Estados: (1.0021823548731563-1.5596186707020057e-06j)\n",
      "Distância: 0.0002576795583491324\n",
      " \n",
      "Valores de média na iteração 8:\n",
      "Portas: 1.0082450201341169\n",
      "Estados: (1.002186420015756-1.307333329402107e-06j)\n",
      "Distância: 0.00022963610678718843\n",
      " \n",
      "Valores de média na iteração 9:\n",
      "Portas: 1.0095893389550825\n",
      "Estados: (1.0026843952073388-1.1416494025407853e-06j)\n",
      "Distância: 0.00025449097149093\n",
      " \n",
      "Valores de média na iteração 10:\n",
      "Portas: 1.0148968492924886\n",
      "Estados: (1.004656935150675-1.2167356763051482e-06j)\n",
      "Distância: 0.0006498836291671944\n",
      " \n",
      "Valores de média na iteração 11:\n",
      "Portas: 1.0140519941907389\n",
      "Estados: (1.0041208638903856-8.766546210678464e-07j)\n",
      "Distância: 0.0006049262967695763\n",
      " \n",
      "Valores de média na iteração 12:\n",
      "Portas: 1.009791975417789\n",
      "Estados: (1.0040684315135855-7.343894769319003e-07j)\n",
      "Distância: 0.000576285065566976\n",
      " \n",
      "Valores de média na iteração 13:\n",
      "Portas: 1.0163624945504808\n",
      "Estados: (1.0064293924202141-5.717791204734371e-07j)\n",
      "Distância: 0.0013190350622088237\n",
      " \n",
      "Valores de média na iteração 14:\n",
      "Portas: 1.0158071116017422\n",
      "Estados: (1.0060597998227687-5.809961185459381e-07j)\n",
      "Distância: 0.001230184026067956\n",
      " \n",
      "Valores de média na iteração 15:\n",
      "Portas: 1.0152647776180748\n",
      "Estados: (1.005781724479678-5.536472182802097e-07j)\n",
      "Distância: 0.0011518976402193429\n",
      " \n",
      "Valores de média na iteração 16:\n",
      "Portas: 1.0115572185949826\n",
      "Estados: (1.0036645435973577-9.003769225791044e-07j)\n",
      "Distância: 0.0010870551062705308\n",
      " \n",
      "Valores de média na iteração 17:\n",
      "Portas: 1.0109616247339137\n",
      "Estados: (1.0034385695781536-9.175013295205233e-07j)\n",
      "Distância: 0.0010237931430692178\n",
      " \n",
      "Valores de média na iteração 18:\n",
      "Portas: 1.0105400122630905\n",
      "Estados: (1.0032718607534887-8.455790872441362e-07j)\n",
      "Distância: 0.0009690463551744548\n",
      " \n",
      "Valores de média na iteração 19:\n",
      "Portas: 1.0103424787143054\n",
      "Estados: (1.0031410541790688-8.258571352336766e-07j)\n",
      "Distância: 0.0009204619650510582\n",
      " \n",
      "Valores de média na iteração 20:\n",
      "Portas: 1.0101727042640107\n",
      "Estados: (1.0031625539055995-7.908527731772114e-07j)\n",
      "Distância: 0.0008806976990295612\n",
      " \n",
      "Valores de média na iteração 21:\n",
      "Portas: 1.0100045923601115\n",
      "Estados: (1.003092229358299-7.989101347584425e-07j)\n",
      "Distância: 0.0008406711934352892\n",
      " \n",
      "Valores de média na iteração 22:\n",
      "Portas: 1.0094662072127247\n",
      "Estados: (1.002946987645297-7.70814461196004e-07j)\n",
      "Distância: 0.0008029162121061732\n",
      " \n",
      "Valores de média na iteração 23:\n",
      "Portas: 1.0093003280968431\n",
      "Estados: (1.0028457013669607-6.961008014751946e-07j)\n",
      "Distância: 0.0007695821674553484\n",
      " \n",
      "Valores de média na iteração 24:\n",
      "Portas: 1.0089818228474883\n",
      "Estados: (1.0027676130491117-6.425029869792632e-07j)\n",
      "Distância: 0.0007432744047609405\n",
      " \n",
      "Valores de média na iteração 25:\n",
      "Portas: 1.0095119252265505\n",
      "Estados: (1.0027573367474076-5.397591622393719e-07j)\n",
      "Distância: 0.0007443549138102621\n",
      " \n",
      "Valores de média na iteração 26:\n",
      "Portas: 1.0089963454718465\n",
      "Estados: (1.0026091776484083-6.109145388019485e-07j)\n",
      "Distância: 0.0007159979836831835\n",
      " \n",
      "Valores de média na iteração 27:\n",
      "Portas: 1.0087983931391358\n",
      "Estados: (1.0024702637881777-4.4195712492364185e-07j)\n",
      "Distância: 0.0006932308277294419\n",
      " \n",
      "Valores de média na iteração 28:\n",
      "Portas: 1.008725925133136\n",
      "Estados: (1.0024210081071687-4.1761863963068463e-07j)\n",
      "Distância: 0.0006701739660007695\n",
      " \n",
      "Valores de média na iteração 29:\n",
      "Portas: 1.0082307207256043\n",
      "Estados: (1.0023338199152425-3.992727928957108e-07j)\n",
      "Distância: 0.0006473507313126165\n",
      " \n",
      "Valores de média na iteração 30:\n",
      "Portas: 1.0082843172222493\n",
      "Estados: (1.0023192575191764-3.9464711073117843e-07j)\n",
      "Distância: 0.0006284962508444688\n",
      " \n",
      "Valores de média na iteração 31:\n",
      "Portas: 1.0078899148555405\n",
      "Estados: (1.0021145061375096-4.4145311024338807e-07j)\n",
      "Distância: 0.0006093519042418454\n",
      " \n",
      "Valores de média na iteração 32:\n",
      "Portas: 1.0077637993037236\n",
      "Estados: (1.0020793511971438-4.721450417776656e-07j)\n",
      "Distância: 0.0005908983877801342\n",
      " \n",
      "Valores de média na iteração 33:\n",
      "Portas: 1.007844809555133\n",
      "Estados: (1.0020682807987837-4.5192530375038734e-07j)\n",
      "Distância: 0.0005757606859504243\n",
      " \n",
      "Valores de média na iteração 34:\n",
      "Portas: 1.0062082031144262\n",
      "Estados: (1.0010893006469197-2.6389986699242596e-07j)\n",
      "Distância: 0.0005676547754770266\n",
      " \n",
      "Valores de média na iteração 35:\n",
      "Portas: 1.00520281435683\n",
      "Estados: (1.000578847099438-5.030476052599966e-07j)\n",
      "Distância: 0.0005589017113792409\n",
      " \n",
      "Valores de média na iteração 36:\n",
      "Portas: 1.0051514653852247\n",
      "Estados: (1.0005483629551448-3.2887392591151423e-07j)\n",
      "Distância: 0.0005467670598135508\n",
      " \n",
      "Valores de média na iteração 37:\n",
      "Portas: 1.004092752722195\n",
      "Estados: (0.9999560104390118-2.3795225426041356e-07j)\n",
      "Distância: 0.0005342661986233044\n",
      " \n",
      "Valores de média na iteração 38:\n",
      "Portas: 1.00401865812937\n",
      "Estados: (0.9999091950928715-1.4593036611451545e-07j)\n",
      "Distância: 0.0005210772502486445\n",
      " \n",
      "Valores de média na iteração 39:\n",
      "Portas: 1.0039584799290429\n",
      "Estados: (0.9999143595735801-1.632976638418538e-07j)\n",
      "Distância: 0.0005078192127047506\n",
      " \n",
      "Valores de média na iteração 40:\n",
      "Portas: 1.00370015553835\n",
      "Estados: (1.0000489346283505-1.403652593700276e-07j)\n",
      "Distância: 0.000501140053746515\n",
      " \n",
      "Valores de média na iteração 41:\n",
      "Portas: 1.0038237113005557\n",
      "Estados: (1.000187124556009-1.2671531529562227e-07j)\n",
      "Distância: 0.0004945644089678959\n",
      " \n",
      "Valores de média na iteração 42:\n",
      "Portas: 1.003741855317442\n",
      "Estados: (1.0000431345077072-1.929537659816506e-07j)\n",
      "Distância: 0.0004917856028800066\n",
      " \n",
      "Valores de média na iteração 43:\n",
      "Portas: 1.0030155353008257\n",
      "Estados: (0.9996152509223076-4.064745512256768e-07j)\n",
      "Distância: 0.0004840795257478291\n",
      " \n",
      "Valores de média na iteração 44:\n",
      "Portas: 1.003519481139559\n",
      "Estados: (0.9997625013938146-4.081760213759486e-07j)\n",
      "Distância: 0.00048665700360246765\n",
      " \n",
      "Valores de média na iteração 45:\n",
      "Portas: 1.0037569967210538\n",
      "Estados: (0.9997876376089827-2.6781644989988077e-07j)\n",
      "Distância: 0.00048508285060369806\n",
      " \n",
      "Valores de média na iteração 46:\n",
      "Portas: 1.0041123211520633\n",
      "Estados: (0.9999065338284407-2.491537826321747e-07j)\n",
      "Distância: 0.0004821111259568778\n",
      " \n",
      "Valores de média na iteração 47:\n",
      "Portas: 1.004182743141551\n",
      "Estados: (0.9998610540594217-1.2504721083493993e-07j)\n",
      "Distância: 0.0004819647386173166\n",
      " \n",
      "Valores de média na iteração 48:\n",
      "Portas: 1.0042065484565088\n",
      "Estados: (0.9998884007180311-1.4349117150717798e-07j)\n",
      "Distância: 0.0004725264661265956\n",
      " \n",
      "Valores de média na iteração 49:\n",
      "Portas: 1.003706502207266\n",
      "Estados: (0.9996785980181043-1.9825518245899974e-07j)\n",
      "Distância: 0.0004630795571503427\n",
      " \n",
      "Valores de média na iteração 50:\n",
      "Portas: 1.0038927533994189\n",
      "Estados: (0.9997399577970567-2.0605660197351245e-07j)\n",
      "Distância: 0.0004592062114844285\n",
      " \n"
     ]
    }
   ],
   "source": [
    "portas = []\n",
    "estados = []\n",
    "distancia = []\n",
    "\n",
    "for i in range(1, 51):\n",
    "    fid_vector, fid_autores, rho_vector, distance_vector, fx_vector, fy_vector, fz_vector = main()\n",
    "    portas.append(sum(fid_autores[30:])/(len(fid_autores)-30))\n",
    "    estados.append(sum(fid_vector[30:])/(len(fid_vector)-30))\n",
    "    distancia.append(sum(distance_vector[80:])/(len(distance_vector)-80))\n",
    "\n",
    "    print(f\"Valores de média na iteração {i}:\")\n",
    "    print(f\"Portas: {sum(portas)/i}\")\n",
    "    print(f\"Estados: {sum(estados)/i}\")\n",
    "    print(f\"Distância: {sum(distancia)/i}\")\n",
    "    print(\" \")"
   ]
  }
 ],
 "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}