El método de optimización por enjambre de partículas es un procedimiento herístico inspirado en el comportamiento de grupo en los animales observado en enjambres, rebaños, parvadas, cardúmenes, manadas, etc. Vea por ejemplo Parvada de pájaros.

Para no hablar de un grupo de animales en particular, se habla en general de un enjambre de partículas. Así, a este procedimiento se le conoce como Optimización por Enjambre de Partículas (Particle Swarm Optimization: PSO)

En la PSO se parte de generar de alguna manera un número de soluciones no óptimas. A cada una de estas soluciones se le considera como la posición de una partícula. Al conjunto de partículas se le considera un enjambre. La idea de la PSO es mover el enjambre para que sus partículas se vayan aproximando a una solución óptima. Mover el enjambre significa mover cada una de las partículas. Así cada partícula debe cambiar buscando que cada vez esté más cerca de la solución óptima.

¿Qué significa mover una partícula? Recuerde que la posición de una partícula es una solución no óptima. Suponga que una solución (no óptima) de un problema está definida por un conjunto de parámetros. Est conjunto de parámetros define la posición de una partícula. Mover una partícula es cambiar su posición, es decir, cambiar sus parámetros buscando que después del cambio, la partícula esté más cerca de la solución óptima. Una idea trivial es mover la partícula en la dirección del óptimo. Sin embargo, no se conoce el óptimo y por lo tanto tampoco en que dirección está.

Otra idea es mover una partícula en todas direcciones y encontrar aquella dirección en que la función de costo disminuya en mayor medida. Es probable que ésta sea la dirección del óptimo. Eso es lo que se llama el método de la fuerza bruta y no se usa porque generalmente requiere un costo computacional enorme, aún en el caso de que cada solución sólo necesite unos pocos parámetros.

La PSO mueve cada partícula en la dirección que resulta de combinar tres direcciones:

1. La dirección inercial. Suponga que la partícula se ha movido antes, entonces se puede calcular un vector velocidad que es la diferencia entre la posición actual y la última. La dirección inercial es la dirección del vector velocidad.
2. La dirección cognitiva. Suponga qué se lleva el registro de la mejor posición que ha tenido la partícula. La resta de la mejor posición que ha ocupado la partícula y la posición actual es un vector que apunta hacia la mejor posición que ha ocupado la partícula. La dirección cognitiva es la dirección de este vector.
3. La dirección social. Suponga que se lleva un registro de la mejor posición que ha ocupado el enjambre. La resta entre la mejor posición que ha ocupado el enjambre y la posición actual de la partícula es un vector que apunta hacia la mejor posición del enjambre. La dirección social es la dirección de este vector.

Si para la partícula \(i\) se define:

• \(x_{i}(k)\) La posición actual de la partícula.
• \(x_{i}(k-1)\) La posición previa de la partícula.
• \(x_{ib}(k)\) La mejor posición de la partícula hasta el momento.
• \(s_{b}(k)\) La mejor posición del enjambre hasta el momento.

entonces se puede calcular

• La dirección inercial: \(x_{i}(k)-x_{i}(k-1)\)
• La dirección cognitiva: \(x_{ib}(k)-x_{i}(k)\)
• La dirección social: \(s_{b}(k)-x_{i}(k)\)

Si escalamos estas direcciones por constantes, haciendo un símil con la física podemos hablar de velocidades, así tenemos

• La velocidad en la dirección inercial: \(v_{i_{inr}}(k)=w(x_{i}(k)-x_{i}(k-1))\)
• La velocidad en la dirección cognitiva: \(v_{i_{cgn}}(k)=k_{cog}(x_{ib}(k)-x_{i}(k))\)
• La velocidad en la dirección social: \(v_{i_{scl}}(k)=k_{scl}(s_{b}(k)-x_{i}(k))\)

donde \(w\), \(k_{cgn}\) y \(k_{scl}\) se conocen como constantes inercial, cognitiva y social respectivamente.

Se puede decir ahora que la partícula \(i\) se mueve a una velocidad

Así la posición de la partícula \(i\) en el instante \(k+1\) está dado por \(x_{i}(k+1)=x_{i}(k)+v_{i}(k)\). Poniendo esta expresión sólo en términos de posiciones resulta

Note que es conveniente expresar la siguiente posición en términos de posiciones anteriores (de la propia u otras partículas) ya que las posiciones son los parámetros de la soluciones (no óptimas) conocidas. Al mover una partícula estamos generando una nueva solución a partir de las soluciones conocidas.

