app.py

from custom_pso import *
import streamlit as st


st.markdown('''
--------------------------------------------------------------
# Custom PSO algorithm for continuous domains

Autor: Rodrigo Araya
 
Email: [email protected]            
            ''')
st.markdown("------")

st.markdown("### 1. Explicación Algoritmo")
with st.expander("Precedimiento General"):
    st.markdown('''
1. **Generar un archivo de tamaño** `nSize=nPart`.
2. **Generar** `nPart` **soluciones iniciales**. Cada solución contiene `nVar` variables.
3. **Evaluar las soluciones** `nPart` **y agregarlas al archivo** ordenadas de la mejor a la peor solución.
4. **Mientras no se cumpla la condición de terminación** (iteraciones > maxiter):
    4.1. **Generar nuevas soluciones** utilizando algún solucionador. Las opciones son: ['Random', 'Newton', 'Coulomb'].
    4.2. **Agregar las nuevas soluciones al archivo**.
    4.3. **Eliminar soluciones duplicadas**.
    4.4. **Evaluar las soluciones y ordenarlas** de la mejor a la peor solución.
    4.5. **Mantener en el archivo las mejores** `nPar` **soluciones**.
    4.6. **Guardar los resultados de la iteración en un historial** (dataframe).
    4.7. **Evaluar la condición de terminación**. Si es negativa, regresar al paso 4.1.
''')
   
    st.image('Custom_PSO_workflow.png')

st.markdown("### 2. Metodos")
with st.expander("Random Method"):
    c1, c2 = st.columns(2)
    c1.markdown('''
Este solucionador genera una solución aleatoria para cada partícula. 
Además, también es posible aplicar un método de explotación donde el 
espacio de búsqueda se reduce en cada iteración.

1. Verificar `auto_reduce_search_space`.
2.1. Si `auto_reduce_search_space` es True.
2.1.1. Calcular límites `Lo` (lower bond) y `Up` (upper bond) basados en `x_`(soluciones inciales)
2.2. Si `auto_reduce_search_space` es `False`.
2.2.1. Establecer límites `Lo` y `Up` en cero y uno respectivamente
3.  Generar nuevas posiciones aleatorias dentro de los límites
4.  Ajustar las posiciones si exceden los límites
5.  Evaluar las nuevas posiciones utilizando 
6.  Devolver las nuevas posiciones y evaluaciones
                ''')
    
    c2.image('Random.jpg')
    
with st.expander("Newton Method"):
    c1, c2 = st.columns(2)
    
    c1.markdown(r'''
El procedimiento que genera las nuevas posiciones de las partículas 
se basa en cómo los cuerpos se atraen entre sí a través de una fuerza
de atracción (ley universal de la gravitación). Por lo tanto, el 
procedimiento será el siguiente:

1. Se reciben $n$ partículas en posiciones aleatorias dentro del 
espacio de búsqueda.
2. A cada partícula se le asigna una masa basada en la solución
proporcionada por la partícula.
    - Cuanto mejor sea la solución proporcionada por la partícula, 
    mayor será la masa asignada.
    - Métodos de asignación: Lineal, Exponencial, Cuadrática (se puede
    explorar una discusión adicional sobre mejores métodos de asignación).
    - En términos simples, se establece un rango de soluciones y se
    ajusta a un rango de masa entre 0 y `max_mass` según algún método de
    asignación.
3. Sea $F_{ij}$ la fuerza producida entre la partícula $i$ y $j$ -> 
$F_{ij} = \frac{G \cdot m_i \cdot m_j}{r^2}$ donde $r$ es la distancia 
entre las partículas, $m_i$ y $m_j$ son las masas de $i$ y $j$.
    - Por lo tanto, la fuerza resultante sobre la partícula $i$ es 
    $FR_{i} = \sum_{j=1}^{n} \frac{G \cdot m_i \cdot m_j}{r_{ij}^2}$.
    - Además, por la Ley de Newton, $F = m \cdot a$ -> $a = \frac{F}{m}$. Por lo tanto, las velocidades de cada partícula se calculan como $v_f = v_i + a \cdot t$ -> $v_f = v_i + \frac{F}{m} \cdot t$.
    - Finalmente, las posiciones se actualizan de la siguiente manera: $x' = x + v_i \cdot t + \frac{a \cdot t^2}{2}$ -> $x' = x + v_i \cdot t + \frac{F}{m} \cdot \frac{t^2}{2}$.
    - Aplicando la suposición $v_i=0$ -> $x' = x + \frac{F}{m} \cdot \frac{t^2}{2}$.
                
                ''')
    
    c2.image('Newton.jpg')
        
    st.markdown(r'''
Finalmente, si las partículas están demasiado cerca, podría causar un 
problema. Si $r_{ij}^{2}$ tiende a cero, entonces la fuerza de atracción sería 
demasiado fuerte, llevando a las partículas a separarse abruptamente 
entre sí. Para evitar este comportamiento, se establece una pequeña 
distancia `0.00000001`. Si la distancia entre dos partículas es menor
que esta distancia, se considerará que ambas partículas han colisionado. 

Por último, si más de la mitad de las partículas han colisionado, se 
aplicará una función aleatoria para generar nuevas soluciones sobre 
un espacio de búsqueda reducido.
    ''')
    
with st.expander("Coulomb Method"):
    c1, c2 = st.columns(2)
    c1.markdown(r'''
1. Se reciben n partículas en posiciones diferentes dentro del espacio 
de búsqueda.
2. A cada partícula se le asigna un tipo de carga positiva.
3. La magnitud de la carga de cada partícula está directamente relacionada
con la función objetivo.
   - Métodos de Asignación: Lineal, Exponencial, Cuadrática (se pueden
   explorar métodos de asignación mejores)
   - En resumen, se establece un rango de solución y se ajusta a un
   rango de carga entre 0 y `max_q` según algún método de asignación.
4. Cada partícula tiene una velocidad. Estas comienzan en reposo pero
cambiarán a lo largo de las iteraciones del algoritmo.
5. Las `P` partículas con los mejores valores obtenidos de la iteración
permanecerán en reposo y emitirán un campo eléctrico de signo opuesto
(negativo) atrayendo al resto.
   - Sea $E = \frac{kQ}{r^2}$ el campo magnético en un punto ubicado a
   una distancia $r$ de la fuente.
   - Sea $Fe$ la fuerza eléctrica entre el campo magnético y la partícula
   -> $Fe = E*q_{0}$ donde $q_{0}$ es la carga de la partícula.
   - Sea $F_{ij}$ la fuerza producida entre la partícula $i$ y $j$ -> 
   $F_{ij} = \frac{k*q_{i}*q_{j}}{r^2}$ donde $r$ es la distancia
   entre las partículas, $q_{i}$ y $q_{j}$ son las cargas de $i$ y $j$.
   - Por lo tanto, las fuerzas resultantes de la partícula $i$ son 
   $FR_{i} = \sum_{p=1}^{P} \frac{k*Q_{p}*Q_{i}}{r_{ip}^{2}} + \sum_{j=P+1}^{n} \frac{k*Q_{i}*Q_{j}}{r_{ij}^{2}}$
   - Además, por la Ley de Newton, $F=m*a$ -> $Fe=m*a$. Por lo tanto, las
   velocidades de cada partícula se calculan $v_{f}=v_{i}+a*t$ -> $v_{f} = v_{i} + (\frac{FR_{i}}{m})*t$
   - Las posiciones se actualizan de la siguiente manera
   $x = v_{i}*t + \frac{(a*t^{2})}{2}$ -> $x = v_{i}*t + (\frac{FR_{i}}{m})*t^{2}*0.5$
''')
    c2.image('Coulomb.jpg')
    
    st.markdown(r'''
Finalmente, si las partículas están demasiado cerca, podría causar un 
problema. Si $r_{ij}^{2}$ tiende a cero, entonces la fuerza eléctrica sería 
demasiado fuerte, llevando a las partículas a separarse abruptamente 
entre sí. Para evitar este comportamiento, se establece una pequeña 
distancia `0.00000001`. Si la distancia entre dos partículas es menor
que esta distancia, se considerará que ambas partículas han colisionado. 

Por último, si más de la mitad de las partículas han colisionado, se 
aplicará una función aleatoria para generar nuevas soluciones sobre 
un espacio de búsqueda reducido.
                
                ''')
    
