Lyapunov-Gate-Hadamard-Genetico-300.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": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_29179/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 1:\n",
      "Portas: 0.9769598043463792\n",
      "Estados: (0.985689195680909+5.96745984179138e-06j)\n",
      "Distância: 0.00025991563673909986\n",
      " \n",
      "Valores de média na iteração 2:\n",
      "Portas: 0.9845574254691098\n",
      "Estados: (0.9898793550091594+5.787860867288728e-06j)\n",
      "Distância: 0.00016125324530965547\n",
      " \n",
      "Valores de média na iteração 3:\n",
      "Portas: 1.0021635339863861\n",
      "Estados: (0.9966515909650681+3.5266754427715667e-06j)\n",
      "Distância: 0.0006004126051081658\n",
      " \n",
      "Valores de média na iteração 4:\n",
      "Portas: 1.0034497870104553\n",
      "Estados: (0.9981445521992107+2.990477370274636e-06j)\n",
      "Distância: 0.0006117790416907765\n",
      " \n",
      "Valores de média na iteração 5:\n",
      "Portas: 1.003080063698838\n",
      "Estados: (0.9985341825827608+2.3128207255952403e-06j)\n",
      "Distância: 0.0004907543173658713\n",
      " \n",
      "Valores de média na iteração 6:\n",
      "Portas: 1.013529874460233\n",
      "Estados: (1.0025483478707236+2.0335824633265523e-06j)\n",
      "Distância: 0.0011581271230703925\n",
      " \n",
      "Valores de média na iteração 7:\n",
      "Portas: 1.011650350338385\n",
      "Estados: (1.0021444435680036+1.695098420643787e-06j)\n",
      "Distância: 0.0010793005974568959\n",
      " \n",
      "Valores de média na iteração 8:\n",
      "Portas: 1.0105492011121715\n",
      "Estados: (1.00245308789813+1.5152835735224736e-06j)\n",
      "Distância: 0.0009693143383341706\n",
      " \n",
      "Valores de média na iteração 9:\n",
      "Portas: 1.0102342709025713\n",
      "Estados: (1.0024162522081062+1.646004703093017e-06j)\n",
      "Distância: 0.0008879185920956329\n",
      " \n",
      "Valores de média na iteração 10:\n",
      "Portas: 1.0106772108520068\n",
      "Estados: (1.002394123295637+1.9243960859138637e-06j)\n",
      "Distância: 0.0008426756582910302\n",
      " \n",
      "Valores de média na iteração 11:\n",
      "Portas: 1.005615456366541\n",
      "Estados: (1.0016676211059077+2.3999884011364744e-06j)\n",
      "Distância: 0.0007826331757677347\n",
      " \n",
      "Valores de média na iteração 12:\n",
      "Portas: 0.9934907293575158\n",
      "Estados: (1.0015177148901584+2.183618583383184e-06j)\n",
      "Distância: 0.0008363180781979528\n",
      " \n",
      "Valores de média na iteração 13:\n",
      "Portas: 0.9957622150200398\n",
      "Estados: (1.0007149166179636+1.5540052264384903e-06j)\n",
      "Distância: 0.0010040523850693023\n",
      " \n",
      "Valores de média na iteração 14:\n",
      "Portas: 0.997110190533744\n",
      "Estados: (1.000962048603186+1.5103129012250362e-06j)\n",
      "Distância: 0.0009459344224519492\n",
      " \n",
      "Valores de média na iteração 15:\n",
      "Portas: 1.001167679106531\n",
      "Estados: (1.0020146935375915+1.4075396112149468e-06j)\n",
      "Distância: 0.0010963099091026213\n",
      " \n",
      "Valores de média na iteração 16:\n",
      "Portas: 1.0014003287260036\n",
      "Estados: (1.0018989515821273+1.1910878382138346e-06j)\n",
      "Distância: 0.001031777903378429\n",
      " \n",
      "Valores de média na iteração 17:\n",
      "Portas: 1.0007970303768272\n",
      "Estados: (1.0020312202916797+1.1184360191511285e-06j)\n",
      "Distância: 0.0009806604614226951\n",
      " \n",
      "Valores de média na iteração 18:\n",
      "Portas: 1.0015213745663538\n",
      "Estados: (1.0021950549289935+1.0542487915943042e-06j)\n",
      "Distância: 0.0009376244216022821\n",
      " \n",
      "Valores de média na iteração 19:\n",
      "Portas: 1.0015903622437061\n",
      "Estados: (1.0021408177889723+9.861153607129548e-07j)\n",
      "Distância: 0.0008916190929394211\n",
      " \n",
      "Valores de média na iteração 20:\n",
      "Portas: 1.0018137728228373\n",
      "Estados: (1.0022193191953455+9.99824522244686e-07j)\n",
      "Distância: 0.0008505755026773853\n",
      " \n",
      "Valores de média na iteração 21:\n",
      "Portas: 1.0039657983888195\n",
      "Estados: (1.0027638391620801+9.45285256115287e-07j)\n",
      "Distância: 0.0009258392130152405\n",
      " \n",
      "Valores de média na iteração 22:\n",
      "Portas: 1.00888268706672\n",
      "Estados: (1.0044890034736098+7.962851812415306e-07j)\n",
      "Distância: 0.0014925082876901517\n",
      " \n",
      "Valores de média na iteração 23:\n",
      "Portas: 1.009206184244076\n",
      "Estados: (1.0045315538359356+7.665935289852721e-07j)\n",
      "Distância: 0.0014377528000980068\n",
      " \n",
      "Valores de média na iteração 24:\n",
      "Portas: 1.0087657778502386\n",
      "Estados: (1.0043099937259299+7.255710837046087e-07j)\n",
      "Distância: 0.0013779822380833417\n",
      " \n",
      "Valores de média na iteração 25:\n",
      "Portas: 1.00855846091063\n",
      "Estados: (1.004080292585847+5.235085014385069e-07j)\n",
      "Distância: 0.0013264512328896355\n",
      " \n",
      "Valores de média na iteração 26:\n",
      "Portas: 1.008592491741364\n",
      "Estados: (1.003978208264014+5.024900877361366e-07j)\n",
      "Distância: 0.0012790889595729617\n",
      " \n",
      "Valores de média na iteração 27:\n",
      "Portas: 1.0092953996579992\n",
      "Estados: (1.0041601098011772+5.623545375114508e-07j)\n",
      "Distância: 0.001259599131999656\n",
      " \n",
      "Valores de média na iteração 28:\n",
      "Portas: 1.0093312351100665\n",
      "Estados: (1.0040446025701057+4.744633614116814e-07j)\n",
      "Distância: 0.0012251869713245454\n",
      " \n",
      "Valores de média na iteração 29:\n",
      "Portas: 1.008753993231519\n",
      "Estados: (1.0035960747590436+7.546134040233643e-07j)\n",
      "Distância: 0.001191821568560226\n",
      " \n",
      "Valores de média na iteração 30:\n",
      "Portas: 1.0056339524107194\n",
      "Estados: (1.003480654857953+7.768066381077504e-07j)\n",
      "Distância: 0.0011530316240888042\n",
      " \n",
      "Valores de média na iteração 31:\n",
      "Portas: 1.005602181491275\n",
      "Estados: (1.0033997665240997+7.308705517584984e-07j)\n",
      "Distância: 0.0011165194974365911\n",
      " \n",
      "Valores de média na iteração 32:\n",
      "Portas: 1.0057118978512531\n",
      "Estados: (1.0033689294153116+6.708067710650696e-07j)\n",
      "Distância: 0.0010839195222206405\n",
      " \n",
      "Valores de média na iteração 33:\n",
      "Portas: 1.0055920860528023\n",
      "Estados: (1.0033505699746823+6.620889399756228e-07j)\n",
      "Distância: 0.001053955978398207\n",
      " \n",
      "Valores de média na iteração 34:\n",
      "Portas: 1.0057208917603437\n",
      "Estados: (1.0032130021795622+6.852767514256644e-07j)\n",
      "Distância: 0.0010354404391338095\n",
      " \n",
      "Valores de média na iteração 35:\n",
      "Portas: 1.0056770246592566\n",
      "Estados: (1.0031399256138849+6.514267633968736e-07j)\n",
      "Distância: 0.0010062959957287375\n",
      " \n",
      "Valores de média na iteração 36:\n",
      "Portas: 1.005475873531629\n",
      "Estados: (1.0030209165437831+6.078865279789869e-07j)\n",
      "Distância: 0.00097843836642448\n",
      " \n",
      "Valores de média na iteração 37:\n",
      "Portas: 1.007128455302997\n",
      "Estados: (1.0035538181640284+5.686527937719546e-07j)\n",
      "Distância: 0.0010721237146266716\n",
      " \n",
      "Valores de média na iteração 38:\n",
      "Portas: 1.0067516046656195\n",
      "Estados: (1.003271207476522+6.46962290568249e-07j)\n",
      "Distância: 0.0010473202837933584\n",
      " \n",
      "Valores de média na iteração 39:\n",
      "Portas: 1.0067028235016653\n",
      "Estados: (1.0032538021982322+6.303380648137022e-07j)\n",
      "Distância: 0.0010538578158198683\n",
      " \n",
      "Valores de média na iteração 40:\n",
      "Portas: 1.006432168069125\n",
      "Estados: (1.003170029000998+6.33008611310583e-07j)\n",
      "Distância: 0.0010278291467376091\n",
      " \n",
      "Valores de média na iteração 41:\n",
      "Portas: 1.0063675262288432\n",
      "Estados: (1.0030973421359353+6.11374220818401e-07j)\n",
      "Distância: 0.0010033742760396436\n",
      " \n",
      "Valores de média na iteração 42:\n",
      "Portas: 1.0059916214901339\n",
      "Estados: (1.00307280143155+5.93281840433203e-07j)\n",
      "Distância: 0.0009829625073759032\n",
      " \n",
      "Valores de média na iteração 43:\n",
      "Portas: 1.0057797482298867\n",
      "Estados: (1.0030035495275946+5.835147740482131e-07j)\n",
      "Distância: 0.000960234088117666\n",
      " \n",
      "Valores de média na iteração 44:\n",
      "Portas: 1.0059569674478892\n",
      "Estados: (1.0029316554817895+5.366534836920247e-07j)\n",
      "Distância: 0.0009438713804276344\n",
      " \n",
      "Valores de média na iteração 45:\n",
      "Portas: 1.006040230292276\n",
      "Estados: (1.002925091362967+5.071805064509262e-07j)\n",
      "Distância: 0.000925602922196337\n",
      " \n",
      "Valores de média na iteração 46:\n",
      "Portas: 1.005826499684336\n",
      "Estados: (1.0028763938687213+5.88208444520361e-07j)\n",
      "Distância: 0.0009127971463472364\n",
      " \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_29179/116918231.py:4: RuntimeWarning: overflow 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 47:\n",
      "Portas: 1.0055952099257437\n",
      "Estados: (1.0028816320380896+5.874258200993993e-07j)\n",
      "Distância: 0.0008963633443738616\n",
      " \n",
      "Valores de média na iteração 48:\n",
      "Portas: 1.0053209598283077\n",
      "Estados: (1.002905507273106+5.703865790135982e-07j)\n",
      "Distância: 0.0008803720805186025\n",
      " \n",
      "Valores de média na iteração 49:\n",
      "Portas: 1.0052729628513368\n",
      "Estados: (1.002855976757417+5.414644405602573e-07j)\n",
      "Distância: 0.0008627508453467924\n",
      " \n",
      "Valores de média na iteração 50:\n",
      "Portas: 1.0063339539788263\n",
      "Estados: (1.003192637761393+5.373658557427189e-07j)\n",
      "Distância: 0.0009165461533465047\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
}