Por alguna razón en la bibliografía en la expresión de la velocidad \ref{eq:vel} en lugar de \(v(k)\) se habla de \(v(k+1)\). Se considera aquí que no hay una justificación para ello.

En resumen la PSO podría describirse así (una mayor sangría significa subtarea). Dado un problema de optimización:

• Crear el enjambre
  • Crear cada partícula
• Si no se cumpla la condición de paro
  • Mover el enjambre
    • Mover cada partícula
  • Repetir

Para desarrollar un programa que implemente la PSO es conveniente pensar cuales son las palabras (ideas) principales del método. Podemos pensar en las siguientes expresiones:

• Enjambre
• Partícula
• Mover enjambre
• Mover partícula
• Mejor posición de la partícula
• Mejor posición del enjambre
• Generar posiciones iniciales

Note que en la descripción de la PSO se habló de un problema de optimización pero no se precisó cual es el problema. Esto es posible porque el método es bastante general. Para mantener esta generalidad en el programa es conveniente separar la implementación de la PSO de un problema particular. Para ello es necesario precisar que partes del procedimiento dependen del problema de optimización que se quiere resolver. La PSO necesita del 'problema' dos cosas

1. La creación de partículas. Crear el enjambre significa crear partículas. Crear partículas es crear su posición inicial. La posición inicial de una partícula son los parámetros de una solución (no óptima) del problema. Es el 'problema' el que debe saber crear estas soluciones.
2. Calcular el fitness. Se debe tener una medida de que tan buena es una partícula para resolver el problema. La medida más común es el valor de la función de costo que se desea minimizar (entre más pequeño mejor). A esta medida se le conoce aquí como el fitness. note que el fitness es un número real positivo. Para mover una partícula se necesita saber la mejor posición que la partícula ha tenido y la mejor posición que ha tenido el enjambre. Es decir se requiere saber si una posición es mejor que otra. Esta comparación se hace a través del fitness de cada posición, la que tenga menor fitness es mejor. El 'problema' debe saber como calcular el fitness asociado a una posición.

De las observaciones anteriores se puede expresar la SPO con las siguientes 'palabras'

• Problema
• Partícula
• Enjambre
• PSO

El 'Problema' debe poder crear posiciones no óptimas y calcular el fitnes de una posición.

Para que una partícula "se mueva", debe conocer además de su posición actual, su posición anterior y la mejor posición que ha ocupado hasta el momento. Note que la partícula debe conocer que es una 'mejor posición'. Esto se hace mediante el fitness. El cálculo del fitness le corresponde al 'problema'. Para no calcular el fitness de una posición varias veces es conveniente que a cada posición se le asocie su fitness. Llamaremos posfit a un par \((posición, fitness)\). Se tiene entonces que una partícula debe almacenar:

• El posfit actual
• El posfit previo
• El mejor posfit que ha tenido la partícula.

Para moverse, la partícula debe conocer también el mejor posfit del enjambre. El mejor posfit del enjambre es una propiedad del enjambre; así es el enjambre el que debe comunicar a cada particula cual ha sido su mejor posición. . En cada movimiento de la partícula se deben actualizar los tres posfit que componen la particula: el actual, el anterior, el mejor.

El enjambre contiene una lista de partículas y su mejor posfit hasta el momento. El enjambre debe poder moverse. Note que mover el enjambre significa mover cada una de sus partículas. En cada movimiento del enjambre debe actualizarse el mejor posfit del enjambre.

La PSO debe crear un enjambre y moverlo hasta que una condición de paro se cumpla. Crear un enjambre significa crear varias partículas. Crear partículas significa crear soluciones no óptimas.

Es conveniente guardar las constantes necesarias de la PSO en un sólo lugar. Esta información consiste en

• Número máximo de generaciones (movimientos del enjambre).
• Número de partículas del enjambre.
• Valor de la constante de inercia.
• Valor de la constante de cognitiva.
• Valor de la constante de social.

A continuación se presenta una implementación del método en el lenguaje de programación Racket.

Hay un conjunto de funciones que no tienen que ver con el método que están programadas en 'auxfnc.rkt'. El método tambien requiere realizar operaciones con vectores. Estas operaciones están programadas en 'vfnc.rkt'. Finalmente se requieren procedimientos que dependen el problema. Estos procedimientos son make-potential-sol y calc-fitness. Las funciones de estos archivos se incorporan al PSO con las siguientes líneas.