st.markdown("### 3. Codigos")

with st.expander("F_newton.py"):
    st.markdown(r'''
```python
import numpy as np

def normaliazed_direction(ori, des):
    dir_ = des-ori
    nor_dir_ = dir_/np.sqrt(np.sum(dir_**2))
    nor_dir_=np.nan_to_num(nor_dir_)
    return nor_dir_

def distance(ori, des):
    dis_ = des-ori
    return dis_

def acc(F, m):
    Npar=F.shape[0]
    Nvar=F.shape[1]
    # Matriz de aceleracion
    Ac = np.full((Npar, Nvar), 0.0)
    for ind_r, row in enumerate(Ac):
        for ind_c, col in enumerate(row):
            Ac[ind_r][ind_c]=F[ind_r][ind_c]/m[ind_r]
    return Ac

def F_newton(x_, m, minimize=True, G=0.0001, keep_best=False, weight_method='Linear', t=1.0, max_mass=100.0): 
    """ The procedure that generates the new positions of the particles is based on how bodies are attracted to each other
        through an attractive force (universal law of gravitation). Thus, the procedure will be as follows:
        
        1. n particles are created at random positions within the search space.
        2. Each particle is assigned a mass based on the solution provided by the particle.
            2.1 The better the solution provided by the particle, the greater the assigned mass.
            2.2 Assignment methods -> Linear, Exponential, Quadratic (further discussion on better assignment methods can be explored).
            2.2.1 In simple terms, a range of solutions is established and adjusted to a charge range between 0 to max_mass according to some assignment method.
        3. Let Fij be the force produced between particle i and j -> Fij = G*mi*mj/(r^2) where r is the distance between the particles, mi and mj are the masses of i and j.
            3.1 Thus, the resulting force on particle i is FRi = Σ{j=1} G*mi*mj/(rij^2).
            3.2 Additionally, by Newton's Law, F = m*a -> a = F/m. Thus, the velocities of each particle are calculated as vf = vi + a*t -> vf = vi + (F/m)*t.
            3.3 Finally, the positions are updated as follows: x' = x + vi*t + (a*t^2)/2 -> x' = x + vi*t + (F/m)*(t^2)/2.
            3.4 Applying the assumption vi=0 -> x' = x + (F/m)*(t^2)/2.

    Args:
        x_ (array(size=(Npar, Nvar)): current particle positions
        m (array(size=(Npar, 1))): current mass of each particle
        minimize (bool, optional): solver objective. Defaults to True.
        G (float, optional): gravitational constant. Defaults to 0.0001.
        keep_best (bool, optional): It will save the best value obtained in each iteration. Defaults to False.
        weight_method (str, optional): method to reassign mass. Defaults to 'Linear'. Options=['Linear', 'Quadratic', 'Exponential'].
        t (float, optional): time. Defaults to 1.0.
        max_mass (float, optional): upper bound of mass to assing. Defaults to 100.0.

    Returns:
        F_total, Ac, new_pos: returns the force obtained on each particle, their acceleration, 
                              and their new positions
    """
    Npar=x_.shape[0]
    Nvar=x_.shape[1]

    # Distance Matrix
    dis = []
    for ind_r, row in enumerate(x_):
        for ind_c, col in enumerate(x_):
            dis.append(distance(x_[ind_r], x_[ind_c]))
    dis=np.array(dis).reshape((Npar,Npar,Nvar))

    # Direction Matrix
    d = []
    for ind_r, row in enumerate(x_):
        for ind_c, col in enumerate(x_):
            d.append(normaliazed_direction(x_[ind_r], x_[ind_c]))
    d=np.array(d).reshape((Npar,Npar,Nvar))

    colisioned_part = []
    r_2 = np.zeros((Npar, Npar))
    for ind_r, row in enumerate(dis):
        for ind_c, col in enumerate(dis):
            value = dis[ind_r][ind_c]
            value_2 = value**2
            value_sum = np.sum(value_2)
            if value_sum < 0.00000001: # Particles have practically collided. Notice later that F_=0.0 ahead.
                r_2[ind_r][ind_c] = 0.0
                if ind_r != ind_c:
                    colisioned_part.append(ind_c)
            else:
                r_2[ind_r][ind_c] = value_sum
    colisioned_part_ = np.unique(np.array(colisioned_part))


    # Each particle is assigned a mass magnitude based on the solution provided by the particle.
    m=np.array(m)
    min_value = m[0]
    max_value = m[-1]

    if minimize:
        m = -1.0*(m-max_value-1.0)
        max_value = m[0]

    if weight_method=="Linear":
        # We adjust the mass according to the following range [0, max_mass].
        m = (m/max_value)*max_mass
        reverse_ind = [len(m)-i-1 for i in range(len(m))] 
        m = m[reverse_ind]
        
    elif weight_method=="Quadratic": 
        # We adjust the mass according to the following range [0, max_mass].
        m_2=m**2
        m=(m_2/np.max(m_2))*max_mass
        reverse_ind = [len(m)-i-1 for i in range(len(m))] 
        m = m[reverse_ind]
        
    elif weight_method=="Exponential": 
        # We adjust the mass according to the following range [0, max_mass].
        m_exp=np.array([np.exp(i) for i in m])
        m=(m_exp/np.max(m_exp))*max_mass
        reverse_ind = [len(m)-i-1 for i in range(len(m))] 
        m = m[reverse_ind]
        
    m = np.nan_to_num(m, nan=0.0001)
    Npar=d.shape[0]
    Nvar=d.shape[2]
    F=np.full((Npar, Npar, Nvar), 0.0)
    for ind_r, row in enumerate(dis):
        for ind_c, col in enumerate(row):
            # The magnitude of the attraction force F_ is calculated.            
            d_2=r_2[ind_r][ind_c]
            if d_2==0:
                F_=0.0
            else:
                m1=m[ind_r]
                m2=m[ind_c]
                F_=float(G*m1*m2/d_2)
            F[ind_r][ind_c]=F_*d[ind_r][ind_c]
    F_total = np.sum(F, axis=1)
    # Note: Between two particles, the attractive forces will be the same, but not their accelerations.
    # Remember that F = M * A -> m1 * a1 = m2 * a2, so if m1 > m2 -> a2 > a1 -> Particles with greater mass have lower acceleration.Ac=acc(F_total, m)
    Ac=acc(F_total, m)
    Ac = np.nan_to_num(Ac, nan=0.0)
    # Finally, Xf = xi + vi * t + 0.5 * acc * (t^2) (Final Position), but if the particles always start at rest (vi=0) -> xf = 0.5 * acc * (t^2).
    x__ = 0.5*Ac*(t**2)
    new_pos=x_ + x__
    
    if keep_best==True:
        best_ind = np.argmin(m)
        Ac[best_ind]=0.0
        new_pos=x_ + 0.5*Ac*(t**2)
    
    # If more than half of the particles have collided, those that have collided will move randomly within the reduced search space.
    max_crash_part=Npar/2
    if len(colisioned_part_)>max_crash_part:
        lo = np.min(new_pos, axis=0)
        up = np.max(new_pos, axis=0)
        for i in colisioned_part_:
            new_pos[i] = np.random.uniform(low=lo, high=up, size=(1, Nvar))

    return F_total, Ac, new_pos
```''')    