(require "../fnc/auxfnc.rkt")
(require "../fnc/vfnc.rkt")
(require "../simpso/pso-ctrl-problem.rkt")

Las constantes del método están encapsuladas en una lista. Para extraerlas se usan selectores (getters). Esto se hace en las siguientes líneas

#;; ===== pso-data constructor and selectors =====  
(define (make-pso-data max-generations num-particles k-inrt k-cgn k-scl)
  (list max-generations num-particles k-inrt  k-cgn k-scl))

(define (max-generations pso-data)
  (list-ref pso-data 0))

(define (num-particles pso-data)
  (list-ref pso-data 1))

(define (k-inrt pso-data)
  (list-ref pso-data 2))

(define (k-cgn pso-data)
  (list-ref pso-data 3))

(define (k-scl pso-data)
  (list-ref pso-data 4))

Finalmente, es conveniente tener un función para mostrar los datos del método

(define (pso-data-display pso-data)
  (let ([msgs (list "Máximo número de generaciones: "
                    "Número de particulas:          "
                    "Constante inercial:            " 
                    "Constante social:              " 
                    "Constante cognitiva:           ")])
    (dp2l msgs pso-data)))

Antes de crear las particulas es conveniente definir el dato posfit que es el par \((posición, fitness)\). El constructor y los selectores de posfit se muestra a continuación

;; ===== posfit constructor and selectors =====  
(define (make-posfit pos fit)
  (list pos fit))

(define (pos posfit)
  (list-ref posfit 0))

(define (fit posfit)
  (list-ref posfit 1))

Una particula almacena una tripleta de posfit: su posfit actual, su posfit previo y su mejor posfit hasta el momento.

;; ===== particle constructor and selectors =====  
(define (make-particle crrnt-posfit prev-posfit best-posfit)
  (list crrnt-posfit prev-posfit best-posfit))

(define (current-posfit particle)
  (list-ref particle 0))

(define (prev-posfit particle)
  (list-ref particle 1))

(define (best-posfit particle)
  (list-ref particle 2))

El procedimiento init-particle crea una partícula. Para ello, ejecuta los procedimientos:

• make-potential-sol que crea una solución no óptima del problema de optimización.
• calc-fitnes que recibe la posición de una partícula y devuelve su fitness

Estos dos procemientos dependen del problema y deben estar en un archivo aparte. Con el uso de estos procedimientos se crea una particula como se muestra a continuación. Note que al crear una particula, el posfit actual, el previo y el mejor son lo mismo.

(define (init-particle)
  (let* ([pos1 (make-potential-sol)]
        [fit1 (calc-fitness pos1)]
        [posfit1 (make-posfit pos1 fit1)])
    (make-particle posfit1 posfit1 posfit1)))

Para mover una particula es necesario conocer la mejor posición del enjambre hasta el momento y las constantes del método. Con ello se calculan las direcciones inercial, cognitiva y social y se multiplican por sus respectivas constantes. Con esto se calcula su nueva posición y a partir de la nueva posición se calcula el fitness. Con una nueva posición y un nuevo fitness se crea un nuevo posfit. Se examina si el nuevo posfit es mejor que el almacenado, si es así, entonces se actualiza el mejor posfit de la partícula. Esto es lo que se hace en las siguientes líneas

;; ===== move particle =====  
(define (move-particle particle swrm-bst-pos pso-data)
  (let ([ki (k-inrt pso-data)]
        [kc (k-cgn pso-data)]
        [ks (k-scl pso-data)]
        [crrnt-posfit (current-posfit particle)]
        [crrnt-pos (pos (current-posfit particle))]
        [prev-pos (pos (prev-posfit particle))]
        [best-pos (pos (best-posfit particle))]
        [best-fit (fit (best-posfit particle))])

    (define inrt-velocity (v* (v- crrnt-pos prev-pos) ki))
    (define cgn-velocity (v* (v- best-pos crrnt-pos) kc))
    (define scl-velocity (v* (v- swrm-bst-pos crrnt-pos) ks))
    (define velocity 
      (v+ inrt-velocity (v+ cgn-velocity scl-velocity )))

    (define new-pos (v+ crrnt-pos velocity))
    (define new-fit (calc-fitness new-pos))
    (define new-posfit (make-posfit new-pos new-fit))
    (define new-best-posfit
      (if (< new-fit best-fit) new-posfit crrnt-posfit ))

    (make-particle new-posfit crrnt-posfit  new-best-posfit)))

Es conveniente tener una función que muestre los datos de una partícula. En las siguientes líneas, se crea una lista de mensajes y una lista de variables. La función dp2l muestra cada mensaje con su correspondiente variable.

(define 
  (display-particle particle)
  (let ([lst-msg (list
                  "posfit actual:   "
                  "posfit anterior: "
                  "mejor posfit:    ")]
        [lst-var (list
                  (current-posfit particle)
                  (prev-posfit particle)
                  (best-posfit particle))])
    (nl)
    (dp2l lst-msg lst-var)))

En el dato swarm se ensamblan la lista de partículas y el mejor posfit del ejambre. A continuación el constructor y los selectores de este dato.

;; ===== swarm constructor and selectors =====  
(define (make-swarm particles swarm-best-posfit)
  (list particles swarm-best-posfit))

(define (particles swarm)
  (list-ref swarm 0))

(define (swarm-best-posfit swarm)
  (list-ref swarm 1))

Para crear un ejambre, se crea una lista de partículas y se encuentra cual es el mejor posfit de esas partículas. El número de particulas a crear se conoce por los datos generales del método. El mejor posfit se encuentra usando la función update-swarm-best-posfit.

(define (init-swarm pso-data)
  (let ([particles (map0 init-particle (num-particles pso-data))])
    (update-swarm-best-posfit
     (make-swarm particles (current-posfit (car particles))))))

Mover el ejambre equivale a mover cada partícula y después actualizar el mejor posfit del ejambre. Para mover una partícula se define el procedimiento auxiliar move-particle-crry que sólo requiere conocer la partícula en cuestión. Después este procedimiento se aplica a cada partícula de la lista. Para actualizar el mejor posfit del ejambre se usa el procedimiento update-swarm-best-posfit.

;; ===== move swarm =====  
(define (move-swarm swarm pso-data)
  (let([crrnt-bst-posfit (swarm-best-posfit swarm)]
       [swrm-bst-pos (pos (swarm-best-posfit swarm))])

    (define (move-particle-crry particle)
      (move-particle particle swrm-bst-pos pso-data))

    (define new-particles 
      (map move-particle-crry (particles swarm)))

    (update-swarm-best-posfit
     (make-swarm new-particles crrnt-bst-posfit))))

Después de crear el ejambre y despúes de cada movimiento se require actualizar el mejor posfit del ejambre. Esto se hace con la función update-swarm-best-posfit. Esta función utiliza la función auxiliar compare-posfit que que recibe una partícula y un posfit.

(define (compare-posfit particle bst-posfit)
  (let ([crrnt-posfit (current-posfit particle)]
        [fit-particle (fit (current-posfit particle))]
        [bst-fit (fit bst-posfit)])
    (if (< fit-particle bst-fit) crrnt-posfit bst-posfit)))

(define (update-swarm-best-posfit swarm)
  (let* ([crrnt-particles (particles swarm)]
        [crrnt-bst-posfit (swarm-best-posfit swarm)]
        [new-best-posfit
         (foldl compare-posfit crrnt-bst-posfit crrnt-particles)])
    (make-swarm crrnt-particles new-best-posfit)))

Es conveniente tener una función que muestre el ejambre; esto es que muestre cada partícula del ejambre y el mejor posfit del ejambre

(define (display-swarm swarm)
  (for-each display-particle (particles swarm))
  ( dp2 "mejor posfit de ejambre:" (swarm-best-posfit swarm)))

La función evolve-swarm recibe un ejambre y los datos de la PSO. Esta función mueve el ejambre durante el número de iteraciones especificado por los datos de la PSO.

(define (evolve-swarm swarm pso-data)
  (define (move-swarm-aux num swarm)
    (nl)
    (dp "Moving Swarm...: ")
    (display-swarm swarm)
    (move-swarm swarm pso-data))

  (foldl move-swarm-aux swarm (range (max-generations pso-data))))

Finalmente, la función pso recibe el dato pso-data con la especificación de las constantes del método, crea un ejambre inicial y despues lo mueve usando evolve-swarm.