with st.expander('F_coulomb.py'):
    st.markdown('''
```python
import numpy as np

def normaliazed_direction(ori, des):
    dir_ = des-ori
    nor_dir_ = dir_/np.sqrt(np.sum(dir_**2))
    nor_dir_=np.nan_to_num(nor_dir_)
    return nor_dir_

def distance(ori, des):
    dis_ = des-ori
    return dis_

def acc(F, m):
    Npar=F.shape[0]
    Nvar=F.shape[1]
    # Acceleration Matrix
    Ac = np.full((Npar, Nvar), 0.0)
    for ind_r, row in enumerate(Ac):
        for ind_c, col in enumerate(row):
            Ac[ind_r][ind_c]=F[ind_r][ind_c]/m[ind_r]
    return Ac

def F_coulomb(x, v, q, P, minimize=True, k=0.0001, weight_method='Linear', t=1.0, max_q=100.0): 
    """ The procedure that generates the new positions of the particles is based on how particles with positive and negative charges move
        in electric fields. Thus, the procedure will be as follows:
        
        1. n particles are created at random positions within the search space.
        2. Each particle is assigned a positive charge type.
        3. The magnitude of each particle's charge is directly related to the objective function.
        3.1 Assignment Methods -> Linear, Exponential, Quadratic (better assignment methods can be explored)
        3.2 Simply put, a solution range is established and adjusted to a charge range between 0 to max_q according to some assignment method.
        4. Each particle holds a velocity. These start at rest but will change over the iterations of the algorithm.
        5. The P particles with the best values obtained from the iteration will remain at rest and emit an electric field of opposite sign (negative) attracting the rest.
        5.1 Let E = k*Q/r^2 be the magnetic field at a point located at a distance r from the source.
        5.2 Let Fe be the electric force between the magnetic field and the particle -> Fe = E*q0 where q0 is the particle's charge.
        5.3 Let Fij be the force produced between particle i and j -> Fij = k*qi*qj/(r^2) where r is the distance between the particles, qi and qj are the charges of i and j.
        5.4 Thus, the resultant forces of particle i are FRi = sum_{p=1}^P k*Qp*Qi/(rip^2) + sum_{j=P+1}^n k*Qi*Qj/(rij^2) 
        5.5 Moreover, by Newton's Law, F=m*a -> Fe=m*a. Thus, the velocities of each particle are calculated vf=vi+a*t -> vf = vi + (FRi/m)*t
        5.6 The positions are updated as follows x = vi*t + (a*t^2)/2 -> x = vi*t + (FRi/m)*(t^2)/2
        
        Finally, if the particles are too close, it could cause a problem. If rij^2 << 0, then the electric force would be too strong, leading
        the particles to abruptly separate from each other. To avoid this behavior, a small distance (0.00000001) is established. If the distance
        between two particles is smaller than that distance, it will be considered that both particles have collided. Then, if more than half of 
        the particles have collided, we will apply a random function to generate new solutions over a reduced search space.
    
    Args:
        x (array(size=(Npar, Nvar)): current particle positions
        v (array(size=(Npar, Nvar)): current particle velocity
        q (array(size=(Npar, 1))): current electric charge of each particle
        P (int): quantity of electric fields (the best P particles become electric fields)
        minimize (bool, optional): solver objective. Defaults to True.
        k (float, optional): electric constant. Defaults to 0.0001.
        weight_method (str, optional): method to reassign electric charges. Defaults to 'Linear'. Options=['Linear', 'Quadratic', 'Exponential'].
        t (float, optional): time. Defaults to 1.0.
        max_q (float, optional): upper bound of electric charge to assing. Defaults to 100.0.

    Returns:
        F_total, Ac, vf, new_pos: returns the force obtained on each particle, their acceleration, their velocities
                                  and their new positions
    """

    Npar=x.shape[0] 
    Nvar=x.shape[1]

    # Distance Matrix
    dis = []
    for ind_r, row in enumerate(x):
        for ind_c, col in enumerate(x):
            dis.append(distance(x[ind_r], x[ind_c]))
    dis=np.array(dis).reshape((Npar,Npar,Nvar))

    # Direction Matrix
    d = []
    for ind_r, row in enumerate(x):
        for ind_c, col in enumerate(x):
            d.append(normaliazed_direction(x[ind_r], x[ind_c]))
    d=np.array(d).reshape((Npar,Npar,Nvar))
    
    colisioned_part = []
    r_2 = np.zeros((Npar, Npar))
    for ind_r, row in enumerate(dis):
        for ind_c, col in enumerate(dis):
            value = dis[ind_r][ind_c]
            value_2 = value**2
            value_sum = np.sum(value_2)
            if value_sum < 0.00000001: # Particles have practically collided. Notice later that fe=0.0 ahead.
                r_2[ind_r][ind_c] = 0.0
                if ind_r != ind_c:
                    colisioned_part.append(ind_c)
            else:
                r_2[ind_r][ind_c] = value_sum
    colisioned_part_ = np.unique(np.array(colisioned_part))


    # Each particle is assigned an electric charge magnitude based on the solution provided by the particle.
    q=np.array(q)
    min_value = q[0]
    max_value = q[-1]
    if minimize:
        q = -1.0*(q-max_value-1.0)
        max_value = q[0]

    if weight_method=="Linear":
        # We adjust the charges according to the following range [0, max_q].
        q = (q/max_value)*max_q
        reverse_ind = [len(q)-i-1 for i in range(len(q))] # It is inverted to give more charge to the particles that are further away.
        q = q[reverse_ind]
        
    elif weight_method=="Quadratic":
        # We adjust the charges according to the following range [0, max_q].
        q_2=q**2
        q=(q_2/np.max(q_2))*max_q
        reverse_ind = [len(q)-i-1 for i in range(len(q))] # It is inverted to give more charge to the particles that are further away.
        q = q[reverse_ind]
        
    elif weight_method=="Exponential":
        # We adjust the charges according to the following range [0, max_q].
        q_exp=np.array([np.exp(i) for i in q])
        q=(q_exp/np.max(q_exp))*max_q
        reverse_ind = [len(q)-i-1 for i in range(len(q))] # It is inverted to give more charge to the particles that are further away.
        q = q[reverse_ind]
        
    Npar=d.shape[0]
    Nvar=d.shape[2]
    F=np.full((Npar, Npar, Nvar), 0.0)
    for ind_r, row in enumerate(dis):
        for ind_c, col in enumerate(row):
            # The magnitude of the electric force Fe is calculated.            
            d_2=r_2[ind_r][ind_c]
            if d_2==0:
                Fe=0.0
            else:
                q1=q[ind_r]
                q2=q[ind_c]
                Fe=float(k*q1*q2/d_2)
                if ind_r >= P and ind_c >= P: # Repulsive forces are generated between particles of the same sign.
                    F[ind_r][ind_c]=-1.0*Fe*d[ind_r][ind_c]
                else: # There is attraction between particles and electric fields.
                    F[ind_r][ind_c]=Fe*d[ind_r][ind_c]
    F[:P, :P] = 0.0
    F_total = np.sum(F, axis=1)
    F_total[:P]=0.0
    # Remember that F=ma -> m1*a1 = m2*a2. So, if m1>m2 -> a2>a1 -> Particles with greater mass have less acceleration.
    # For this method, the weight of the particle is not important, so we will set them all to be equal to 1.0.
    m=np.ones(Npar)
    # vf = acc + vi*t
    Ac=acc(F_total, m)
    vf = Ac + t*v
    Ac[:P]=0.0
    vf[:P]=0.0 # The velocity of the magnetic fields is set to 0.0.
    # Finally, Xf = xi + vi*t + 0.5*acc*(t^2) (Final Position)
    x__=v*t + 0.5*Ac*(t**2)
    new_pos = x + x__
    
    # If more than half of the particles have collided, those that have collided will move randomly within the reduced search space.
    max_crash_part=Npar/2
    if len(colisioned_part_)>max_crash_part:
        lo = np.min(new_pos, axis=0)
        up = np.max(new_pos, axis=0)
        for i in colisioned_part_:
            new_pos[i] = np.random.uniform(low=lo, high=up, size=(1, Nvar))

    return F_total, Ac, vf, new_pos
```                
                ''')  
    
with st.expander("Custom_pso.py"):
    st.markdown('''
```python

import math
import numpy as np
import pandas as pd
from F_newton import F_newton
from F_coulomb import F_coulomb
import plotly.graph_objects as go
import plotly.express as px


def Random_(problem, x_, auto_reduce_search_space=False):
    """ This solver generates a random solution for each particle. Additionally, it is also possible to 
        apply an exploitation method where the search space is reduced on each iteration.

    Args:
        problem (dic): Dictionary that include: objective function, lower bound and upper bound of each variable and optimal solution
        x_ (array(size=())): Current position of each particle
        auto_reduce_search_space (bool, optional): If True, it update the lower and upper bounds in a way to reduce the search space. Defaults to False.

    Returns:
        Stemp, S_f: New positions for each particle and their performance after being evaluated with the objective function.
    """
    
    
    nPart = x_.shape[0]
    nVar = x_.shape[1]
    
    if auto_reduce_search_space:
        Lo = np.min(x_, axis=0)
        Up = np.max(x_, axis=0)
    else:
        Lo = np.zeros(nVar)
        Up = np.ones(nVar)

    new_x = np.random.uniform(low=Lo, high=Up, size=(nPart, nVar))
    
    Stemp = np.zeros((nPart,nVar))
    for k in range(nPart):
        for i in range(nVar):
            Stemp[k][i] = new_x[k][i]
            if Stemp[k][i] > Up[i]:
                Stemp[k][i] = Up[i]
            elif Stemp[k][i] < Lo[i]:
                Stemp[k][i] = Lo[i]
    f,S_r,maximize = mp_evaluator(problem, Stemp)

    S_f = np.zeros((nPart,1))
    
    for i in range(len(S_r)):
        S_f[i] = f[i]
    return Stemp, S_f
    
def F_newton_(problem, x_, m, Lo, Up, G=0.00001, keep_best=True, weight_method='Linear', t=1.0, max_mass=100.0):
    _, _, new_x = F_newton(x_, m, minimize=True, G=G, keep_best=keep_best, weight_method=weight_method, t=t, max_mass=max_mass)
    nPart=x_.shape[0]
    nVar=x_.shape[1]
    Stemp = np.zeros((nPart,nVar))
    for k in range(nPart):
        for i in range(nVar):
            Stemp[k][i] = new_x[k][i]
            if Stemp[k][i] > Up[i]:
                Stemp[k][i] = Up[i]
            elif Stemp[k][i] < Lo[i]:
                Stemp[k][i] = Lo[i]
    f,S_r,maximize = mp_evaluator(problem, Stemp)

    S_f = np.zeros((nPart,1))
    
    for i in range(len(S_r)):
        S_f[i] = f[i]
    return Stemp, S_f
    
def F_coulomb_(problem, x_, v, q, P, Lo, Up, k=0.00001, weight_method='Linear', t=1.0, max_q=100.0):
    _, _, v, new_x = F_coulomb(x_, v, q, P=P, minimize=True, k=k, weight_method=weight_method, t=t, max_q=max_q)
    nPart=x_.shape[0]
    nVar=x_.shape[1]
    Stemp = np.zeros((nPart,nVar))
    for k in range(nPart):
        for i in range(nVar):
            Stemp[k][i] = new_x[k][i]
            if Stemp[k][i] > Up[i]:
                Stemp[k][i] = Up[i]
            elif Stemp[k][i] < Lo[i]:
                Stemp[k][i] = Lo[i]
    f,S_r,maximize = mp_evaluator(problem, Stemp)

    S_f = np.zeros((nPart,1))
    
    for i in range(len(S_r)):
        S_f[i] = f[i]
    return Stemp, v, S_f

def evaluator(problem, x):
    # Dado que se trabaja bajo el dominio [0, 1] para cada variable, se debe crear una funcion que regrese a los valores a los dominios originales
    # Ejemplo (ndim=2): si se tiene el dominio original [-5, 5] y [-2, 2] para la variables x1, x2 y se cambio a [0, 1] y [0, 1] se vuelve al original tras:
    # y1=ax+b -> -5 = a*0+b -> b=-5
    # y1=ax+b -> 5 = a*1+-5 -> a=10
    # y1=10*x+-5
    # y2=ax+b -> -2 = a*0+b -> b=-2
    # y2=ax+b -> 2 = a*1+-2 -> a=4
    # y2=4*x+-2
    # Luego se aplica y1(x1) e y2(x2) respectivamente. Extendible a n dimensiones.
    # Dado que [0, 1] no cambia, se generaliza la formula b=lb y a=ub-lb -> y_{i} = (ub-lb)_{i}*x + lb_{i}
    lb = [var[0] for var in problem['bounds']]
    ub = [var[1] for var in problem['bounds']]
    x = [(ub[ind]-lb[ind])*i+lb[ind] for ind, i in enumerate(x)]
    # calculate fitness
    f = problem['f'](x)
    fitness = dict(Obj=f)
    return fitness

def mp_evaluator(problem, x):
    results = [evaluator(problem, c) for c in x]
    f = [r['Obj'] for r in results]
    # maximization or minimization problem
    maximize = False
    return (f, [r for r in results],maximize)

def correct_x(problem, x_):
    lb = [var[0] for var in problem['bounds']]
    ub = [var[1] for var in problem['bounds']]
    x = np.empty(x_.shape)
    for ind, row in enumerate(x_):
        corr_row = np.array([(ub[ind]-lb[ind])*i+lb[ind] for ind, i in enumerate(row)])
        x[ind]=corr_row
    return x



def custom_pso(problem, nPart, nVar, maxiter, G=0.00001, k=0.0001, keep_best=True, weight_method='Linear', t=1.0, seed=0, max_mass=100.0, solver='Newton', P=3, max_q=100.0, auto_reduce_search_space=False, dinamic=False):
    """The procedure of this algorithm is as follows:
    1. Generate a file of size nSize=nPart.
    2. Generate nPart initial solutions. Each solution contains nVar variables.
    3. Evaluate the nPart solutions and add them to the file ordered from best to worst solution.
    4. While the termination condition is not met (iterations > maxiter):
        4.1 Generate new solutions using some solver. Options = ['Random', 'Newton', 'Coulomb']
        4.2 Add new solutions to the file.
        4.3 Remove duplicate solutions.
        4.4 Evaluate solutions and sort from best to worst solution.
        4.5 Keep in the file the nPar best solutions.
        4.6 Save iteration results in a history (dataframe).
        4.7 Evaluate termination condition. If negative, return to step 4.1.
    
    Args:
        problem (dic): Dictionary that include: objective function, lower bound and upper bound of each variable and optimal solution
        nPart (_type_): Quantity of particles
        nVar (_type_): Quantity of variables
        maxiter (_type_): Maximum number of iterations.
        seed (int, optional): set the generation of random numbers. Defaults to 0.
        solver (str, optional): solver to apply. Defaults to 'Newton'. Options=['Random', 'Newton', 'Coulomb'].
        
        Random Solver:
            auto_reduce_search_space (bool, optional): If True, it update the lower and upper bounds in a way to reduce the search space. Defaults to False.

        Newton Solver:
            G (float, optional): Gravitational constant. Defaults to 0.00001.
            keep_best (bool, optional): It will keep the best value obtained in each iteration. Defaults to True.
            weight_method (str, optional): method to reassign particle mass. Defaults to 'Linear'. Options=['Linear', 'Quadratic', 'Exponential'].
            t (float, optional): time. Defaults to 1.0.
            max_mass (float, optional): upper bound of mass to assing. Defaults to 100.0.
            dinamic (bool, optional): It will change the max_mass value depending on the current iteration and difference between best and worst value obteined. Defaults to False.
            
        Coulomb Solver:
            P (int): quantity of electric fields (the best P particles become electric fields)
            max_q (float, optional): upper bound of electric charge to assing. Defaults to 100.0.
            weight_method (str, optional): method to reassign electric charges. Defaults to 'Linear'. Options=['Linear', 'Quadratic', 'Exponential'].
            k (float, optional): electric constant. Defaults to 0.0001.
            t (float, optional): time. Defaults to 1.0.
            dinamic (bool, optional): It will change the max_q value depending on the current iteration and difference between best and worst value obteined. Defaults to False.
            
        
    Returns:
        df, best_var, best_sol: dataframe contening data from all iterations, the best variables and the best value obtained
    """
    
    # number of variables
    parameters_v = [f'x{i+1}' for i in range(nVar)]
    
    # number of variables
    nVar = len(parameters_v)

    # size of solution archive
    nSize = nPart

    # number of Particules
    nPart = nPart

    # maximum iterations
    maxiter = maxiter

    # bounds of variables
    Up = [1]*nVar
    Lo = [0]*nVar
    
    # dinamic q
    din_max_q=max_q
    
    # dinamic mass
    din_max_mass = max_mass

    # initilize matrices
    S = np.zeros((nSize,nVar))
    S_f = np.zeros((nSize,1))

    # initial velocity
    v = np.zeros((nSize,nVar))

    # history
    columns_ = ['iter']
    for i in parameters_v: columns_.append(i)
    columns_.append('f')
    df = pd.DataFrame(columns=columns_)
    
    # generate first random solution
    #np.random.seed(seed)
    Srand = np.random.uniform(low=0,high=1,size=(nPart, nVar))
    f,S_r,maximize = mp_evaluator(problem, Srand)


    for i in range(len(S_r)):
        S_f[i] = f[i]
        
    # add responses and "fitness" column to solution
    S = np.hstack((Srand, v, S_f))
    # sort according to fitness (last column)
    S = sorted(S, key=lambda row: row[-1],reverse = maximize)
    S = np.array(S)

    # save each iteration
    iter_n = np.full((nPart, 1), 0.0)
    x_ = S[:, 0:nVar]
    x = correct_x(problem, x_)
    res = np.reshape(S[:, -1], (nPart, 1))
    rows=np.hstack((iter_n, x, res))
    df_new = pd.DataFrame(rows, columns=columns_)
    df = pd.concat([df, df_new])

    iterations=1
    
    # iterations
    while True:
        # get a new solution
        if solver == "Random":
            Stemp, S_f = Random_(problem, S[:, :nVar], auto_reduce_search_space=auto_reduce_search_space)
        
        elif solver=="Newton":
            din_mass=0
            if dinamic: 
                din_mass = ((maxiter-iterations)/(maxiter))*(np.max(S_f)-np.min(S_f))
            else:
                din_mass=max_mass
            
            m = np.reshape(S[:, -1], (nPart, 1))
            Stemp, S_f = F_newton_(problem, S[:, :nVar], m, Lo, Up, G=G, keep_best=keep_best, weight_method=weight_method, t=t, max_mass=din_mass)

        elif solver == "Coulomb":
            din_q=0
            if dinamic:
                din_q = ((maxiter-iterations)/(maxiter))*(np.max(S_f)-np.min(S_f))
            else:
                din_q=max_q
            q = np.reshape(S[:, -1], (nPart, 1))
            Stemp, v, S_f = F_coulomb_(problem, S[:, :nVar], v, q, P, Lo, Up, k=k, weight_method=weight_method, t=t, max_q=din_q)
        
        # add responses and "fitness" column to solution
        Ssample = np.hstack((Stemp, v, S_f))

        # add new solutions in the solutions table
        Solution_temp = np.vstack((S,Ssample))

        # delate duplicated rows
        Solution_temp = np.unique(Solution_temp, axis=0)

        # sort according to "fitness"
        Solution_temp = sorted(Solution_temp, key=lambda row: row[-1],reverse = maximize)
        Solution_temp = np.array(Solution_temp)

        # keep best solutions
        S = Solution_temp[:nSize][:]

        # save each iteration
        iter_n = np.full((nPart, 1), iterations)
        x_ = S[:, 0:nVar]
        x = correct_x(problem, x_)
        res = np.reshape(S[:, -1], (nPart, 1))
        rows=np.hstack((iter_n, x, res))
        df_new = pd.DataFrame(rows, columns=columns_)
        df = pd.concat([df, df_new])

        iterations += 1
        if iterations > maxiter:
            break

    best_sol = np.min(df['f'])
    ind_best_sol = np.argmin(df['f'])
    best_var = df.iloc[ind_best_sol, 1:len(parameters_v)+1]
    return df, best_var, best_sol

# Test Functions.
# Adapted from "https://www.sfu.ca/~ssurjano/optimization.html"

def Ackley(x, a=20.0, b=0.2, c=2.0*np.pi):
    d = len(x)
    sum1 = np.sum(np.square(x))
    sum2 = np.sum(np.array([np.cos(c*i) for i in x]))
    term1 = -a * np.exp(-b * np.sqrt(sum1 / d))
    term2 = -np.exp(sum2 / d)
    return term1 + term2 + a + np.exp(1)

def sixth_Bukin(x):
    return 100 * np.sqrt(np.abs(x[1] - 0.01*x[0]**2)) + 0.01*np.abs(x[0] + 10)

def Cross_in_Tray(x):
    return -0.0001 * math.pow(np.abs(np.sin(x[0]) * np.sin(x[1]) * np.exp(np.abs(100.0 - np.sqrt(x[0]**2 + x[1]**2)/np.pi)))+1.0, 0.1)

def Drop_Wave(x):
    return -1.0*(1.0 + np.cos(12.0 * np.sqrt(x[0]**2 + x[1]**2))) / (0.5 * (x[0]**2 + x[1]**2) + 2.0)

def Eggholder(x):
    return -(x[1] + 47.0) * np.sin(np.sqrt(np.abs(x[1] + x[0]/2 + 47.0))) - x[0] * np.sin(np.sqrt(np.abs(x[0] - (x[1] + 47.0))))

def Griewank(x):
    sum_part=0.0
    prod_part=1.0
    for i, xi in enumerate(x):
        sum_part += xi/4000.0
        prod_part *= np.cos(xi/np.sqrt(i+1))
    return sum_part - prod_part + 1.0

def Holder_Table(x):
    return -np.abs(np.sin(x[0])*np.cos(x[1])*np.exp(np.abs(1.0-(np.sqrt(x[0]**2 + x[1]**2)/np.pi))))

def Levy(x):
    # d dimensions
    w1 = 1.0 + (x[0]-1.0)/4.0
    wd = 1.0 + (x[-1]-1.0)/4.0
    sum_part = 0.0
    for i, xi in enumerate(x):
        wi = 1.0 + (xi-1.0)/4.0
        sum_part += ((wi-1.0)**2)*(1.0 + 10.0*math.pow(np.sin(np.pi*wi+1.0), 2))
    return math.pow(np.sin(np.pi*w1), 2) + sum_part + ((wd-1.0)**2)*(1.0 + math.pow(np.sin(2*np.pi*wd), 2))

def Rastrigin(x):
    # d dimensions
    d = len(x)
    sum_part = 0.0
    for i, xi in enumerate(x):
        sum_part += (xi**2) - 10.0*np.cos(2*np.pi*xi)
    return 10*d + sum_part

def second_Schaffe(x):
    return 0.5 + (math.pow(np.sin(x[0]**2 + x[1]**2), 2)-0.5)/(1.0 + 0.001*(x[0]**2 + x[1]**2))**2

def fourth_Schaffer(x):
    return 0.5 + (math.pow(np.cos(np.abs(x[0]**2 - x[1]**2)), 2)-0.5)/(1.0 + 0.001*(x[0]**2 + x[1]**2))**2

def Schwefel(x):
    # d dimensions
    d = len(x)
    sum_part = 0.0
    for xi in x:
        sum_part += xi*np.sin(np.sqrt(np.abs(xi)))
    return 418.9829*d - sum_part

def Shubert(x):
    sum_1 = 0.0
    sum_2 = 0.0
    for i in np.arange(5):
        i = float(i + 1)
        sum_1 += i*np.cos((i+1)*x[0] + i)
        sum_2 += i*np.cos((i+1)*x[1] + i)
    return sum_1*sum_2

def Styblinski_Tang(x):
    f = (sum([math.pow(i,4)-16*math.pow(i,2)+5*i for i in x])/2)
    return f

def Easom(x):
    f = np.cos(x[0])*np.cos(x[1])*np.exp(-(math.pow(x[0]-np.pi, 2) + math.pow(x[1]-np.pi, 2)))
    return f

def Bohachevsky(x):
    f = x[0]**2 + 2*x[1]**2 -0.3*np.cos(3*np.pi*x[0]) - 0.4*np.cos(4*np.pi*x[1]) + 0.7
    return f

def Perm_d_beta(x, d=2, beta=4):
    f = 0.0
    for i in range(d):
        for j in range(d):
            f += ((j+1) + beta)*(x[j]**(i+1) - (1/(j+1)**(i+1)))**2
    return f
    
def Rotated_Hyper_Ellipsoid(x, d=2):
    f = 0.0
    for i in range(d):
        for j in range(i+1):
            f += x[j]**2
    return f
            
def Sum_of_Different_Powers(x, d=2):
    f = 0.0
    for i in range(d):
        f += np.abs(x[i])**i+1+1
    return f
        
def SUM_SQUARES(x, d=2):    
    f = 0.0
    for i in range(d):
        f += (i+1)*x[i]**2
    return f

def TRID(x, d=2):
    sum_1 = 0.0
    sum_2 = 0.0
    for i in range(d):
        sum_1 += (x[i] - 1)**2
    for i in range(d-1):
        sum_2 += x[i+1]*x[i]   
    f = sum_1 + sum_2
    return f 

def BOOTH(x):
    f = (x[0] + 2*x[1] -7)**2 + (2*x[0] + x[1] - 5)**2
    return f

def Matyas(x):
    f = 0.26*(x[0]**2 + x[1]**2) - 0.48*x[0]*x[1]
    return f

def MCCORMICK(x):
    f = np.sin(x[0] + x[1]) + (x[0] - x[1])**2 - 1.5*x[0] + 2.5*x[1] + 1
    return f

def Power_Sum(x, d=2, b=[8, 18, 44, 114]):
    f = 0.0
    for i in range(d):
        sum_1 = 0.0
        for j in range(d):
            sum_1 += x[j]**(i+1)
        f += (sum_1 - b[i])**2
    return f
            
def Zakharov(x, d=2):
    f = 0.0
    sum_1 = 0.0
    sum_2 = 0.0
    sum_3 = 0.0
    for i in range(d):
        sum_1 += x[i]**2
        sum_2 += 0.5*(i+1)*x[i]
        sum_3 += 0.5*(i+1)*x[i]
    f = sum_1 + sum_2**2 + sum_3**4
    return f

def THREE_HUMP_CAMEL(x):
    f = 2*x[0]**2 - 1.05*x[0]**4 + (x[0]**6/6) + x[0]*x[1] + x[1]**2
    return f

def SIX_HUMP_CAMEL(x):
    f = (4 - 2.1*x[0] + (x[0]**4)/3)*x[0]**2 + x[0]*x[1] + (-4 + 4*x[1]**2)*x[1]**2
    return f

def DIXON_PRICE(x, d=2):
    sum_1 = 0.0
    for i in range(d-1):
        i = i + 1
        sum_1 += (i+1)*(2*x[i]**2 - x[i-1])**2
    f = (x[0] - 1)**2 + sum_1
    return f 
    
def ROSENBROCK(x, d=2):
    f = 0.0 
    for i in range(d-1):
        f += 100*(x[i+1] - x[i]**2)**2 + (x[i] - 1)**2
    return f    

def DE_JONG(x):
    a = [[-32, -16, 0, 16, 32, -32, -16, 0, 16, 32, -32, -16, 0, 16, 32, -32, -16, 0, 16, 32, -32, -16, 0, 16, 32], 
         [-32, -32, -32, -32, -32, -16, -16, -16, -16, -16, 0, 0, 0, 0, 0, 16, 16, 16, 16, 16, 32, 32, 32, 32, 32]]
    sum_1 = 0.0
    for i in range(25):
        sum_1 += 1/((i+1) + (x[0] - a[0][i])**6 + (x[1] - a[1][i])**6)
    f = (0.002 + sum_1)**(-1)
    return f

def MICHALEWICZ(x, d=2, m=10):
    f = 0.0
    for i in range(d):
        f += np.sin(x[i])*np.sin(((i+1)*x[i]**2)/np.pi)**(2*m) 
    f = -f
    return f
  
def BEALE(x):
    f = (1.5 - x[0] + x[0]*x[1])**2 + (2.25 - x[0] + x[0]*x[1]**2)**2 + (2.625 - x[0] + x[0]*x[1]**3)**2
    return f
    
def BRANIN(x):
    a=1
    b=5.1/(4*(np.pi)**2)
    c = 5/np.pi
    r = 6
    s = 10
    t = 1/(8*np.pi)
    f = a*(x[1] - b*x[0]**2 + c*x[0] - r)**2 + s*(1 - t)*np.cos(x[0]) + s
    return f
    
def GOLDSTEIN_PRICE(x):
    f = (1 + ((x[0] + x[1] + 1)**2)*(19 - 14*x[0] + 3*x[0]**2 - 14*x[1] + 6*x[0]*x[1] + 3*x[1]**2))*(30 + ((2*x[0] - 3*x[1])**2)*(18 - 32*x[0] + 12*x[0]**2 + 48*x[1] - 36*x[0]*x[1] + 27*x[1]**2))    
    return f

def PERM_D_BETA(x, d=2, beta=1):
    f = 0.0
    for i in range(d):
        sum_1 = 0
        for j in range(d):
            sum_1 += ((j+1)**(i+1) + beta)*((x[j]/(j+1))**(i+1) - 1)
        f += sum_1
    return f

class test_functions():
    def __init__(self) -> None:
        self.Ackley_ = {'name':'Ackley', 'f':Ackley, 'bounds':[[-32.768, 32.768], [-32.768, 32.768]], 'opt':[[0.0, 0.0], 0.0]}
        self.sixth_Bukin_ = {'name':'sixth_Bukin', 'f':sixth_Bukin, 'bounds':[[-15.0, -5.0], [-3.0, 3.0]], 'opt':[[-10.0, 1.0], 0.0]}
        self.Cross_in_Tray_ = {'name':'Cross_in_Tray', 'f':Cross_in_Tray, 'bounds':[[-10.0, 10.0], [-10.0, 10.0]], 'opt':[[[1.3491, -1.3491], [1.3491, 1.3491], [-1.3491, 1.3491], [-1.3491, -1.3491]], -2.06261]}
        self.Drop_Wave_ = {'name':'Drop_Wave', 'f':Drop_Wave, 'bounds':[[-5.12, 5.12], [-5.12, 5.12]], 'opt':[[0, 0], -1.0]}
        self.Eggholder_ = {'name':'Eggholder', 'f':Eggholder, 'bounds':[[-512.0, 512.0], [-512.0, 512.0]], 'opt':[[512.404, 512.404], -959.6407]}
        self.Griewank_ = {'name':'Griewank', 'f':Griewank, 'bounds':[[-600.0, 600.0], [-600.0, 600.0]], 'opt':[[0.0, 0.0], 0.0]}
        self.Holder_Table_ = {'name':'Holder_Table', 'f':Holder_Table, 'bounds':[[-10.0, 10.0], [-10.0, 10.0]], 'opt':[[[8.05502, 9.66459], [8.05502, -9.66459], [-8.05502, 9.66459], [-8.05502, -9.66459]], -19.2085]}
        self.Levy_ = {'name':'Levy', 'f':Levy, 'bounds':[[-10.0, 10.0], [-10.0, 10.0]], 'opt':[[1.0, 1.0], 0.0]}
        self.Rastrigin_ = {'name':'Rastrigin', 'f':Rastrigin, 'bounds':[[-5.12, 5.12], [-5.12, 5.12]], 'opt':[[0.0, 0.0], 0.0]}
        self.second_Schaffe_ = {'name':'second_Schaffe', 'f':second_Schaffe, 'bounds':[[-100.0, 100.0], [-100.0, 100.0]], 'opt':[[0.0, 0.0], 0.0]}
        self.fourth_Schaffer_ = {'name':'fourth_Schaffer', 'f':fourth_Schaffer, 'bounds':[[-100.0, 100.0], [-100.0, 100.0]], 'opt':[[0.0, 0.0], 0.0]}
        self.Schwefel_ = {'name':'Schwefel', 'f':Schwefel, 'bounds':[[-500.0, 500.0], [-500.0, 500.0]], 'opt':[[420.9687, 420.9687], 0.0]}
        self.Shubert_ = {'name':'Shubert', 'f':Shubert, 'bounds':[[-10.0, 10.0], [-10.0, 10.0]], 'opt':[[0.0, 0.0], -186.7309]}
        self.Styblinski_Tang_ = {'name':'Styblinski_Tang', 'f':Styblinski_Tang, 'bounds':[[-5, 5], [-5, 5]]}
        self.Easom_ = {'name':'Easom', 'f':Easom, 'bounds':[[-3, 3], [-3, 3]]}
        self.Bohachevsky_ = {'name':'Bohachevsky', 'f':Bohachevsky, 'bounds':[[-100.0, 100.0], [-100.0, 100.0]], 'opt':[[0, 0], 0]}
        self.Perm_d_beta_ = {'name':'Perm_d_beta', 'f':Perm_d_beta, 'bounds':[[-2.0, 2.0], [-2.0, 2.0]], 'opt':[[1, 0.5], 0]}
        self.Rotated_Hyper_Ellipsoid_ = {'name':'Rotated_Hyper_Ellipsoid', 'f':Rotated_Hyper_Ellipsoid, 'bounds':[[-65.536, 65.536], [-65.536, 65.536]], 'opt':[[0.0, 0.0], 0]}
        self.Sum_of_Different_Powers_ = {'name':'Sum_of_Different_Powers', 'f':Sum_of_Different_Powers, 'bounds':[[-1, 1], [-1, 1]], 'opt':[[0.0, 0.0], 0]}
        self.SUM_SQUARES_ = {'name':'SUM_SQUARES', 'f':SUM_SQUARES, 'bounds':[[-10, 10], [-10, 10]], 'opt':[[0.0, 0.0], 0]}
        self.TRID_ = {'name':'TRID', 'f':TRID, 'bounds':[[-4, 4], [-4, 4]], 'opt':[[2, 2], -2]}
        self.BOOTH_ = {'name':'BOOTH', 'f':BOOTH, 'bounds':[[-10, 10], [-10, 10]], 'opt':[[1, 3], 0]}
        self.Matyas_ = {'name':'Matyas', 'f':Matyas, 'bounds':[[-10, 10], [-10, 10]], 'opt':[[0, 0], 0]}
        self.MCCORMICK_ = {'name':'MCCORMICK', 'f':MCCORMICK, 'bounds':[[-1.5, 4], [-3, 4]], 'opt':[[-0.54719, -1.54719], -1.9133]}
        self.Power_Sum_ = {'name':'Power_Sum', 'f':Power_Sum, 'bounds':[[0, 2], [0, 2]]}
        self.Zakharov_ = {'name':'Zakharov', 'f':Zakharov, 'bounds':[[-5, 10], [-5, 10]], 'opt':[[0.0, 0.0], 0.0]}
        self.THREE_HUMP_CAMEL_ = {'name':'THREE_HUMP_CAMEL', 'f':THREE_HUMP_CAMEL, 'bounds':[[-5, 5], [-5, 5]], 'opt':[[0.0, 0.0], 0.0]}
        self.SIX_HUMP_CAMEL_  = {'name':'SIX_HUMP_CAMEL', 'f':SIX_HUMP_CAMEL, 'bounds':[[-3, 3], [-2, 2]], 'opt':[[0.0898, -0.7126], -1.0316]}
        self.DIXON_PRICE_ = {'name':'DIXON_PRICE', 'f':DIXON_PRICE, 'bounds':[[-10, 10], [-10, 10]], 'opt':[[1, 1/np.sqrt(2)], 0]}
        self.ROSENBROCK_ = {'name':'ROSENBROCK', 'f':ROSENBROCK, 'bounds':[[-5, 10], [-5, 10]], 'opt':[[1, 1], 0]}
        self.DE_JONG_ = {'name':'DE_JONG', 'f':DE_JONG, 'bounds':[[-65.536, 65.536], [-65.536, 65.536]]}
        self.MICHALEWICZ_ = {'name':'MICHALEWICZ', 'f':MICHALEWICZ, 'bounds':[[0, np.pi], [0, np.pi]], 'opt':[[2.2, 1.57], -1.8013]}
        self.BEALE_ = {'name':'BEALE', 'f':BEALE, 'bounds':[[-4.5, 4.5], [-4.5, 4.5]], 'opt':[[3, 0.5], 0]}
        self.BRANIN_ = {'name':'BRANIN', 'f':BRANIN, 'bounds':[[-5, 10], [0, 15]], 'opt':[[-np.pi, 12.275], 0.397887]}
        self.GOLDSTEIN_PRICE_ = {'name':'GOLDSTEIN_PRICE', 'f':GOLDSTEIN_PRICE, 'bounds':[[-2, 2], [-2, 2]], 'opt':[[0, -1], 3]}
        self.PERM_D_BETA_ = {'name':'PERM_D_BETA', 'f':PERM_D_BETA, 'bounds':[[-2, 2], [-2, 2]], 'opt':[[1, 2], 0]}
        self.dictionary = {'Ackley': self.Ackley_, 
                           'sixth_Bukin':self.sixth_Bukin_, 
                           'Cross_in_Tray':self.Cross_in_Tray_, 
                           'Drop_Wave':self.Drop_Wave_, 
                           'Eggholder':self.Eggholder_, 
                            'Griewank':self.Griewank_, 
                            'Holder_Table':self.Holder_Table_, 
                            'Levy':self.Levy_, 
                            'Rastrigin':self.Rastrigin_, 
                            'second_Schaffe':self.second_Schaffe_, 
                            'fourth_Schaffer':self.fourth_Schaffer_, 
                            'Schwefel':self.Schwefel_, 
                            'Shubert':self.Shubert_, 
                            'Styblinski_Tang':self.Styblinski_Tang_, 
                            'Easom':self.Easom_, 
                            'Bohachevsky':self.Bohachevsky_, 
                            'Perm_d_beta':self.Perm_d_beta_, 
                            'Rotated_Hyper_Ellipsoid':self.Rotated_Hyper_Ellipsoid_, 
                            'Sum_of_Different_Powers': self.Sum_of_Different_Powers_, 
                            'SUM_SQUARES':self.SUM_SQUARES_, 
                            'TRID':self.TRID_, 
                            'BOOTH': self.BOOTH_, 
                            'Matyas':self.Matyas_, 
                            'MCCORMICK': self.MCCORMICK_, 
                            'Power_Sum':self.Power_Sum_, 
                            'Zakharov':self.Zakharov_, 
                            'THREE_HUMP_CAMEL' :self.THREE_HUMP_CAMEL_, 
                            'SIX_HUMP_CAMEL': self.SIX_HUMP_CAMEL_, 
                            'DIXON_PRICE': self.DIXON_PRICE_, 
                            'ROSENBROCK_': self.ROSENBROCK_, 
                            'DE_JONG':self.DE_JONG_, 
                            'MICHALEWICZ': self.MICHALEWICZ_, 
                            'BEALE':self.BEALE_, 
                            'BRANIN': self.BRANIN_, 
                            'GOLDSTEIN_PRICE':self.GOLDSTEIN_PRICE_, 
                            'PERM_D_BETA':self.PERM_D_BETA_} 
        self.whole_list = list(self.dictionary.keys())


def plotly_graph(problem, df=None):
    function=problem['f']
    x_lb=problem['bounds'][0][0]
    x_ub=problem['bounds'][0][1]
    y_lb=problem['bounds'][1][0]
    y_ub=problem['bounds'][1][1]
    
    x = np.linspace(x_lb, x_ub, 100)
    y = np.linspace(y_lb, y_ub, 100)
    z = np.empty((100, 100))
    for ind_y, j in enumerate(y):
        for ind_x, i in enumerate(x):
            z[ind_y][ind_x] = function(np.array([i, j]))
    
    steps_ = int(np.max(df['iter']))

    fig1 = go.Figure(data=[go.Surface(x=x, y=y, z=z)])
    for step in range(steps_):
        points = df[df['iter']==step]
        points_x = list(points['x1'])
        points_y = list(points['x2'])
        points_z = list(points['f'])
        fig1.add_scatter3d(x=np.array(points_x), y=np.array(points_y), z=np.array(points_z), mode='markers', visible=False, marker=dict(size=5, color="white", line=dict(width=1, color="black")))
        fig1.update_layout(title=f"f = {step}")
    
    # Create figure
    fig = go.Figure(data=[go.Scatter3d(x=[], y=[], z=[],
                                mode="markers",
                                marker=dict(size=5, color="white", line=dict(width=1, color="black"))
                                ), fig1.data[0]]
                    )
        
    # Frames
    frames = [go.Frame(data=[go.Scatter3d(x=k['x'],
                                        y=k['y'],
                                        z=k['z']
                                        ), fig1.data[0]
                            ],
                    traces= [0],
                    name=f'frame{ind}'      
                    ) for ind, k  in  enumerate(fig1.data[1:])
            ]

    fig.update(frames=frames)

    def frame_args(duration):
        return {
                "frame": {"duration": duration},
                "mode": "immediate",
                "fromcurrent": True,
                "transition": {"duration": duration, "easing": "linear"},
                }


    sliders = [
        {"pad": {"b": 10, "t": 60},
        "len": 0.9,
        "x": 0.1,
        "y": 0,
        
        "steps": [
                    {"args": [[f.name], frame_args(0)],
                    "label": str(k),
                    "method": "animate",
                    } for k, f in enumerate(fig.frames)
                ]
        }
            ]

    fig.update_layout(

        updatemenus = [{"buttons":[
                        {
                            "args": [None, frame_args(150)],
                            "label": "Play", 
                            "method": "animate",
                        },
                        {
                            "args": [[None], frame_args(150)],
                            "label": "Pause", 
                            "method": "animate",
                    }],
                        
                    "direction": "left",
                    "pad": {"r": 10, "t": 70},
                    "type": "buttons",
                    "x": 0.1,
                    "y": 0,
                }
            ],
            sliders=sliders
        )

    fig.update_layout(sliders=sliders)
    fig.write_html('animation.html')
    return fig

        
#problem=test_functions().PERM_D_BETA_  
#df, best_var, best_sol = custom_pso(problem, 20, 2, maxiter=100, solver="Coulomb", k=0.00000000000000001, G=0.00000001, t=1.0, max_q=0.01, auto_reduce_search_space=True, dinamic=True)
#plotly_graph(problem, df)

#print(best_sol)

```                
                ''')      