(define (pso pso-data)
  (let ([iswrm (init-swarm pso-data)])
    (dp "Swarm inicial: ")
    (display-swarm iswrm)
  (evolve-swarm iswrm  pso-data))
)

;; export all defined function
(provide (all-defined-out))

El simulador no esta desarrollado para un usuario final sino como una herramienta de investigación. Para poder utilizarlo es necesario saber programar en Scheme/Racket pues la representación de un sistema se hace en este lenguaje de programación.

Para construir una representación de un sistema de control se especifican los bloques que lo forman. El simulador tiene una característica que hace que se puedan simular un gran numero de controladores sin intervención: separa la conexión de la especificación de los bloques. Esto se explica a continuación

Suponga que se quiere construir un esquema clásico de control como el que se muestra en la figura Esquema clásico de control

Entonces se puede describir la conexion así:

• conecta la fuente con la entrada positiva del restador
• conecta la salida del restador con el controlador
• conecta la salida del controlador con el sistema
• Conecta la salida del sistema con la entrada negativa del restador

Estas conexiones se pueden 'empaquetar' en un procedimiento, de tal manera que el procedimiento puede recibir la fuente, el controlador y el sistema y realizar la conexión. Más aún, si en una serie de simulaciones, la fuente y el sistema no cambian, se puede crear un procedimiento particular, que sólo reciba el controlador y realice la conexión de forma automática. No solo eso, también se puede crear un procedimiento que realice la conexión, haga la simulación y calcule la norma dos del error de un controlador determinado.

A continuación se presentan algunas funciones del simulador que son importantes para poder aplicar el PSO.

La figura 2 muestra como están conceptualizadas las conexiones entre bloques en el simulador. Las entradas y salidas de los bloques están numeradas. Estas entradas y salidas se conocen como puertos el primer puerto siempre es cero. Las conexiones siempre van de un puerto de salida de un bloque a un puerto de entrada de otro bloque. Para realizar una conexión se deben especificar ambos puertos. El siguiente código hipotético realizaría una conexión entre el puerto 1 de salida de bloque A y el puerto 0 de entrada del bloque B.

  (wire-up! (pto bloqueA 1) (pto bloqueB 0))

Cuando el puerto es el puerto cero de cualquier bloque, éste se puede omitir. Esto es útil porque muchos bloques sólo tienen un puerto de entrada o de salida. Así, el codigo anterior también pudo haberse escrito como

  (wire-up! (pto bloqueA 1) (pto bloqueB))

A continuación se describen los bloques que se usaron

El el simulador un sistema de control se representa mediante la interconexión de bloques. Estos bloques actualizan sus entradas y salidas en cada 'tic' de un reloj que los sincroniza. El simulador tiene implementado los siguientes bloques:

La simulación de los controladores clásicos muestra como se representan sistemas dinámicos en el simulador. También se ha mostrado que se pueden hacer procedimientos para hacer conexiones de forma automática. De la misma manera se pueden representar sistemas dinámicos generales y luego obtener representaciones particulares. Por ejemplo, para representar el sistema lineal de segundo orden expresado por

donde \(A\) es una matrix de \(2\times 2\), \(b\) es un vector de \(2\times 1\), \(c\) es un vector de \(1\times 2\) y \(d\) es un escalar, se puede usar el código