st.markdown("### 4. Experimentación")

if "results" not in st.session_state:
    st.session_state.results = {'df':[], 'fig':[], 'best_solution':None, 'best_f':None}

c1, c2 = st.columns(2)    
options = test_functions().whole_list
selected = c1.selectbox("choose problem", options, index=1)
problem = test_functions().dictionary[selected]
solver_list = ['Random', 'Newton', 'Coulomb']
solver_selected = c2.selectbox("choose solver", options=solver_list, index=0)

st.markdown("Hyperparameters")
# hyperparameters
auto_constaint_choosen=False
G=0.0000000001
k=0.0000000001
t=1.0
options_as_mt=['Linear', 'Quadratic', 'Exponential']
assing_method='Linear'
if solver_selected == "Random":
    auto_constaint = st.selectbox("auto_constraint_domain", options=['False', 'True'], index=1)
    dic_auto_constaint = {'False':False, 'True':True}
    auto_constaint_choosen=dic_auto_constaint[auto_constaint]
    
elif solver_selected == "Newton":
    c1, c2, c3 = st.columns(3)
    G=c1.number_input("G", min_value=0.0, max_value=8.0, value=0.0000000001)
    assing_method = c2.selectbox("assing mehod", options=options_as_mt, index=0)
    t=c3.number_input("t", min_value=0.01, max_value=10.0, value=1.0)
    