(define (make-slo2 a b c [d 0] [ic '(0.0 0.0)])
  (define sys (make-dynsys 1 1))
  (let ([a11 (list-ref a 0)] [a12 (list-ref a 1)]
        [a21 (list-ref a 2)] [a22 (list-ref a 3)]
        [b1 (list-ref b 0)] [b2 (list-ref b 1)]
        [c1 (list-ref c 0)] [c2 (list-ref c 1)])

  ;; system definition
  (sys 'set-state-expr!  '( (+ (* a11 x1) (* a12 x2) (* b1 u) )
                            (+ (* a21 x1) (* a22 x2) (* b2 u) ) ))

  (sys 'set-out-expr!    '( (+ (* c1 x1) (* c2 x2) (* d u)) ))
  (sys 'set-state-symb!  '(x1 x2))
  (sys 'set-prmtr-symb!  '(a11 a12 a21 a22 b1 b2 c1 c2 d))
  (sys 'set-init-cond!   '(0.0 0.0))
  (sys 'set-in-symb!     '(u) )
  (sys 'set-prmtr-val!   (list a11 a12 a21 a22 b1 b2 c1 c2 d) )
  sys))

Una vez teniendo este procedimiento se pueden crear sistemas de segundo orden, especificando sólamente las listas de coeficientes a, b, c y d. Si no se especifica d se le asigna \(0\). Este código se utiliza en uno de los ejemplos.

De la misma manera se podría simular estructuras generales y a partir de ellas generar sistemas particulares.

Una vez conociendo como se simula un esquema clásico de retroalimentación a partir de sus bloques y teniendo procedimientos para generar controladores clásicos a partir de sus parámetros, se puede construir un procedimiento que dado un sistema:

• Reciba los parámetros del controlador clásico.
• Construya (realice las conexiones) el esquema clásico del control.
• Realice la simulación.
• Obtenga la señal del error
• Calcule la norma dos de la señal de error.

Es decir, en términos del PSO, este procedimiento recibiría la posición de una partícula (los parámetros del controlador) y devolvería su fitness. Como se recordará, es el cálculo del fitness el procedimiento que faltaba para aplicar el PSO la sintonización de controladores.

A continuación se muestran algunos ejemplos de la aplicación del PSO a la sintonización de controladores.

En este ejemplo se sintonizará un controlador PD para el sistema con función de transferencia

Una realización de este sistema esta dado por

Usando el procemiento make-slo2 definido arriba, este sistema se puede representar con el código

(define a1  '(0.0 1.0 0.0 -1.0))
(define b  '(0.0 1.0))
(define c  '(0.1 0.0))
(define sys1 (make-slo2 a1 b c))

Se sabe [??Ogata] que en un controlador La constante proporcional y derivativa del controlador son positivas. Además, por lo general la constante proporcional es mayor que la constante derivativa. Teniendo en cuenta esto para generar una particula (controlador) al azar se generan dos números aleatorios; el primero (\(k_{p}\)) está en \([0,20]\) y el segundo (\(k_{d}\)) en \([0,10]\). El código código para generar partículas (controladores) al azar queda

(define (make-pos x1 x2)
  (vector x1 x2))

(define (x1-pos pos)
  (vith pos 0))

(define (x2-pos pos)
  (vith pos 1))

(define (make-potential-sol)
  (make-pos (rnd 0.0 20.0)
            (rnd 0.0 10.0)))

El siguiente procedimiento sim-pd-ctrl toma un systema sys y los parametros de un controlador PD que pueden interpretarse como la posición de una particula; crea el controlador PD realiza la simulación y devuelve los resultados de la simulación.

(define (sim-pd-ctrl sys pos)
  (let ([kp (x1-pos pos)]
        [kd (x2-pos pos)])
    (let ([ ctrl (make-PD kp kd (* kd 10)) ])
      (sim-classic-retro sys ctrl))))

Con todos los procedimientos anteriores, ahora se puede construir el procedimiento calc-fitness. Este procedimiento toma la posición de una particula, es decir los parámetros de un controlador, realiza la simulación, a partir de los resultados de simulación construye la señal de error y calcula su norma-dos

(define (calc-fitness pos)
  (define sal (sim-pd-ctrl sys1 pos))
  (define t (vector-map (lambda (v) (vfirst v)) sal))
  (define e (vector-map (lambda (v) (- (vthird v) (vsecond v)))  sal))
  (+ (norm2 (make-dfnc t e))))

El simulador tiene los procedimientos set-interval! y set-dt! para establecer el intervalo de simulación y el paso de integración. Estos procedimientos se deben ejecutar antes de hacer cualquier simulación. En los resultados de esta sección se utilizó

(sim-prmtr 'set-interval! 0.0 16.0)
(sim-prmtr 'set-dt! 0.1)

Recuerde que la PSO requiere del problema dos cosas:

• El procedimiento make-potential-sol que crea las particulas al azar.
• El procedimiento calc-fitness que le asigna una calificación a cada partícula.

Como ya se tienen estos dos procedimientos, lo que resta es decirle al algoritmo en donde encontrar estos procedimientos y ejecutarlo. La siguiente líneas ejecutan la PSO con 10 partículas y 15 iteraciones (movimientos del ejambre). A cada iteración se realizan 10 simulaciones. Así al finalizar la corrida se habrán realizado 150 simulaciones.

;; test pso-data
(define datos (make-pso-data 15 10 0.8 0.3 0.4))
(define resultado (pso datos))
(nl)
(dp "Resultados:")
(display-swarm resultado)