elif solver_selected == "Coulomb":
    c1, c2, c3 = st.columns(3)
    k=c1.number_input("k", min_value=0.0, max_value=8.0, value=0.0000000001)
    assing_method = c2.selectbox("assing mehod", options=options_as_mt, index=0)
    t=c3.number_input("t", min_value=0.01, max_value=10.0, value=1.0)
    
solve_bt = st.button("Solve")
if solve_bt:
    df, best_solution, best_f = custom_pso(problem, nPart=20, nVar=2, maxiter=100, solver=solver_selected, auto_reduce_search_space=auto_constaint_choosen, G=G, t=t, keep_best=True, k=k, dinamic=True, weight_method=assing_method)
    fig = plotly_graph(problem, df)
    st.session_state.results['df'], st.session_state.results['best_solution'], st.session_state.results['best_f'], st.session_state.results['fig'] = df, best_solution, best_f, fig       
    
if len(st.session_state.results['df'])>0:
    results = st.session_state.results
    df, best_solution, best_f = results['df'], results['best_solution'], results['best_f']        
    with st.expander('Performance'):
        c1, c2 = st.columns([4, 1])
        c1.dataframe(df)
        c2.markdown('Best Solution:')
        df = pd.DataFrame(best_solution)
        df.columns = ['value']
        c2.dataframe(df)
        c2.markdown(f'Best Value: `{best_f}`')
    fig = results['fig']
    st.plotly_chart(fig)